scripts/verify.py

"""PatchBench row verification + context expansion harness (v1.3).

For each candidate row:
  1. clone the repo at base_commit
  2. apply test_patch -> run rebuild_cmds -> run test_cmds (twice) -> parse per-test results
     verify: every FAIL_TO_PASS test FAILS pre-fix in both runs (a test that does not
     exist because its package fails to build counts as failing -- upstream semantics)
  3. apply gold_patch -> rebuild -> run test_cmds (twice) -> parse
     verify: every FAIL_TO_PASS PASSES and every PASS_TO_PASS still PASSES in both runs
  4. slice a 500-1500 line context window around the buggy files
  5. write a result record; verified rows additionally carry the full patchbench schema

P2P scoping: PASS_TO_PASS is evaluated over tests that PASS in BOTH pre-fix runs in
this environment. Tests upstream lists in P2P that fail pre-fix here (e.g. tests
needing docker/k8s) are recorded in p2p_env_dropped and excluded from grading --
they are not evaluable natively, not regressions.

Native (non-Docker) reproduction of the upstream env:
  - toolchain dirs are prepended to PATH per language
  - the upstream /testbed convention is rewritten to the local checkout path
  - after test_cmds, the harness collects the report files the frameworks wrote
    (surefire/gradle XML, gradle HTML, reports/* go-json dumps) and feeds them to
    the parser alongside console output; the row's print_cmds list is often empty
  - JS/TS: if package.json exists without node_modules, deps are installed with the
    repo's own package manager (detected from lockfile)
  - rust: cargo target dirs are wiped between rows AND all builds go to one shared
    CARGO_TARGET_DIR outside the repo, so disk usage is monitorable and reclaimable

v0.7: TimeoutExpired.stdout/stderr can be bytes (python quirk under capture_output) --
decode before concatenating. This crashed slow maven builds at the 2100s timeout.
v0.8: disk guard. Three rust jobs died on the 50G ephemeral-storage quota mid-row.
v0.9: java report files (surefire/gradle XML + gradle HTML) are collected and fed
to the parser; disk guard is du-based (container quota) and rust builds run under
a du watchdog so a runaway build kills the row, not the pod.
v1.0: used_bytes() timed out on 40G+ du scans (empty output parsed as 0 => guard blind); limit lowered to 32GiB, watchdog polls 20s and reclaims on kill; results pushed to the Hub incrementally after each row so evictions lose at most one row.

v1.1: one dev-profile cargo build grew the shared target dir 6.7G->43G and evicted the pod before the watchdog's du scan could catch it. Fixed both causes: cargo now strips debuginfo and disables incremental compilation in dev/test profiles (no effect on test outcomes, cuts target-dir size several-fold); the in-run watchdog monitors only /tmp/pb-cargo-target (fast du scans even under pressure) at a 20GiB limit instead of scanning all of /tmp at 32GiB.

v1.2: some rows' test_cmds use a nested repo/ layout (cd repo, --manifest-path
repo/Cargo.toml) from the upstream /testbed/repo convention -- a self-symlink now
makes both layouts resolve. Context expansion skips test files referenced by the
test_patch that don't exist on disk instead of crashing the row (eza 0070).

v1.3: the v1.2 repo-layout symlink was created in verify_row BEFORE clean_state, and
clean_state runs git clean -fdxq which deleted it -- noir rows ran with no repo/
self-link and parsed 0 tests. The symlink is now created inside run_tests, after
every clean_state, so both layouts resolve in every phase.

Usage (inside a job with the right language toolchain image):
  python verify.py --lang go --file pilot/candidates/go.jsonl --limit 6
"""
import argparse, json, os, shlex, subprocess, sys, time, traceback

REPO_ID = "rootxhacker/patchbench"
CACHE = "/tmp/cache/repos"
CMD_TIMEOUT_S = 2100
GIT_TIMEOUT_S = 900
MAX_CONTEXT_LINES = 1500
# The 50G limit is a per-container ephemeral-storage quota. df/statvfs report the
# host filesystem and never see it, so disk accounting must be du-based.
CONTAINER_QUOTA_BYTES = 50 * 1024**3
DU_LIMIT_BYTES = 32 * 1024**3
RUST_SHARED_TARGET = "/tmp/pb-cargo-target"
RUST_WATCHDOG_LIMIT_BYTES = 20 * 1024**3  # watchdog limit on the target dir alone

