[System] You 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":675,"language":"go","mode":"strict","ok":false}

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

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


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

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

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

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

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

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

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

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

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

[Assistant] {"case":498,"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 330: 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=bash, ok=true, case=329, mode=strict. No markdown fence.

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

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

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


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

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

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

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

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

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

[Assistant]
def safe_get_1(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 106: answer with the single token python. No punctuation.

[Assistant] python


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

[User] For validation item 80, 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=516, mode=strict. No markdown fence.

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

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


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

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

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

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

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


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

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

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

[Assistant] {"case":942,"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 511: 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 360: 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 only Python code. Define `count_matches_91(items, target)` that counts values equal to `target`.

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

[Assistant]
def is_even_79(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 23: output only this word: no

[Assistant] no


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

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

[Assistant] The model output is clear.


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

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

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

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

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

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

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

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

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

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

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

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

[Assistant]
def clamp_182(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 93, 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] Validation item 70: 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. Write Python function `is_even_186(value)` that returns True when `value` is even.

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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

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


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

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

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


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

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

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

[Assistant]
def count_matches_247(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 290, 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 Python code. Define `count_matches_35(items, target)` that counts values equal to `target`.

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

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

[Assistant] {"case":1090,"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 22, 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 a compact JSON object only. Fields: language=go, ok=false, case=543, mode=strict. No markdown fence.

[Assistant] {"case":543,"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 580: 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 only Python code. Define a function `add_72(a, b)` that returns `a + b`. No markdown, no explanation.

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

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

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

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

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

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

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

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

[Assistant]
def dedupe_preserve_order_67(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 267: 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 214, 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] For validation item 21, in one short plain English sentence, say that the model output is compact. No markdown and no reasoning.

[Assistant] The model output is compact.


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

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

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


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

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

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

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


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

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

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

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

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

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

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

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


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

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

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


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

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

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

[Assistant] {"case":993,"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 344: reply with exactly one word, pass. Do not include any special tokens.

[Assistant] pass


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

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

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

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


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

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

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

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

[Assistant] {"case":306,"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":685,"language":"typescript","mode":"strict","ok":true}

[Assistant] {"case":685,"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 383, in one short plain English sentence, say that the model output is clear. No markdown and no reasoning.

[Assistant] The model output is clear.


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

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

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

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

[Assistant] {"case":922,"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 544: reply with exactly one word, pass. Do not include any special tokens.

[Assistant] pass


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

[User] Validation item 610: 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. Write Python function `is_even_132(value)` that returns True when `value` is even.

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

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


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

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

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

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


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

[User] For validation item 303, 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] Validation item 497: 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] Validation item 322: 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] For validation item 348, 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 `reverse_words_250(text)` that reverses word order while preserving each word.

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

[Assistant]
def is_even_47(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 76, 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 Python code. Define `count_matches_170(items, target)` that counts values equal to `target`.

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

[Assistant] The model output is clear.


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

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

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

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

[Assistant] {"case":384,"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 351: output only this word: done

[Assistant] done


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

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

[Assistant] The model output is readable.


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

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

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

[Assistant] {"case":777,"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 412: reply with exactly one word, yes. Do not include any special tokens.

[Assistant] yes


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

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

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

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

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

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

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

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

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

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

[Assistant] The model output is compact.


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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

[Assistant]
def reverse_words_256(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 498: 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 code. Write Python function `is_even_71(value)` that returns True when `value` is even.

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

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

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

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


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

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

[Assistant]
def is_even_237(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 10: 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] For validation item 130, 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. Write Python function `is_even_88(value)` that returns True when `value` is even.

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


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

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

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

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

[Assistant] The model output is clear.


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

[Assistant]
def is_even_42(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 373: 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] Validation item 491: 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 code with no code fence. Write `clamp_103(value, low, high)` to clamp `value` into the inclusive range.

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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


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

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

[Assistant]
def add_136(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 72: reply with exactly one word, yes. Do not include any special tokens.

[Assistant] yes


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

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

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

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

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


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

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

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


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

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

[Assistant]
def first_or_none_201(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 370, 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 Python code. Define `count_matches_196(items, target)` that counts values equal to `target`.

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

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

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

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

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

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

[Assistant]
def count_matches_89(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 143, 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] Validation item 506: 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 only code with no code fence. Write `clamp_202(value, low, high)` to clamp `value` into the inclusive range.

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

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

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

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

[Assistant] The model output is valid.


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

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

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

[Assistant]
def safe_get_43(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":590,"language":"rust","mode":"strict","ok":true}

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

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


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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

[Assistant]
def clamp_73(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 111: 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 292: reply with exactly one word, yes. Do not include any special tokens.

[Assistant] yes


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

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

[Assistant] The model output is valid.


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

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

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

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

[Assistant] The model output is deterministic.


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

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

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


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

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

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

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


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

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

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

[Assistant] {"case":1007,"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 584: 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 Python code. Define a function `add_51(a, b)` that returns `a + b`. No markdown, no explanation.

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


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

[User] For validation item 351, 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_22(mapping, key, default=None)` that returns the mapped value or default.

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

[Assistant]
def reverse_words_36(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 545: return exactly `fail` and nothing else.

[Assistant] fail


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

[User] Validation item 335: 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 a compact JSON object only. Fields: language=typescript, ok=true, case=31, mode=strict. No markdown fence.

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

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


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

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

[Assistant] The model output is compact.


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

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

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

[Assistant] The model output is clear.


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

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

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

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

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

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

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