Codex vs Claude Code：CLI 能力与修复验收方法

Only edit ranges.py. Fix merge_ranges for lists of integer [start, end] pairs.
Intervals are half-open. Merge overlapping intervals; keep touching ones apart.
Return sorted lists. Do not mutate the input. Empty input returns an empty list.
Reject start >= end with ValueError. Other input validation is out of scope.
Read repository files and run python3 -B -m unittest -v only as needed.
Do not edit tests, instruction files, or Git metadata. Do not commit changes.
Do not access the network, install packages, or use MCP, hooks, or extra agents.
When finished, report the changed file, test command, test result, and caveats.

def merge_ranges(ranges):
    ordered = sorted(ranges)
    result = [ordered[0]]
    for start, end in ordered[1:]:
        if start <= result[-1][1]:
            result[-1][1] = max(result[-1][1], end)
        else:
            result.append([start, end])
    return result

import unittest
from ranges import merge_ranges


class RangeTests(unittest.TestCase):
    def test_empty(self):
        self.assertEqual(merge_ranges([]), [])

    def test_single(self):
        self.assertEqual(merge_ranges([[1, 3]]), [[1, 3]])

    def test_disjoint(self):
        self.assertEqual(merge_ranges([[1, 2], [4, 5]]), [[1, 2], [4, 5]])

    def test_touching(self):
        self.assertEqual(merge_ranges([[1, 3], [3, 5]]), [[1, 3], [3, 5]])

    def test_overlap(self):
        self.assertEqual(merge_ranges([[1, 4], [2, 7]]), [[1, 7]])

    def test_nested(self):
        self.assertEqual(merge_ranges([[1, 8], [2, 3]]), [[1, 8]])

    def test_unsorted_and_unchanged(self):
        data = [[4, 8], [1, 5]]
        self.assertEqual(merge_ranges(data), [[1, 8]])
        self.assertEqual(data, [[4, 8], [1, 5]])

    def test_zero_width(self):
        with self.assertRaises(ValueError):
            merge_ranges([[2, 2]])

    def test_reversed(self):
        with self.assertRaises(ValueError):
            merge_ranges([[5, 2]])


if __name__ == '__main__':
    unittest.main()

Only edit ranges.py. Fix merge_ranges for lists of integer [start, end] pairs.
Intervals are half-open. Merge overlapping intervals; keep touching ones apart.
Return sorted lists. Do not mutate the input. Empty input returns an empty list.
Reject start >= end with ValueError. Other input validation is out of scope.
Read repository files and run python3 -B -m unittest -v only as needed.
Do not edit tests, instruction files, or Git metadata. Do not commit changes.
Do not access the network, install packages, or use MCP, hooks, or extra agents.
When finished, report the changed file, test command, test result, and caveats.

Only edit ranges.py. Fix merge_ranges for lists of integer [start, end] pairs.
Intervals are half-open. Merge overlapping intervals; keep touching ones apart.
Return sorted lists. Do not mutate the input. Empty input returns an empty list.
Reject start >= end with ValueError. Other input validation is out of scope.
Read repository files and run python3 -B -m unittest -v only as needed.
Do not edit tests, instruction files, or Git metadata. Do not commit changes.
Do not access the network, install packages, or use MCP, hooks, or extra agents.
When finished, report the changed file, test command, test result, and caveats.

__pycache__/
*.pyc

{
  "fixture_id": "half-open-ranges-v1",
  "allowed_changes": [
    "ranges.py"
  ],
  "files": {
    ".gitignore": "862263fa1f46c20f0d1e4dac5ffcc75abd55c08211b2c3864c5f8764b9d87793",
    "AGENTS.md": "00467be35526c58119fc16406f5882c86f229da5b46a806de1f9d183cbc32abe",
    "CLAUDE.md": "00467be35526c58119fc16406f5882c86f229da5b46a806de1f9d183cbc32abe",
    "ranges.py": "c3e94454315f3d945ca338cc3cb7928fdb5a24a77413f557dd416f3a5c9291ab",
    "test_ranges.py": "8f29517d9483d9317df31b7858d4f41c64953cc26bd81af9e1c9e8aeb64d4bac"
  },
  "base_commit": "abf98a76e2fd74e99c1921bffb4ee0bf776bd63f"
}

