[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 620: reply with exactly one word, ready. Do not include any special tokens.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 168, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 550: answer with the single token ready. No punctuation.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=206, mode=strict. No markdown fence.

[Assistant] {"case":206,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":275,"language":"bash","mode":"strict","ok":true}

[Assistant] {"case":275,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=332, mode=strict. No markdown fence.

[Assistant] {"case":332,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_145(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_145(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":20,"language":"rust","mode":"strict","ok":true}

[Assistant] {"case":20,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_185(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_185(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=262, mode=strict. No markdown fence.

[Assistant] {"case":262,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":640,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":640,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_59(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_59(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=67, mode=strict. No markdown fence.

[Assistant] {"case":67,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":1005,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":1005,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 280: reply with exactly one word, ready. Do not include any special tokens.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 317, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_29(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_29(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_134(value)` that returns True when `value` is even.

[Assistant]
def is_even_134(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":845,"language":"bash","mode":"strict","ok":true}

[Assistant] {"case":845,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_109(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_109(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=913, mode=strict. No markdown fence.

[Assistant] {"case":913,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=937, mode=strict. No markdown fence.

[Assistant] {"case":937,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=1103, mode=strict. No markdown fence.

[Assistant] {"case":1103,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_183(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_183(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=1023, mode=strict. No markdown fence.

[Assistant] {"case":1023,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_260(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_260(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 246: answer with the single token python. No punctuation.

[Assistant] python


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 9, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_123(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_123(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_98(value)` that returns True when `value` is even.

[Assistant]
def is_even_98(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_14(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_14(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 163: output only this word: no

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_243(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_243(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_265(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_265(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_52(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_52(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_118(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_118(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_183(value)` that returns True when `value` is even.

[Assistant]
def is_even_183(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_83(value)` that returns True when `value` is even.

[Assistant]
def is_even_83(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 428, in one short plain English sentence, say that the model output is deterministic. No markdown and no reasoning.

[Assistant] The model output is deterministic.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":725,"language":"bash","mode":"strict","ok":true}

[Assistant] {"case":725,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 204, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 522: answer with the single token yes. No punctuation.

[Assistant] yes


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_284(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_284(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=871, mode=strict. No markdown fence.

[Assistant] {"case":871,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 273: return exactly `no` and nothing else.

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_268(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_268(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_178(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_178(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_139(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_139(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=1107, mode=strict. No markdown fence.

[Assistant] {"case":1107,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_63(value)` that returns True when `value` is even.

[Assistant]
def is_even_63(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_227(value)` that returns True when `value` is even.

[Assistant]
def is_even_227(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_218(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_218(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=1087, mode=strict. No markdown fence.

[Assistant] {"case":1087,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":450,"language":"python","mode":"strict","ok":false}

[Assistant] {"case":450,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_142(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_142(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 210: answer with the single token ready. No punctuation.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_182(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_182(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_267(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_267(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=27, mode=strict. No markdown fence.

[Assistant] {"case":27,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=461, mode=strict. No markdown fence.

[Assistant] {"case":461,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_260(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_260(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_275(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_275(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_283(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_283(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_214(value)` that returns True when `value` is even.

[Assistant]
def is_even_214(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 271, in one short plain English sentence, say that the model output is valid. No markdown and no reasoning.

[Assistant] The model output is valid.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_109(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_109(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_218(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_218(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 230: answer with the single token ready. No punctuation.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_213(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_213(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_252(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_252(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_16(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_16(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 268: reply with exactly one word, invalid. Do not include any special tokens.

[Assistant] invalid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 485: return exactly `fail` and nothing else.

[Assistant] fail


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=166, mode=strict. No markdown fence.

[Assistant] {"case":166,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=639, mode=strict. No markdown fence.

[Assistant] {"case":639,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=788, mode=strict. No markdown fence.

[Assistant] {"case":788,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_66(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_66(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 555: output only this word: fail

[Assistant] fail


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_76(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_76(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=964, mode=strict. No markdown fence.

[Assistant] {"case":964,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_14(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_14(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 333: return exactly `no` and nothing else.

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_108(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_108(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_162(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_162(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_207(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_207(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=162, mode=strict. No markdown fence.

[Assistant] {"case":162,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_234(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_234(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_267(value)` that returns True when `value` is even.

[Assistant]
def is_even_267(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=981, mode=strict. No markdown fence.

[Assistant] {"case":981,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=797, mode=strict. No markdown fence.

[Assistant] {"case":797,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 108, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 305, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_28(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_28(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_14(value)` that returns True when `value` is even.

[Assistant]
def is_even_14(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_71(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_71(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=1061, mode=strict. No markdown fence.

[Assistant] {"case":1061,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=762, mode=strict. No markdown fence.

[Assistant] {"case":762,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=204, mode=strict. No markdown fence.

[Assistant] {"case":204,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=299, mode=strict. No markdown fence.

[Assistant] {"case":299,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 392: reply with exactly one word, yes. Do not include any special tokens.

[Assistant] yes


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 396, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_181(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_181(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_221(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_221(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":735,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":735,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_82(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_82(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 120, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_262(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_262(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 465: return exactly `fail` and nothing else.

[Assistant] fail


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_30(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_30(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=802, mode=strict. No markdown fence.

[Assistant] {"case":802,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=98, mode=strict. No markdown fence.

[Assistant] {"case":98,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_220(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_220(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_121(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_121(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_189(value)` that returns True when `value` is even.

[Assistant]
def is_even_189(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_122(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_122(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_26(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_26(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 170: answer with the single token ready. No punctuation.

[Assistant] ready


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_131(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_131(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=382, mode=strict. No markdown fence.

[Assistant] {"case":382,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_227(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_227(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=581, mode=strict. No markdown fence.

[Assistant] {"case":581,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_88(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_88(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_237(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_237(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_121(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_121(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_77(value)` that returns True when `value` is even.

[Assistant]
def is_even_77(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=286, mode=strict. No markdown fence.

[Assistant] {"case":286,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=13, mode=strict. No markdown fence.

[Assistant] {"case":13,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=558, mode=strict. No markdown fence.

[Assistant] {"case":558,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_48(value)` that returns True when `value` is even.

[Assistant]
def is_even_48(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_84(value)` that returns True when `value` is even.

[Assistant]
def is_even_84(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_83(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_83(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 56: reply with exactly one word, python. Do not include any special tokens.

[Assistant] python


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 193: return exactly `no` and nothing else.

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_125(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_125(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_180(value)` that returns True when `value` is even.

[Assistant]
def is_even_180(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 429, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_180(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_180(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 347: output only this word: valid

[Assistant] valid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=483, mode=strict. No markdown fence.

[Assistant] {"case":483,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_77(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_77(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=1046, mode=strict. No markdown fence.

[Assistant] {"case":1046,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_227(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_227(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_137(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_137(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=1137, mode=strict. No markdown fence.

[Assistant] {"case":1137,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_257(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_257(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":1065,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":1065,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=974, mode=strict. No markdown fence.

[Assistant] {"case":974,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":805,"language":"typescript","mode":"strict","ok":true}

[Assistant] {"case":805,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only this compact JSON object with no markdown and no extra whitespace: {"case":980,"language":"rust","mode":"strict","ok":true}

[Assistant] {"case":980,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=757, mode=strict. No markdown fence.

[Assistant] {"case":757,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_41(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_41(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_175(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_175(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 652: reply with exactly one word, yes. Do not include any special tokens.

[Assistant] yes


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_268(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_268(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 62: answer with the single token yes. No punctuation.

[Assistant] yes


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 477: return exactly `valid` and nothing else.

[Assistant] valid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=859, mode=strict. No markdown fence.

[Assistant] {"case":859,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 27, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_233(value)` that returns True when `value` is even.

[Assistant]
def is_even_233(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=338, mode=strict. No markdown fence.

[Assistant] {"case":338,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_12(value)` that returns True when `value` is even.

[Assistant]
def is_even_12(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_175(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_175(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=77, mode=strict. No markdown fence.

[Assistant] {"case":77,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_203(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_203(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_103(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_103(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_286(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_286(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_34(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_34(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_261(value)` that returns True when `value` is even.

[Assistant]
def is_even_261(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_5(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_5(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 84, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=843, mode=strict. No markdown fence.

[Assistant] {"case":843,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=142, mode=strict. No markdown fence.

[Assistant] {"case":142,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_114(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_114(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 623: output only this word: no

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 55, in one short plain English sentence, say that the model output is valid. No markdown and no reasoning.

[Assistant] The model output is valid.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_57(value)` that returns True when `value` is even.

[Assistant]
def is_even_57(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_0(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_0(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_269(value)` that returns True when `value` is even.

[Assistant]
def is_even_269(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_269(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_269(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 51: output only this word: done

[Assistant] done


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 165, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_253(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_253(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 175: output only this word: fail

[Assistant] fail


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_155(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_155(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_165(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_165(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=184, mode=strict. No markdown fence.

[Assistant] {"case":184,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 11, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 337, in one short plain English sentence, say that the model output is valid. No markdown and no reasoning.

[Assistant] The model output is valid.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=549, mode=strict. No markdown fence.

[Assistant] {"case":549,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_191(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_191(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_2(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_2(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_239(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_239(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_182(value)` that returns True when `value` is even.

[Assistant]
def is_even_182(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_211(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_211(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_170(value)` that returns True when `value` is even.

[Assistant]
def is_even_170(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 399: output only this word: ok

[Assistant] ok


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=583, mode=strict. No markdown fence.

[Assistant] {"case":583,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=436, mode=strict. No markdown fence.

[Assistant] {"case":436,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=337, mode=strict. No markdown fence.

[Assistant] {"case":337,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_287(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_287(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_23(value)` that returns True when `value` is even.

[Assistant]
def is_even_23(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=992, mode=strict. No markdown fence.

[Assistant] {"case":992,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_249(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_249(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_217(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_217(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 357, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_13(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_13(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_113(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_113(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 563: output only this word: no

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_193(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_193(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_143(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_143(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 194: answer with the single token pass. No punctuation.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 191, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=991, mode=strict. No markdown fence.

[Assistant] {"case":991,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=281, mode=strict. No markdown fence.

[Assistant] {"case":281,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 187: output only this word: valid

[Assistant] valid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_200(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_200(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_61(value)` that returns True when `value` is even.

[Assistant]
def is_even_61(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=917, mode=strict. No markdown fence.

[Assistant] {"case":917,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=259, mode=strict. No markdown fence.

[Assistant] {"case":259,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_140(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_140(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 394: answer with the single token pass. No punctuation.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_117(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_117(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_136(value)` that returns True when `value` is even.

[Assistant]
def is_even_136(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_236(value)` that returns True when `value` is even.

[Assistant]
def is_even_236(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=621, mode=strict. No markdown fence.

[Assistant] {"case":621,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 464: reply with exactly one word, pass. Do not include any special tokens.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 661: return exactly `done` and nothing else.

[Assistant] done


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_196(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_196(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 411: output only this word: done

[Assistant] done


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=1014, mode=strict. No markdown fence.

[Assistant] {"case":1014,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_63(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_63(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=146, mode=strict. No markdown fence.

[Assistant] {"case":146,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_47(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_47(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 663: output only this word: no

[Assistant] no


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=911, mode=strict. No markdown fence.

[Assistant] {"case":911,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=1134, mode=strict. No markdown fence.

[Assistant] {"case":1134,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_241(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_241(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=646, mode=strict. No markdown fence.

[Assistant] {"case":646,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_130(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_130(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_202(value)` that returns True when `value` is even.

[Assistant]
def is_even_202(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_98(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_98(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=typescript, ok=true, case=91, mode=strict. No markdown fence.

[Assistant] {"case":91,"language":"typescript","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 654: answer with the single token pass. No punctuation.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_47(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_47(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_117(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_117(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_142(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_142(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_145(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_145(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_255(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_255(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 258: answer with the single token invalid. No punctuation.

[Assistant] invalid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=rust, ok=true, case=158, mode=strict. No markdown fence.

[Assistant] {"case":158,"language":"rust","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_153(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_153(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_103(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_103(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_221(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_221(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_226(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_226(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 146: answer with the single token python. No punctuation.

[Assistant] python


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 215, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_119(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_119(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_132(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_132(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] For validation item 333, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_152(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_152(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code with no code fence. Write `clamp_85(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_85(value, low, high):
    return max(low, min(value, high))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_15(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_15(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 664: reply with exactly one word, pass. Do not include any special tokens.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=python, ok=false, case=102, mode=strict. No markdown fence.

[Assistant] {"case":102,"language":"python","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Write `dedupe_preserve_order_94(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_94(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_178(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_178(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code. Write Python function `is_even_218(value)` that returns True when `value` is even.

[Assistant]
def is_even_218(value):
    return value % 2 == 0


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_177(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_177(items):
    return items[0] if items else None


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=go, ok=false, case=333, mode=strict. No markdown fence.

[Assistant] {"case":333,"language":"go","mode":"strict","ok":false}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 204: reply with exactly one word, pass. Do not include any special tokens.

[Assistant] pass


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only code, no prose. Write `safe_get_11(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_11(mapping, key, default=None):
    return mapping.get(key, default)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=sql, ok=true, case=682, mode=strict. No markdown fence.

[Assistant] {"case":682,"language":"sql","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `reverse_words_257(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_257(text):
    return " ".join(reversed(text.split()))


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define `count_matches_81(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_81(items, target):
    return sum(1 for item in items if item == target)


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Validation item 537: return exactly `valid` and nothing else.

[Assistant] valid


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only Python code. Define a function `add_7(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_7(a, b):
    return a + b


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return a compact JSON object only. Fields: language=bash, ok=true, case=173, mode=strict. No markdown fence.

[Assistant] {"case":173,"language":"bash","mode":"strict","ok":true}


[System] You are a precise coding assistant. Follow output format constraints exactly. Do not include reasoning, markdown fences, or preambles unless explicitly requested.

[User] Return only raw Python code. Define `first_or_none_149(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_149(items):
    return items[0] if items else None