LANG_PATH_PREPEND = {
    "go": ["/usr/local/go/bin"],
    "rust": ["/usr/local/cargo/bin", "/usr/local/rustup/bin"],
    "java": [],
    "javascript": [],
    "typescript": [],
}
EXTS = {"go": [".go"], "rust": [".rs"], "java": [".java"],
        "javascript": [".js", ".mjs"], "typescript": [".ts", ".tsx"]}
SKIP_DIRS = {".git", "node_modules", "vendor", "target", "dist", "build", "__pycache__", ".idea"}

TESTBED = "/testbed"


def run(cmd, cwd, timeout):
    t0 = time.time()
    try:
        p = subprocess.run(["bash", "-c", cmd], cwd=cwd, capture_output=True,
                           timeout=timeout, text=True, errors="replace")
        return p.returncode, (p.stdout or "") + (p.stderr or ""), time.time() - t0
    except subprocess.TimeoutExpired as e:
        so, se = e.stdout or "", e.stderr or ""
        if isinstance(so, bytes):
            so = so.decode("utf-8", "replace")
        if isinstance(se, bytes):
            se = se.decode("utf-8", "replace")
        return 124, so + se + f"\n[TIMEOUT after {timeout}s]", time.time() - t0


def sh(cmds, cwd, timeout=CMD_TIMEOUT_S):
    for c in (cmds or []):
        rc, out, _ = run(c, cwd, timeout)
        if rc != 0:
            return False, out[-4000:]
    return True, ""


def used_bytes():
    """Bytes used in the du-monitored dirs. df/statvfs see the host fs, not the
    per-container ephemeral-storage quota, so du is the only honest measure."""
    _, out, _ = run("du -sb /tmp /usr/local/cargo /root/.cache /var/tmp 2>/dev/null "
                    "| awk '{s+=$1} END {print s+0}'", "/tmp", 900)
    for line in reversed(out.splitlines()):
        s = line.strip()
        if s.isdigit():
            return int(s)
    return 0


def log_disk(tag):
    _, out, _ = run("du -sb /tmp/pb-cargo-target /tmp/cache /usr/local/cargo/registry "
                    "2>/dev/null", "/tmp", 120)
    print(f"[disk:{tag}] container_used={used_bytes() >> 30}G | {out.strip()[:400]}",
          flush=True)


def reclaim_disk():
    """Wipe build artifacts (not .git clones, not the registry) to free space."""
    run("rm -rf /tmp/pb-cargo-target", "/tmp", 600)


def disk_guard(tag):
    """Raise instead of blowing the container's ephemeral-storage quota -- an
    eviction loses all remaining rows."""
    u = used_bytes()
    if u > DU_LIMIT_BYTES:
        print(f"[disk:{tag}] used={u >> 30}G > limit={DU_LIMIT_BYTES >> 30}G, "
              "reclaiming shared target dir", flush=True)
        reclaim_disk()
        u = used_bytes()
    if u > CONTAINER_QUOTA_BYTES - 2 * 1024**3:
        raise RuntimeError(f"disk_pressure: used={u >> 30}G after reclaim "
                           f"(tag={tag}); aborting row to save the remaining rows")


def apply_patch(text, cwd):
    pf = os.path.join(cwd, ".pb_patch")
    with open(pf, "w") as f:
        f.write(text)
    rc, out, _ = run(f"git apply --whitespace=nowarn < {pf}", cwd, 120)
    if rc == 0:
        return None
    rc2, out2, _ = run(f"patch -p1 --forward --no-backup-if-mismatch < {pf}", cwd, 120)
    if rc2 == 0:
        return None
    return (out + out2)[-2000:]


def clean_state(repo_dir, lang=None):
    run("git checkout -f HEAD -- . && git clean -fdxq", repo_dir, 120)
    if lang == "rust":
        run("find . -name target -type d -prune -exec rm -rf {} +", repo_dir, 300)
        run(f"rm -rf {RUST_SHARED_TARGET}", "/tmp", 300)


def get_parser(row):
    ns = {}
    src = row.get("log_parser") or ""
    assert "def parser" in src, f"no log_parser for {row['id']}"
    exec(src, ns)
    return ns["parser"]