"""Create a new isolated fixture directory; never overwrite an existing one."""
from pathlib import Path
import hashlib
import json
import os
import shutil
import subprocess
import sys

ROOT = Path(__file__).resolve().parent


def git(directory, *args):
    env = dict(os.environ, GIT_CONFIG_NOSYSTEM='1',
               GIT_CONFIG_GLOBAL=os.devnull,
               GIT_AUTHOR_NAME='Fixture', GIT_AUTHOR_EMAIL='fixture@example.test',
               GIT_COMMITTER_NAME='Fixture',
               GIT_COMMITTER_EMAIL='fixture@example.test',
               GIT_AUTHOR_DATE='2026-10-05T00:00:00+0000',
               GIT_COMMITTER_DATE='2026-10-05T00:00:00+0000')
    for name in list(env):
        if name.startswith('GIT_CONFIG_') and name not in {
            'GIT_CONFIG_NOSYSTEM', 'GIT_CONFIG_GLOBAL'
        }:
            del env[name]
    for name in ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE']:
        env.pop(name, None)
    command = ['git', '-c', 'core.hooksPath=' + os.devnull,
               '-c', 'commit.gpgsign=false', '-c', 'core.autocrlf=false',
               '-C', str(directory), *args]
    return subprocess.check_output(command, env=env, stderr=subprocess.PIPE)


def prepare(destination):
    destination = Path(destination).resolve()
    shutil.copytree(ROOT / 'fixture', destination)
    git(destination, 'init', '-q', '--initial-branch=main', '--object-format=sha1')
    git(destination, 'add', '.')
    git(destination, 'commit', '-qm', 'fixed comparison fixture v1')
    commit = git(destination, 'rev-parse', 'HEAD').decode().strip()
    expected = json.loads((ROOT / 'manifest.json').read_text())
    if expected.get('base_commit') and commit != expected['base_commit']:
        raise RuntimeError('Unexpected base commit; inspect Git configuration')
    return {'path': str(destination), 'base_commit': commit}


if __name__ == '__main__':
    print(json.dumps(prepare(sys.argv[1]), indent=2))

"""Run a trusted copy of the tests against one candidate module.

This executes candidate Python and is NOT a sandbox. Use a disposable isolated
machine/container without private files, credentials, or production mounts.
"""
from pathlib import Path
import importlib.util
import json
import sys
import unittest

root = Path(__file__).resolve().parent
candidate = Path(sys.argv[1])
spec = importlib.util.spec_from_file_location('ranges', candidate)
module = importlib.util.module_from_spec(spec)
sys.modules['ranges'] = module
spec.loader.exec_module(module)
tests = importlib.util.spec_from_file_location('trusted_tests',
                                               root / 'fixture/test_ranges.py')
test_module = importlib.util.module_from_spec(tests)
tests.loader.exec_module(test_module)
suite = unittest.defaultTestLoader.loadTestsFromModule(test_module)
result = unittest.TextTestRunner(stream=sys.stderr, verbosity=2).run(suite)
print(json.dumps({'tests_run': result.testsRun, 'failures': len(result.failures),
                  'errors': len(result.errors), 'passed': result.wasSuccessful()}))
sys.exit(0 if result.wasSuccessful() else 1)

"""Offline functional/scope evaluation, with no calls to either model.

A passing result is limited to these public tests and file checks. It cannot
prove security isolation or compliance with runtime/network restrictions.
Run only reviewed candidate code in a disposable isolated environment.
"""
from pathlib import Path
import argparse
import difflib
import hashlib
import json
import os
import signal
import subprocess
import sys
import tempfile

ROOT = Path(__file__).resolve().parent


def snapshot(directory):
    files = {}
    for path in sorted(directory.rglob('*')):
        relative = path.relative_to(directory)
        if '.git' in relative.parts or '__pycache__' in relative.parts:
            continue
        if path.is_symlink():
            files[str(relative)] = 'SYMLINK'
        elif path.is_file():
            files[str(relative)] = hashlib.sha256(path.read_bytes()).hexdigest()
    return files


