[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_265(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_265(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, no prose. Write `safe_get_71(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_71(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 371: 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 only Python code. Define `reverse_words_229(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_229(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=513, mode=strict. No markdown fence.

[Assistant] {"case":513,"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. Define `first_or_none_12(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_12(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=sql, ok=true, case=838, mode=strict. No markdown fence.

[Assistant] {"case":838,"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] Validation item 234: 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 code, no prose. Write `safe_get_181(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_181(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=697, mode=strict. No markdown fence.

[Assistant] {"case":697,"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_78(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_78(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] For validation item 241, 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 this compact JSON object with no markdown and no extra whitespace: {"case":820,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":820,"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_86(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_86(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 346: 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] Validation item 418: 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] For validation item 228, 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=rust, ok=true, case=638, mode=strict. No markdown fence.

[Assistant] {"case":638,"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] Validation item 680: 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] Return a compact JSON object only. Fields: language=bash, ok=true, case=941, mode=strict. No markdown fence.

[Assistant] {"case":941,"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=go, ok=false, case=897, mode=strict. No markdown fence.

[Assistant] {"case":897,"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] For validation item 155, 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 201, 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] For validation item 150, 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_260(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_260(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_8(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_8(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=typescript, ok=true, case=457, mode=strict. No markdown fence.

[Assistant] {"case":457,"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 21: 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 raw Python code. Write `dedupe_preserve_order_104(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_104(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_174(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_174(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 a compact JSON object only. Fields: language=rust, ok=true, case=386, mode=strict. No markdown fence.

[Assistant] {"case":386,"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] For validation item 414, 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 95: 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 code. Write Python function `is_even_242(value)` that returns True when `value` is even.

[Assistant]
def is_even_242(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 453, 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 a function `add_135(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_135(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 with no code fence. Write `clamp_98(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_98(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 103: 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 code with no code fence. Write `clamp_114(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_114(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 600: 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] Validation item 617: 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 raw Python code. Define `first_or_none_34(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_34(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_78(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_78(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_68(value)` that returns True when `value` is even.

[Assistant]
def is_even_68(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_185(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_185(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 191: 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] Validation item 34: 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 a compact JSON object only. Fields: language=go, ok=false, case=453, mode=strict. No markdown fence.

[Assistant] {"case":453,"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=typescript, ok=true, case=523, mode=strict. No markdown fence.

[Assistant] {"case":523,"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 `reverse_words_169(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_169(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 `reverse_words_273(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_273(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_275(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_275(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_223(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_223(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 raw Python code. Define `first_or_none_143(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_143(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_166(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_166(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 321: 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] Validation item 602: 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 370: 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 code, no prose. Write `safe_get_36(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_36(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 raw Python code. Write `dedupe_preserve_order_129(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_129(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 219: 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 only Python code. Define `count_matches_183(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_183(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=131, mode=strict. No markdown fence.

[Assistant] {"case":131,"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. Write `dedupe_preserve_order_282(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_282(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_263(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_263(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 `reverse_words_240(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_240(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_15(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_15(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=bash, ok=true, case=683, mode=strict. No markdown fence.

[Assistant] {"case":683,"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=344, mode=strict. No markdown fence.

[Assistant] {"case":344,"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_67(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_67(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_32(value)` that returns True when `value` is even.

[Assistant]
def is_even_32(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 483: 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 `reverse_words_75(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_75(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 96: 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] Return only Python code. Define a function `add_83(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_83(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 `reverse_words_188(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_188(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=python, ok=false, case=132, mode=strict. No markdown fence.

[Assistant] {"case":132,"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] Validation item 447: 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] For validation item 114, 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=rust, ok=true, case=824, mode=strict. No markdown fence.

[Assistant] {"case":824,"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 `reverse_words_208(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_208(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. Write `dedupe_preserve_order_87(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_87(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 a compact JSON object only. Fields: language=rust, ok=true, case=356, mode=strict. No markdown fence.

[Assistant] {"case":356,"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] Validation item 568: 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] Return a compact JSON object only. Fields: language=bash, ok=true, case=509, mode=strict. No markdown fence.

[Assistant] {"case":509,"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_127(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_127(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":940,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":940,"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=python, ok=false, case=366, mode=strict. No markdown fence.

[Assistant] {"case":366,"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_270(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_270(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=python, ok=false, case=342, mode=strict. No markdown fence.

[Assistant] {"case":342,"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_219(value)` that returns True when `value` is even.

[Assistant]
def is_even_219(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=typescript, ok=true, case=463, mode=strict. No markdown fence.

[Assistant] {"case":463,"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=318, mode=strict. No markdown fence.

[Assistant] {"case":318,"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_266(value)` that returns True when `value` is even.

[Assistant]
def is_even_266(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_280(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_280(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=python, ok=false, case=1056, mode=strict. No markdown fence.

[Assistant] {"case":1056,"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_258(value)` that returns True when `value` is even.

[Assistant]
def is_even_258(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_151(value)` that returns True when `value` is even.

[Assistant]
def is_even_151(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=791, mode=strict. No markdown fence.

[Assistant] {"case":791,"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 604: 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] For validation item 128, 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] For validation item 218, 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 a compact JSON object only. Fields: language=sql, ok=true, case=856, mode=strict. No markdown fence.

[Assistant] {"case":856,"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] Validation item 446: 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] Return a compact JSON object only. Fields: language=go, ok=false, case=411, mode=strict. No markdown fence.

[Assistant] {"case":411,"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, no prose. Write `safe_get_216(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_216(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_107(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_107(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 232: 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] Validation item 250: 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_168(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_168(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=269, mode=strict. No markdown fence.

[Assistant] {"case":269,"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. Write `dedupe_preserve_order_92(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_92(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 a compact JSON object only. Fields: language=go, ok=false, case=201, mode=strict. No markdown fence.

[Assistant] {"case":201,"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] For validation item 392, 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 a compact JSON object only. Fields: language=python, ok=false, case=294, mode=strict. No markdown fence.

[Assistant] {"case":294,"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=rust, ok=true, case=1058, mode=strict. No markdown fence.

[Assistant] {"case":1058,"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_37(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_37(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 this compact JSON object with no markdown and no extra whitespace: {"case":585,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":585,"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=1096, mode=strict. No markdown fence.

[Assistant] {"case":1096,"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=608, mode=strict. No markdown fence.

[Assistant] {"case":608,"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] Validation item 229: return exactly `ok` and nothing else.

[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 only Python code. Define `count_matches_36(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_36(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 593: 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. Define `first_or_none_47(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_47(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 118: 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=go, ok=false, case=759, mode=strict. No markdown fence.

[Assistant] {"case":759,"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. Define `first_or_none_203(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_203(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_203(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_203(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_213(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_213(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_230(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_230(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 530: 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 this compact JSON object with no markdown and no extra whitespace: {"case":745,"language":"typescript","mode":"strict","ok":true}

[Assistant] {"case":745,"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 a function `add_234(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_234(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=163, mode=strict. No markdown fence.

[Assistant] {"case":163,"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":760,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":760,"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=291, mode=strict. No markdown fence.

[Assistant] {"case":291,"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 with no code fence. Write `clamp_3(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_3(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 90: 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=sql, ok=true, case=1018, mode=strict. No markdown fence.

[Assistant] {"case":1018,"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. Write `dedupe_preserve_order_170(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_170(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 a function `add_44(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_44(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 `reverse_words_67(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_67(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_140(value)` that returns True when `value` is even.

[Assistant]
def is_even_140(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_59(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_59(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 raw Python code. Define `first_or_none_133(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_133(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] For validation item 374, 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 code with no code fence. Write `clamp_22(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_22(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 47: 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=bash, ok=true, case=569, mode=strict. No markdown fence.

[Assistant] {"case":569,"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 310: 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 `count_matches_287(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_287(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=rust, ok=true, case=896, mode=strict. No markdown fence.

[Assistant] {"case":896,"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=sql, ok=true, case=52, mode=strict. No markdown fence.

[Assistant] {"case":52,"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 89, 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 441, 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_67(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_67(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=747, mode=strict. No markdown fence.

[Assistant] {"case":747,"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=python, ok=false, case=954, mode=strict. No markdown fence.

[Assistant] {"case":954,"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_116(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_116(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 76: 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] Return only code with no code fence. Write `clamp_246(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_246(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=636, mode=strict. No markdown fence.

[Assistant] {"case":636,"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_122(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_122(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 `count_matches_61(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_61(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=python, ok=false, case=174, mode=strict. No markdown fence.

[Assistant] {"case":174,"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_207(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_207(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_242(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_242(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 `count_matches_146(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_146(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_213(value)` that returns True when `value` is even.

[Assistant]
def is_even_213(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_31(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_31(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 494: 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 274, in one short plain English sentence, say that the model output is complete. No markdown and no reasoning.

[Assistant] The model output is complete.


[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 44: 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 with no code fence. Write `clamp_39(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_39(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 `reverse_words_134(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_134(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 `reverse_words_108(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_108(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 a function `add_64(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_64(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=442, mode=strict. No markdown fence.

[Assistant] {"case":442,"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 a function `add_283(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_283(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_96(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_96(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_110(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_110(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":625,"language":"typescript","mode":"strict","ok":true}

[Assistant] {"case":625,"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 code, no prose. Write `safe_get_190(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_190(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 687: 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 raw Python code. Write `dedupe_preserve_order_231(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_231(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_259(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_259(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=7, mode=strict. No markdown fence.

[Assistant] {"case":7,"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 code with no code fence. Write `clamp_60(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_60(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=1131, mode=strict. No markdown fence.

[Assistant] {"case":1131,"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] For validation item 88, in one short plain English sentence, say that the model output is complete. No markdown and no reasoning.

[Assistant] The model output is complete.


[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_255(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_255(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":225,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":225,"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=typescript, ok=true, case=877, mode=strict. No markdown fence.

[Assistant] {"case":877,"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_246(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_246(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 98: 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] Validation item 19: 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 only Python code. Define `reverse_words_47(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_47(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 `reverse_words_195(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_195(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=127, mode=strict. No markdown fence.

[Assistant] {"case":127,"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 99, 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_186(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_186(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_131(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_131(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_34(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_34(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_188(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_188(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 this compact JSON object with no markdown and no extra whitespace: {"case":555,"language":"go","mode":"strict","ok":false}

[Assistant] {"case":555,"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_225(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_225(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_38(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_38(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 249, 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_243(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_243(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, no prose. Write `safe_get_2(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_2(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=bash, ok=true, case=1109, mode=strict. No markdown fence.

[Assistant] {"case":1109,"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=go, ok=false, case=591, mode=strict. No markdown fence.

[Assistant] {"case":591,"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, no prose. Write `safe_get_163(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_163(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_232(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_232(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 148, in one short plain English sentence, say that the model output is complete. No markdown and no reasoning.

[Assistant] The model output is complete.


[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_187(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_187(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 445, 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 raw Python code. Write `dedupe_preserve_order_148(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_148(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 a compact JSON object only. Fields: language=go, ok=false, case=207, mode=strict. No markdown fence.

[Assistant] {"case":207,"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 this compact JSON object with no markdown and no extra whitespace: {"case":280,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":280,"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=231, mode=strict. No markdown fence.

[Assistant] {"case":231,"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 658: 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 only raw Python code. Define `first_or_none_65(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_65(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=776, mode=strict. No markdown fence.

[Assistant] {"case":776,"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_213(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_213(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_250(value, low, high)` to clamp `value` into the inclusive range.

[Assistant]
def clamp_250(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, no prose. Write `safe_get_18(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_18(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_192(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_192(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=bash, ok=true, case=119, mode=strict. No markdown fence.

[Assistant] {"case":119,"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_233(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_233(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_138(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_138(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 `count_matches_154(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_154(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_53(value)` that returns True when `value` is even.

[Assistant]
def is_even_53(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_195(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_195(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=567, mode=strict. No markdown fence.

[Assistant] {"case":567,"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 621: 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 raw Python code. Define `first_or_none_0(items)` that returns the first item or None for an empty sequence.

[Assistant]
def first_or_none_0(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_236(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_236(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 raw Python code. Write `dedupe_preserve_order_158(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_158(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 a compact JSON object only. Fields: language=python, ok=false, case=354, mode=strict. No markdown fence.

[Assistant] {"case":354,"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 this compact JSON object with no markdown and no extra whitespace: {"case":580,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":580,"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=609, mode=strict. No markdown fence.

[Assistant] {"case":609,"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_277(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_277(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_116(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_116(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=359, mode=strict. No markdown fence.

[Assistant] {"case":359,"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=1069, mode=strict. No markdown fence.

[Assistant] {"case":1069,"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 463: 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 `reverse_words_247(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_247(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] For validation item 435, 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_230(mapping, key, default=None)` that returns the mapped value or default.

[Assistant]
def safe_get_230(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_133(value)` that returns True when `value` is even.

[Assistant]
def is_even_133(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. Write `dedupe_preserve_order_232(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_232(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 a function `add_2(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_2(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 `count_matches_134(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_134(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=python, ok=false, case=1038, mode=strict. No markdown fence.

[Assistant] {"case":1038,"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_141(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_141(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 649: return exactly `ok` and nothing else.

[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] Validation item 306: 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] Validation item 38: 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=go, ok=false, case=1089, mode=strict. No markdown fence.

[Assistant] {"case":1089,"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 this compact JSON object with no markdown and no extra whitespace: {"case":370,"language":"sql","mode":"strict","ok":true}

[Assistant] {"case":370,"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=932, mode=strict. No markdown fence.

[Assistant] {"case":932,"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 `reverse_words_176(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_176(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. Write `dedupe_preserve_order_136(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_136(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_66(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_66(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] For validation item 171, 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 a compact JSON object only. Fields: language=go, ok=false, case=243, mode=strict. No markdown fence.

[Assistant] {"case":243,"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] For validation item 53, 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=python, ok=false, case=612, mode=strict. No markdown fence.

[Assistant] {"case":612,"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 `reverse_words_72(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_72(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_204(value)` that returns True when `value` is even.

[Assistant]
def is_even_204(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 108: 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 435: 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_12(a, b)` that returns `a + b`. No markdown, no explanation.

[Assistant]
def add_12(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 `reverse_words_216(text)` that reverses word order while preserving each word.

[Assistant]
def reverse_words_216(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_1(items, target)` that counts values equal to `target`.

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