def ensure_js_deps(repo_dir):
    """Upstream JS/TS images ship node_modules; natively we must install them.
    Detect the package manager from the lockfile. Returns error string or None."""
    if not os.path.exists(os.path.join(repo_dir, "package.json")):
        return None
    if os.path.exists(os.path.join(repo_dir, "node_modules")):
        return None
    if os.path.exists(os.path.join(repo_dir, "pnpm-lock.yaml")):
        cmds = ["corepack enable 2>/dev/null; corepack prepare pnpm@latest --activate 2>/dev/null || npm install -g pnpm",
                "pnpm install --frozen-lockfile || pnpm install"]
    elif os.path.exists(os.path.join(repo_dir, "yarn.lock")):
        cmds = ["yarn install --frozen-lockfile || yarn install"]
    elif os.path.exists(os.path.join(repo_dir, "package-lock.json")):
        cmds = ["npm ci || npm install"]
    else:
        cmds = ["npm install"]
    ok, err = sh(cmds, repo_dir, 1800)
    return None if ok else f"js deps install failed: {err}"


DEFAULT_REPORT_FINDS = [r'for f in reports/*; do [ -f "$f" ] && cat "$f"; done']
REPORT_FINDS = {
    "java": DEFAULT_REPORT_FINDS + [
        r'find . \( -path "*surefire-reports*" -o -path "*failsafe-reports*" '
        r'-o -path "*build/test-results*" \) -name "*.xml" -type f '
        r'| sort | head -400 | while read -r f; do cat "$f"; done',
        r'find . -path "*reports/tests*" -name "*.html" -type f '
        r'| sort | head -200 | while read -r f; do cat "$f"; done',
    ],
}


def collect_reports(repo_dir, lang):
    """Cat the report files the test frameworks wrote (per-language find commands)
    into the output stream the log parser sees. Each output capped at 8M chars."""
    outs = []
    for cmd in REPORT_FINDS.get(lang, DEFAULT_REPORT_FINDS):
        _, o, _ = run(cmd, repo_dir, 300)
        if o.strip():
            outs.append(o[:8_000_000])
    return "\n".join(outs)


WATCHDOG_LANGS = {"rust"}


def watchdog_wrap(cmd):
    """Run cmd in its own process group under a du watchdog. setsid is critical:
    without it cargo survives `kill -9 -- -$pid` and keeps writing to the quota.
    Build runs in FOREGROUND; the du monitor polls in BACKGROUND; `wait $pid`
    decides the exit code (avoids the kill -0 zombie-hang on fast commands)."""
    limit = DU_LIMIT_BYTES
    q = shlex.quote(cmd)
    return (
        f"printf %s {q} > /tmp/pb_cmd.sh\n"
        "setsid bash /tmp/pb_cmd.sh & pid=$!\n"
        "( while kill -0 $pid 2>/dev/null; do\n"
        "    used=$(du -sb /tmp/pb-cargo-target 2>/dev/null "
        "| awk '{s+=$1} END {print s+0}')\n"
        f"    if [ \"$used\" -gt {RUST_WATCHDOG_LIMIT_BYTES} ]; then\n"
        "      kill -9 -- -$pid 2>/dev/null\n"
        "      echo \"[DISK_WATCHDOG] killed build: container=${used}B\"\n"
        "      rm -rf /tmp/pb-cargo-target 2>/dev/null\n"
        "      exit 0\n"
        "    fi\n"
        "    sleep 20 >/dev/null 2>&1\n"
        "  done ) & mon=$!\n"
        "wait $pid; rc=$?\n"
        "kill $mon 2>/dev/null\n"
        "exit $rc\n"
    )