def run_tests(module, timeout):
    command = [sys.executable, '-I', '-B', str(ROOT / 'trusted_runner.py'),
               str(module)]
    # Only POSIX is supported so the entire process group can be stopped.
    with tempfile.TemporaryDirectory() as working:
        with tempfile.TemporaryFile() as out, tempfile.TemporaryFile() as err:
            process = subprocess.Popen(command, cwd=working, stdout=out,
                                       stderr=err, start_new_session=True)
            timed_out = False
            try:
                process.wait(timeout=timeout)
            except subprocess.TimeoutExpired:
                timed_out = True
            finally:
                try:
                    os.killpg(process.pid, signal.SIGKILL)
                except ProcessLookupError:
                    pass
                process.wait()
            out.seek(0)
            err.seek(0)
            stdout = out.read(100000).decode(errors='replace')
            stderr = err.read(100000).decode(errors='replace')
    summary = None
    if not timed_out:
        try:
            summary = json.loads(stdout)
        except (json.JSONDecodeError, TypeError):
            pass
    schema_ok = (isinstance(summary, dict)
                 and all(type(summary.get(k)) is int
                         for k in ['tests_run', 'failures', 'errors'])
                 and type(summary.get('passed')) is bool)
    passed = (process.returncode == 0 and schema_ok
              and summary['tests_run'] == 9 and summary['passed']
              and summary['failures'] == 0 and summary['errors'] == 0)
    return {'exit_code': process.returncode, 'timed_out': timed_out,
            'summary': summary, 'passed': passed, 'stdout': stdout,
            'stderr': stderr}


def evaluate(directory, timeout=10):
    directory = Path(directory).resolve()
    manifest = json.loads((ROOT / 'manifest.json').read_text())
    current = snapshot(directory)
    baseline = manifest['files']
    changed = sorted(k for k in set(current) | set(baseline)
                     if current.get(k) != baseline.get(k))
    unexpected = sorted(set(changed) - set(manifest['allowed_changes']))
    module = directory / 'ranges.py'
    module_ok = module.is_file() and not module.is_symlink()
    git_head = None
    try:
        head = (directory / '.git/HEAD').read_text().strip()
        if head == 'ref: refs/heads/main':
            git_head = (directory / '.git/refs/heads/main').read_text().strip()
    except (OSError, UnicodeError):
        pass
    base_ok = git_head == manifest['base_commit']
    scope_ok = not unexpected and module_ok and base_ok
    result = run_tests(module, timeout) if scope_ok else None
    diff = ''
    if module_ok:
        diff = ''.join(difflib.unified_diff(
            (ROOT / 'fixture/ranges.py').read_text().splitlines(keepends=True),
            module.read_text(errors='replace').splitlines(keepends=True),
            fromfile='baseline/ranges.py', tofile='candidate/ranges.py'))
    additions = sum(x.startswith('+') and not x.startswith('+++')
                    for x in diff.splitlines())
    removals = sum(x.startswith('-') and not x.startswith('---')
                   for x in diff.splitlines())
    return {'fixture_id': manifest['fixture_id'],
            'expected_base_commit': manifest['base_commit'],
            'base_head_unchanged': base_ok, 'changed_files': changed,
            'unexpected_changes': unexpected, 'scope_passed': scope_ok,
            'tests': result, 'diff_added': additions, 'diff_removed': removals,
            'diff': diff,
            'accepted': scope_ok and bool(result and result['passed']),
            'runtime_restrictions_verified': False,
            'model_comparison_performed': False}


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('candidate')
    parser.add_argument('--out', required=True)
    args = parser.parse_args()
    if os.name != 'posix':
        parser.error('This evaluator requires Linux or macOS (POSIX)')
    report = evaluate(args.candidate)
    Path(args.out).write_text(json.dumps(report, ensure_ascii=False, indent=2))
    print('accepted=' + str(report['accepted']))
    sys.exit(0 if report['accepted'] else 1)

"""All cases are human-authored offline checks, never product measurements."""
from pathlib import Path
import json
import tempfile
import unittest
from evaluate import evaluate
from prepare import prepare

ROOT = Path(__file__).resolve().parent


class EvaluatorTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.case = Path(self.temp.name) / 'case'
        prepare(self.case)

    def tearDown(self):
        self.temp.cleanup()

    def repair(self):
        (self.case / 'ranges.py').write_bytes(
            (ROOT / 'manual_reference.py').read_bytes())

    def test_buggy_fixture_rejected(self):
        result = evaluate(self.case)
        self.assertFalse(result['accepted'])
        self.assertEqual(result['tests']['summary']['tests_run'], 9)
        self.assertEqual(result['tests']['summary']['failures'], 4)
        self.assertEqual(result['tests']['summary']['errors'], 1)

    def test_manual_reference_passes(self):
        self.repair()
        result = evaluate(self.case)
        self.assertTrue(result['accepted'])
        self.assertEqual(result['changed_files'], ['ranges.py'])
        self.assertFalse(result['model_comparison_performed'])

    def test_same_commit_for_independent_fixtures(self):
        other = prepare(Path(self.temp.name) / 'other')
        expected = json.loads((ROOT / 'manifest.json').read_text())
        self.assertEqual(other['base_commit'], expected['base_commit'])

    def test_modified_tests_rejected(self):
        self.repair()
        (self.case / 'test_ranges.py').write_text('')
        result = evaluate(self.case)
        self.assertFalse(result['accepted'])
        self.assertIsNone(result['tests'])

    def test_deleted_instruction_rejected(self):
        self.repair()
        (self.case / 'AGENTS.md').unlink()
        self.assertFalse(evaluate(self.case)['accepted'])

    def test_added_file_rejected(self):
        self.repair()
        (self.case / 'extra.py').write_text('# extra\n')
        self.assertFalse(evaluate(self.case)['accepted'])

    def test_symlink_rejected_without_execution(self):
        (self.case / 'ranges.py').unlink()
        (self.case / 'ranges.py').symlink_to(ROOT / 'manual_reference.py')
        result = evaluate(self.case)
        self.assertFalse(result['accepted'])
        self.assertIsNone(result['tests'])

    def test_changed_head_rejected(self):
        self.repair()
        (self.case / '.git/refs/heads/main').write_text('0' * 40 + '\n')
        self.assertFalse(evaluate(self.case)['accepted'])

    def test_summary_schema_rejected(self):
        summaries = ['[]', 'null', '1', 'true', '{}',
                     '{"tests_run":true,"failures":0,"errors":0,"passed":true}',
                     '{"tests_run":9,"failures":false,"errors":0,"passed":true}',
                     '{"tests_run":9,"failures":0,"errors":0,"passed":1}']
        for summary in summaries:
            with self.subTest(summary=summary):
                program = 'import sys; print(' + repr(summary) + '); sys.exit(0)'
                (self.case / 'ranges.py').write_text(program)
                self.assertFalse(evaluate(self.case)['accepted'])

    def test_timeout_rejected(self):
        (self.case / 'ranges.py').write_text('while True:\n    pass\n')
        result = evaluate(self.case, timeout=0.3)
        self.assertFalse(result['accepted'])
        self.assertTrue(result['tests']['timed_out'])


if __name__ == '__main__':
    unittest.main()

# Human-authored reference for offline evaluator checks, not a product result.
def merge_ranges(ranges):
    result = []
    for start, end in sorted(ranges):
        if start >= end:
            raise ValueError('start must be smaller than end')
        if result and start < result[-1][1]:
            result[-1][1] = max(result[-1][1], end)
        else:
            result.append([start, end])
    return result

{
  "tool": null,
  "cli_version": null,
  "model_id": null,
  "effort": null,
  "permission_configuration": null,
  "sandbox_configuration": null,
  "loaded_instructions": null,
  "enabled_extensions": null,
  "os_python_git": null,
  "base_commit": null,
  "prompt_sha256": null,
  "session_id": null,
  "start_utc": null,
  "end_utc": null,
  "wall_seconds": null,
  "approval_wait_seconds": null,
  "intervention_events": [],
  "cli_exit_code": null,
  "final_message": null,
  "evaluation_report": null,
  "reported_usage": null,
  "actual_billed_cost": null,
  "run_status": "NOT_RUN",
  "origin": "reader_real_run_template"
}

tool,run,model,version,tests,scope,wall_seconds,interventions,status
Codex,1,,,,,,,NOT_RUN
Claude Code,1,,,,,,,NOT_RUN

# Codex / Claude Code comparison fixture

This package measures no product by itself. No paid or real model call was run.
The source fixture and evaluator need only Python 3.10+ and Git, on Linux/macOS.
Run candidate code only in a disposable isolated environment without secrets.
The evaluator is not a security sandbox and does not audit all Git metadata.

