[System] 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=423, mode=strict. No markdown fence.

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


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

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

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

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

[Assistant]
def dedupe_preserve_order_88(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] For validation item 391, 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 Python code. Define a function `add_88(a, b)` that returns `a + b`. No markdown, no explanation.

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

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


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

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

[Assistant]
def safe_get_92(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 449, 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 385: 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] For validation item 381, 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_195(items, target)` that counts values equal to `target`.

[Assistant]
def count_matches_195(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 313, 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] Validation item 288: 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 only code, no prose. Write `safe_get_262(mapping, key, default=None)` that returns the mapped value or default.

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

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


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

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

[Assistant]
def add_59(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 43: 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 344, 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. Write `dedupe_preserve_order_59(items)` that removes duplicates while preserving order.

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

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

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

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

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

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

[Assistant] The model output is complete.


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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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


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

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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

[Assistant]
def reverse_words_34(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 134: answer with the single token pass. No punctuation.

[Assistant] pass


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

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

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

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

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

[Assistant]
def clamp_100(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 155: output only this word: fail

[Assistant] fail


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

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

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


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

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

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


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

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

[Assistant] {"case":734,"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 637: 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] For validation item 129, 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_275(value)` that returns True when `value` is even.

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

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

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


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

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

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

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

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


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

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

[Assistant] {"case":319,"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 367: output only this word: valid

[Assistant] valid


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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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

[Assistant]
def safe_get_55(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":605,"language":"bash","mode":"strict","ok":true}

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


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

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

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

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

[Assistant]
def clamp_162(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 99: output only this word: ok

[Assistant] ok


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

[Assistant] done


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

[Assistant] The model output is clear.


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

[Assistant] The model output is complete.


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

[User] Validation item 629: 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. Write `dedupe_preserve_order_0(items)` that removes duplicates while preserving order.

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


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

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

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

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


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

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

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


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

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

[Assistant]
def reverse_words_0(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 417: return exactly `valid` and nothing else.

[Assistant] valid


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

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

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

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

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

[Assistant] python


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

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

[Assistant] The model output is complete.


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

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

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

[Assistant] yes


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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

[Assistant] The model output is deterministic.


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

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

[Assistant]
def safe_get_228(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 27: 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] Validation item 7: 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_183(value, low, high)` to clamp `value` into the inclusive range.

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

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


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

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

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

[Assistant] python


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

[User] Validation item 243: 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 126, in one short plain English sentence, say that the model output is readable. No markdown and no reasoning.

[Assistant] The model output is readable.


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

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

[Assistant] fail


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

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

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


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

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

[Assistant] {"case":751,"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. Write Python function `is_even_27(value)` that returns True when `value` is even.

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


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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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

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

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

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


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

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

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


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

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

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

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

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

[Assistant] yes


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

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

[Assistant] invalid


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

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

[Assistant] valid


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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

[Assistant]
def clamp_56(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 63: 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] Validation item 276: reply with exactly one word, python. Do not include any special tokens.

[Assistant] python


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

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

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

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

[Assistant] pass


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

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

[Assistant] {"case":372,"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 454: answer with the single token pass. No punctuation.

[Assistant] pass


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

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

[Assistant] The model output is valid.


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

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

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

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

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

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

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

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

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

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

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

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


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

[User] For validation item 144, 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 raw Python code. Define `first_or_none_26(items)` that returns the first item or None for an empty sequence.

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

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

[Assistant] python


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

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

[Assistant]
def add_190(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 389, 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 686: answer with the single token python. No punctuation.

[Assistant] python


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

[User] Validation item 178: 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 Python code. Define `reverse_words_223(text)` that reverses word order while preserving each word.

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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

[Assistant]
def first_or_none_227(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 211: 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 234, 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_130(a, b)` that returns `a + b`. No markdown, no explanation.

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

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

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

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

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


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

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

[Assistant]
def clamp_195(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 339: output only this word: ok

[Assistant] ok


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

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

[Assistant] The model output is clear.


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

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

[Assistant] The model output is clear.


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

[User] For validation item 358, 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_15(value)` that returns True when `value` is even.

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

[Assistant] no


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

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

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


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

[User] For validation item 81, 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 `reverse_words_149(text)` that reverses word order while preserving each word.

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

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

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

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

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

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


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

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

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