def run_tests(row, repo_dir, lang, phase_tag=""):
    """Run rebuild_cmds, test_cmds, print_cmds, then collect the report files the
    test frameworks wrote (surefire/gradle XML, gradle HTML, reports/*) and feed
    them to the log parser. Returns (tests_dict, combined_output_tail)."""
    # v1.3: rows whose cmds reference a nested repo/ layout need a self-symlink,
    # and it must exist AFTER every clean_state (which git-cleans it away).
    _cmds = (row.get("test_cmds") or []) + (row.get("rebuild_cmds") or []) + (row.get("print_cmds") or [])
    if any(("repo/" in c) or c.rstrip().endswith("/repo") for c in _cmds):
        _sl = os.path.join(repo_dir, "repo")
        if not (os.path.islink(_sl) or os.path.exists(_sl)):
            os.symlink(repo_dir, _sl)
            print("repo-layout symlink created", flush=True)
    disk_guard(f"{phase_tag}-pre")
    parser = get_parser(row)
    dep_err = ensure_js_deps(repo_dir)
    wrap = watchdog_wrap if lang in WATCHDOG_LANGS else (lambda c: c)
    for c in (row.get("rebuild_cmds") or []):
        run(wrap(c), repo_dir, CMD_TIMEOUT_S)
    run("mkdir -p reports", repo_dir, 30)
    out = ""
    if dep_err:
        out += dep_err + "\n"
    for c in (row.get("test_cmds") or []):
        _, o, _ = run(wrap(c), repo_dir, CMD_TIMEOUT_S)
        out += o + "\n"
    for c in (row.get("print_cmds") or []):
        _, o, _ = run(c, repo_dir, 120)
        out += o + "\n"
    out += collect_reports(repo_dir, lang) + "\n"
    disk_guard(f"{phase_tag}-post")
    log_disk(f"{phase_tag}-post")
    return parser(out), out[-3000:]


def grade(tests, want, expect, allow_missing=False):
    """allow_missing=True for pre-fix 'fail' checks: a test that never ran (build
    failure in its package) is not passing, which is what upstream means by fail."""
    missing, wrong = [], []
    for t in want:
        s = tests.get(t)
        if s is None:
            if not allow_missing:
                missing.append(t)
        elif s != expect:
            wrong.append((t, s))
    return (not missing and not wrong), {"missing": len(missing), "wrong": wrong[:10],
                                         "missing_ids": missing[:5], "parsed_count": len(tests)}


def touched_paths(patch):
    paths = set()
    for line in patch.splitlines():
        if line.startswith("+++ b/"):
            paths.add(line[6:].split("\t")[0])
        elif line.startswith("--- a/"):
            paths.add(line[6:].split("\t")[0])
    return {p for p in paths if p != "/dev/null"}


def collect_context(repo_dir, buggy_paths, test_paths, lang, cap=MAX_CONTEXT_LINES):
    exts = tuple(EXTS[lang])
    prio = {"buggy": [], "same_dir": [], "tests": [], "other": []}
    buggy_dirs = {os.path.dirname(p) for p in buggy_paths}
    for root, dirs, files in os.walk(repo_dir):
        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
        for fn in files:
            if not fn.endswith(exts):
                continue
            p = os.path.relpath(os.path.join(root, fn), repo_dir)
            try:
                n = sum(1 for _ in open(os.path.join(repo_dir, p), errors="replace"))
            except OSError:
                continue
            if n > 600:
                continue
            if p in buggy_paths:
                prio["buggy"].append(p)
            elif p in test_paths:
                prio["tests"].append(p)
            elif os.path.dirname(p) in buggy_dirs:
                prio["same_dir"].append(p)
            else:
                prio["other"].append(p)
    chosen, total = [], 0
    for group in ["buggy", "same_dir", "tests", "other"]:
        for p in sorted(prio[group]):
            with open(os.path.join(repo_dir, p), errors="replace") as f:
                content = f.read()
            n = content.count("\n") + 1
            if total + n > cap:
                continue
            chosen.append({"path": p, "content": content})
            total += n
        if total > cap * 0.9:
            break
    return chosen, total