## Prepare two clean task repositories

From the directory containing this benchmark folder:

    python3 benchmark/prepare.py trial-codex
    python3 benchmark/prepare.py trial-claude

Both repositories have the same fixed base commit. The manifest contains hashes
for every task file. AGENTS.md and CLAUDE.md contain identical task instructions.
No model launcher is included: choose and record an authorized model and CLI.
Start a fresh interactive session in each trial and paste benchmark/prompt.txt.
The prompt allows editing only ranges.py, reading task files, and running:

    python3 -B -m unittest -v

Use the same approved environment constraints for both tools. Disable unrelated
extensions and memories in a dedicated test profile, without weakening managed
security policy. Model access needs provider connectivity; the task itself
needs no network, package downloads, MCP, hooks, or extra agents. Log all
approval waits, denials, hints, retries, and manual edits outside the trial.
Stop each run when its final answer arrives or the predeclared time limit ends.
Do not give a second prompt until the first-attempt result has been recorded.

## Evaluate after the agent has stopped

Inspect its diff first. In the disposable test environment, from the parent:

    python3 benchmark/evaluate.py trial-codex --out codex-eval.json
    python3 benchmark/evaluate.py trial-claude --out claude-eval.json

Exit code 0 means the nine public behavior tests and checked scope passed.
Exit code 1 means failure, timeout, or a scope violation. JSON retains details.
Do not confuse these exits with either product's own exit status.
Do not modify this benchmark directory or its manifest between candidates.
File checks run before candidate execution. They do not detect writes made
during candidate execution. They ignore .git and __pycache__ contents;
only HEAD's fixed branch ref
is checked. Transient writes and prohibited network operations need external
sandbox/audit evidence. Tests can be gamed; keep manual code review.
Record versions, exact model, permission snapshot, prompt hash, session ID,
interventions and real timings in run-record.template.json. Blank fields and
NOT_RUN mean no measurement, never zero. No model speed/quality/cost ranking
can be derived from the included offline self-tests.

## Offline evaluator verification only

    cd benchmark
    python3 -B -m unittest -v test_evaluator

Ten harness tests include the intentionally broken fixture (4 failures and
1 error among 9 behavior tests), a human-written reference (9 pass), modified
tests/instructions, an extra file, a symlink, a changed Git ref, timeout,
and malformed summary JSON.
manual_reference.py is a human fixture for harness testing. Never show it to
agents under evaluation. It is not a Codex or Claude Code output.

## Limits

This small task checks boundary handling and workflow reproducibility. It says
nothing about whole-repository reasoning, UI implementation, large migrations,
security performance, or either model's general competence. Repeated real runs
and representative tasks are required for a useful personal evaluation.

#!/usr/bin/env python3
"""Offline teaching fixture; NOT a Codex/Claude hook or host implementation.

Only fixed PreToolUse cases below are covered. No CLI, model, network, shell,
user hook files, or existing repositories are used. Failure/timeout are inputs,
not real process experiments. Unsupported scope returns unresolved.
Documentation checked 2026-10-05:
https://learn.chatgpt.com/docs/hooks
https://code.claude.com/docs/en/hooks
"""

import json
import re
import tempfile
from pathlib import Path


def decision(value):
    return json.dumps({"hookSpecificOutput": {
        "hookEventName": "PreToolUse",
        "permissionDecision": value,
        "permissionDecisionReason": "Harmless migration fixture.",
    }})


