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

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

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


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

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

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


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

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

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

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

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


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

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

[Assistant] no


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

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

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


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

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

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


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

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

[Assistant]
def clamp_176(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":810,"language":"python","mode":"strict","ok":false}

[Assistant] {"case":810,"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 145: return exactly `fail` and nothing else.

[Assistant] fail


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

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

[Assistant] yes


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

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

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


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

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

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

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


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

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

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

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

[Assistant] valid


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

[User] For validation item 146, 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 326: 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 78: 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 `count_matches_20(items, target)` that counts values equal to `target`.

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


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

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

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


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

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

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

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


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

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

[Assistant] The model output is compact.


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

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

[Assistant] ready


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

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

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

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

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

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


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

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

[Assistant] no


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

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

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

[Assistant] {"case":887,"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":140,"language":"rust","mode":"strict","ok":true}

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


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

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

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


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

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

[Assistant] {"case":305,"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 436: 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 225: return exactly `fail` and nothing else.

[Assistant] fail


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

[User] Validation item 332: 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 `count_matches_38(items, target)` that counts values equal to `target`.

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

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


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

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

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

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

[Assistant] The model output is deterministic.


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

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

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

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

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


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

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

[Assistant] The model output is valid.


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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

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


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

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

[Assistant] {"case":702,"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 55: output only this word: fail

[Assistant] fail


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

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

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


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

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

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

[Assistant] The model output is readable.


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

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

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


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

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

[Assistant]
def first_or_none_36(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 142: answer with the single token yes. No punctuation.

[Assistant] yes


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

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

[Assistant] The model output is clear.


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

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

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

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

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


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

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

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

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


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

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

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


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

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

[Assistant] {"case":931,"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 153: return exactly `no` and nothing else.

[Assistant] no


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

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

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

[Assistant] The model output is deterministic.


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

[Assistant] The model output is readable.


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

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

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

[Assistant] ok


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

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

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

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


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

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

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


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

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

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

[Assistant] valid


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

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

[Assistant] no


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

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

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


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

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

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

[Assistant] The model output is deterministic.


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

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

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


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

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

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

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

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

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

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

[Assistant] python


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

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

[Assistant] The model output is complete.


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

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

[Assistant] The model output is compact.


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

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

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

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

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

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

[Assistant]
def reverse_words_132(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":840,"language":"python","mode":"strict","ok":false}

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


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

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

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

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

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

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


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

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

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


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

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

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


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

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

[Assistant] {"case":452,"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 496: 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 a compact JSON object only. Fields: language=bash, ok=true, case=689, mode=strict. No markdown fence.

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

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


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

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

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

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


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

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

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

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


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

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

[Assistant]
def reverse_words_193(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":210,"language":"python","mode":"strict","ok":false}

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


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

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

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


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

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

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

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

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

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


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

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

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


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

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

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


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

[User] For validation item 182, 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":100,"language":"sql","mode":"strict","ok":true}

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


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

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

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


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

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

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

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

[Assistant]
def is_even_38(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 35, 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 9: 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 code. Write Python function `is_even_165(value)` that returns True when `value` is even.

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

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

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

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

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

[Assistant] The model output is readable.


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

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

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


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

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

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


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

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

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


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

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

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

[Assistant]
def reverse_words_87(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 318: answer with the single token invalid. No punctuation.

[Assistant] invalid


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

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

[Assistant]
def safe_get_198(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 343: 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 348: 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 Python code. Define `reverse_words_38(text)` that reverses word order while preserving each word.

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

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


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

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

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

[Assistant] ok


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

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

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

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

[Assistant] pass


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

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

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


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

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

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


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

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

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

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

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


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

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

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

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

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

[Assistant] The model output is complete.


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

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

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


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

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

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

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

[Assistant]
def reverse_words_162(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 582: answer with the single token yes. No punctuation.

[Assistant] yes


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

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

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

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

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


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

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

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


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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

[Assistant] The model output is compact.


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

[User] For validation item 162, 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. Write `dedupe_preserve_order_246(items)` that removes duplicates while preserving order.

[Assistant]
def dedupe_preserve_order_246(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":900,"language":"python","mode":"strict","ok":false}

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

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


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

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

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


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

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

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

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

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


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

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

[Assistant] ready


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

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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

[Assistant] yes


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

[User] For validation item 353, 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 52: 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_10(a, b)` that returns `a + b`. No markdown, no explanation.

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

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

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

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

[Assistant] {"case":733,"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":945,"language":"go","mode":"strict","ok":false}

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


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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

[Assistant]
def add_152(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 213, 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_145(value)` that returns True when `value` is even.

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


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

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

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

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

[Assistant]
def safe_get_267(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 616: 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_70(items)` that removes duplicates while preserving order.

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

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

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

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


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

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

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