def verify_row(row, lang):
    t0 = time.time()
    rec = {"id": row["id"], "repo": row["repo"], "base_commit": row["base_commit"],
           "status": "env_failed", "verify_status": None, "error": None, "timing": {}}
    repo_dir = os.path.join(CACHE, row["repo"].replace("/", "__"))
    sha = row["base_commit"]
    if not os.path.isdir(repo_dir):
        os.makedirs(CACHE, exist_ok=True)
        rc, out, _ = run(f"git clone --filter=blob:none https://github.com/{row['repo']}.git {repo_dir}", CACHE, GIT_TIMEOUT_S)
        if rc != 0:
            rec["error"] = f"clone failed: {out[-500:]}"
            return rec
    for cmd in [f"git fetch origin {sha} --quiet", f"git checkout -f {sha} --quiet"]:
        rc, out, _ = run(cmd, repo_dir, GIT_TIMEOUT_S)
        if rc != 0:
            rec["error"] = f"checkout failed: {out[-500:]}"
            return rec
    log_disk(f"cloned:{row['id']}")

    if lang == "rust":
        os.environ["CARGO_TARGET_DIR"] = RUST_SHARED_TARGET
        # v1.1: a dev-profile build with debuginfo hit 43G on the 50G container
        # quota. Stripping debuginfo and disabling incremental compilation has
        # no effect on test outcomes, only on build artifacts.
        os.environ["CARGO_PROFILE_DEV_DEBUG"] = "0"
        os.environ["CARGO_PROFILE_TEST_DEBUG"] = "0"
        os.environ["CARGO_INCREMENTAL"] = "0"
    os.environ["PATH"] = ":".join(LANG_PATH_PREPEND.get(lang, [])) + ":" + os.environ["PATH"]
    def tb(cmds):
        return [c.replace(TESTBED, repo_dir) for c in (cmds or [])]
    row = {**row, "test_cmds": tb(row["test_cmds"]), "rebuild_cmds": tb(row.get("rebuild_cmds")),
           "print_cmds": tb(row.get("print_cmds"))}
    rec["test_cmds"], rec["rebuild_cmds"], rec["print_cmds"] = row["test_cmds"], row["rebuild_cmds"], row["print_cmds"]
    rec["timing"]["setup"] = round(time.time() - t0, 1)

    # ---- PRE-FIX (twice) ----
    clean_state(repo_dir, lang)
    err = apply_patch(row["test_patch"], repo_dir)
    if err:
        rec["error"] = f"test_patch failed to apply: {err}"
        return rec
    pre_runs = []
    for i in range(2):
        s = time.time()
        tests, tail = run_tests(row, repo_dir, lang, f"pre{i}:{row['id']}")
        pre_runs.append((tests, tail))
        rec["timing"][f"pre_test_{i}"] = round(time.time() - s, 1)
    pre_detail = grade(pre_runs[0][0], row["fail_to_pass"], "fail", allow_missing=True)[1]
    f2p_ok_pre = all(grade(t, row["fail_to_pass"], "fail", allow_missing=True)[0] for t, _ in pre_runs)
    rec["f2p_pre_ok"], rec["pre_detail"] = f2p_ok_pre, pre_detail

    # P2P scoped to this environment: keep only tests that pass in BOTH pre-fix runs
    p2p_scoped = [t for t in row["pass_to_pass"]
                  if pre_runs[0][0].get(t) == "pass" and pre_runs[1][0].get(t) == "pass"]
    rec["p2p_env_dropped_count"] = len(row["pass_to_pass"]) - len(p2p_scoped)

    # ---- POST-FIX (twice) ----
    clean_state(repo_dir, lang)
    err = apply_patch(row["test_patch"], repo_dir)
    if err:
        rec["error"] = f"test_patch re-apply failed: {err}"
        return rec
    err = apply_patch(row["gold_patch"], repo_dir)
    if err:
        rec["error"] = f"gold_patch failed to apply: {err}"
        return rec
    post_runs = []
    for i in range(2):
        s = time.time()
        tests, tail = run_tests(row, repo_dir, lang, f"post{i}:{row['id']}")
        post_runs.append((tests, tail))
        rec["timing"][f"post_test_{i}"] = round(time.time() - s, 1)
    f2p_ok_post = all(grade(t, row["fail_to_pass"], "pass")[0] for t, _ in post_runs)
    p2p_ok_post = all(grade(t, p2p_scoped, "pass")[0] for t, _ in post_runs)
    rec["f2p_post_ok"], rec["p2p_post_ok"] = f2p_ok_post, p2p_ok_post
    rec["post_detail"] = grade(post_runs[0][0], row["fail_to_pass"], "pass")[1]

    rec["timing"]["total"] = round(time.time() - t0, 1)
    rec["raw_tail"] = pre_runs[0][1][-1500:]

    if len(pre_runs[0][0]) == 0:
        rec["status"] = "no_tests_parsed"
    elif not f2p_ok_pre:
        rec["status"] = "f2p_not_failing_prefix"
    elif not f2p_ok_post:
        rec["status"] = "f2p_not_passing_postfix"
    elif not p2p_ok_post:
        rec["status"] = "p2p_regression"
    else:
        rec["status"] = "verified"

    if rec["status"] == "verified":
        buggy = touched_paths(row["gold_patch"])
        tfiles = touched_paths(row["test_patch"])
        ctx, nlines = collect_context(repo_dir, buggy, tfiles, lang)
        rec["verify_status"] = "verified"
        rec["context_files"] = ctx
        rec["context_lines"] = nlines
        rec["buggy_files"] = sorted(buggy - tfiles)
        rec["test_files"] = []
        for _p in sorted(tfiles):
            try:
                rec["test_files"].append({"path": _p, "content": open(os.path.join(repo_dir, _p), errors="replace").read()})
            except OSError:
                pass  # v1.2: missing files are silently skipped
        rec["eval"] = {"test_cmds": row["test_cmds"], "print_cmds": row.get("print_cmds"),
                       "log_parser": row["log_parser"], "rebuild_cmds": row.get("rebuild_cmds")}
    return rec


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--lang", required=True)
    ap.add_argument("--file", required=True)
    ap.add_argument("--limit", type=int, default=6)
    ap.add_argument("--out", default=None)
    args = ap.parse_args()

    from huggingface_hub import hf_hub_download, HfApi
    token = os.environ.get("HF_TOKEN")
    cand_path = hf_hub_download(REPO_ID, args.file, repo_type="dataset", token=token)
    rows = [json.loads(l) for l in open(cand_path)]
    api = HfApi(token=token)
    out_path = args.out or f"/tmp/results_{args.lang}.jsonl"
    verified_path = f"/tmp/verified_{args.lang}.jsonl"

    done = 0
    with open(out_path, "w") as fo, open(verified_path, "w") as fv:
        for row in rows[:args.limit]:
            try:
                rec = verify_row(row, row["language"])
            except Exception as e:
                rec = {"id": row["id"], "status": "harness_crash", "error": repr(e)[:500],
                       "tb": traceback.format_exc()[-1500:]}
            fo.write(json.dumps(rec) + "\n")
            fo.flush()
            if rec.get("verify_status") == "verified":
                fv.write(json.dumps({**row, "result": {k: rec[k] for k in
                         ["timing", "context_lines", "buggy_files"]}}) + "\n")
                fv.flush()
            print(f"[{row['id']}] {rec['status']} "
                  f"pre_ok={rec.get('f2p_pre_ok')} post_ok={rec.get('f2p_post_ok')} "
                  f"p2p_ok={rec.get('p2p_post_ok')} parsed={rec.get('pre_detail', {}).get('parsed_count', '?')} "
                  f"err={(rec.get('error') or '')[:200]}", flush=True)
            if row["language"] == "rust":
                run(f"rm -rf {RUST_SHARED_TARGET}", "/tmp", 600)
            done += 1
            try:
                api.upload_file(path_or_fileobj=out_path, path_in_repo=f"pilot/results/{args.lang}.jsonl",
                                repo_id=REPO_ID, repo_type="dataset", commit_message=f"pilot {args.lang}: incremental {done} rows")
                if os.path.getsize(verified_path) > 0:
                    api.upload_file(path_or_fileobj=verified_path, path_in_repo=f"pilot/verified/{args.lang}.jsonl",
                                    repo_id=REPO_ID, repo_type="dataset", commit_message=f"pilot {args.lang}: verified {done}")
            except Exception as pe:
                print(f"[push] incremental push failed: {pe}", flush=True)

    for path, dest in [(out_path, f"pilot/results/{args.lang}.jsonl"),
                       (verified_path, f"pilot/verified/{args.lang}.jsonl")]:
        if os.path.getsize(path) > 0:
            api.upload_file(path_or_fileobj=path, path_in_repo=dest, repo_id=REPO_ID,
                            repo_type="dataset", commit_message=f"pilot {args.lang}: {dest.split('/')[-2]}")
    counts = {}
    for l in open(out_path):
        counts[json.loads(l)["status"]] = counts.get(json.loads(l)["status"], 0) + 1
    print(f"VERIFY_DONE lang={args.lang} rows={done} statuses={json.dumps(counts)}", flush=True)


if __name__ == "__main__":
    main()