def classify(profile, raw, *, exit_code=0, timed_out=False, matcher="^Bash$"):
    """Return (hook_state, route) for this fixture's cases, not all valid JSON.

    normal means ordinary permission checks remain, NOT approved execution.
    stop and ask remain distinct from deny. Unknown Codex failure branches
    deliberately stay unresolved. No mixed-exit/JSON precedence is simulated.
    """
    if profile not in {"codex-doc", "claude-command-doc"}:
        raise ValueError("Unknown documentation profile")
    if not re.search(matcher, "Bash"):
        return "not_invoked", "normal"
    is_claude = profile == "claude-command-doc"
    if timed_out:
        return "timeout", "normal" if is_claude else "unresolved"
    if exit_code == 2 and not raw:
        return "exit_2", "deny"
    if exit_code != 0:
        if exit_code == 1 and not raw:
            return "error", "normal" if is_claude else "unresolved"
        return "outside_fixture", "unresolved"
    if not raw:
        return "no_decision", "normal"
    try:
        value = json.loads(raw)
    except json.JSONDecodeError:
        return "invalid_json", "normal" if is_claude else "unresolved"
    if not isinstance(value, dict):
        return "outside_fixture", "unresolved"
    stop = {"continue": False, "stopReason": "Fixture stop."}
    if value == stop:
        return ("accepted", "stop") if is_claude else ("unsupported", "normal")
    if value == {"decision": "block", "reason": "Fixture block."}:
        return "legacy_block", "deny"
    for name in ("deny", "ask"):
        if value == json.loads(decision(name)):
            if name == "ask" and not is_claude:
                return "unsupported", "normal"
            return "accepted", name
    return "outside_fixture", "unresolved"


def marker_probe(directory, key, route, ordinary_permission):
    """A local stand-in, not a host call. None means no outcome was modeled."""
    marker = directory / (key + ".marker")
    assert not marker.exists()
    if route == "unresolved":
        return None
    if route == "normal" and ordinary_permission:
        marker.write_text("offline fixture only\n", encoding="utf-8")
    return marker.exists()


def check():
    stop = json.dumps({"continue": False, "stopReason": "Fixture stop."})
    legacy = json.dumps({"decision": "block", "reason": "Fixture block."})
    cases = [
        ("positive", "", {}, ("no_decision", "normal"),
         ("no_decision", "normal")),
        ("deny", decision("deny"), {}, ("accepted", "deny"),
         ("accepted", "deny")),
        ("migrated_stop", stop, {}, ("unsupported", "normal"),
         ("accepted", "stop")),
        ("migrated_ask", decision("ask"), {}, ("unsupported", "normal"),
         ("accepted", "ask")),
        ("legacy_block", legacy, {}, ("legacy_block", "deny"),
         ("legacy_block", "deny")),
        ("exit_2", "", {"exit_code": 2}, ("exit_2", "deny"),
         ("exit_2", "deny")),
        ("error", "", {"exit_code": 1}, ("error", "unresolved"),
         ("error", "normal")),
        ("bad_json", "{broken}", {}, ("invalid_json", "unresolved"),
         ("invalid_json", "normal")),
        ("timeout", "", {"timed_out": True}, ("timeout", "unresolved"),
         ("timeout", "normal")),
        ("matcher_miss", decision("deny"), {"matcher": "^Read$"},
         ("not_invoked", "normal"), ("not_invoked", "normal")),
        ("outside_fixture", '{"other":true}', {},
         ("outside_fixture", "unresolved"), ("outside_fixture", "unresolved")),
    ]
    rows = []
    profiles = ("codex-doc", "claude-command-doc")
    with tempfile.TemporaryDirectory(prefix="hook-contract-") as tmp:
        directory = Path(tmp)
        for name, raw, options, codex_expected, claude_expected in cases:
            for profile, expected in zip(profiles, (codex_expected, claude_expected)):
                state, route = classify(profile, raw, **options)
                assert (state, route) == expected, (name, profile, state, route)
                # Check both independent permission outcomes. A missing marker
                # by itself therefore cannot identify the rejecting layer.
                for permission in (True, False):
                    key = f"{name}-{profile}-{permission}"
                    marker = marker_probe(directory, key, route, permission)
                    want = None if route == "unresolved" else (
                        route == "normal" and permission
                    )
                    assert marker is want, (key, marker, want)
                    rows.append({
                        "case": name,
                        "profile": profile,
                        "hook_state": state,
                        "route": route,
                        "ordinary_permission": permission,
                        "marker_exists": marker,
                        "evidence": "offline_simulation",
                    })
    return {
        "evidence": "offline_simulation",
        "real_host_runs": 0,
        "real_model_calls": 0,
        "scenario_count": len(cases),
        "profile_scenarios": len(cases) * len(profiles),
        "marker_checks": len(rows),
        "ask_scope": "Prompt requested; no answer or noninteractive host modeled.",
        "rows": rows,
    }


if __name__ == "__main__":
    print(json.dumps(check(), ensure_ascii=False, indent=2))