{"id": "op_sortalpha", "entry_point": "op_sortalpha", "primitives": ["sortalpha"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically.", "solution": "def op_sortalpha(xs):\n    r = list(xs)\n    r = sorted(r)\n    return r", "tests": "assert op_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha([]) == []\nassert op_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'BC', 'bc']\nassert op_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha(['x']) == ['x']\nassert op_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_dropzeros", "entry_point": "op_dropzeros", "primitives": ["dropzeros"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros.", "solution": "def op_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros([]) == []\nassert op_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros([10]) == [10]\nassert op_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg", "entry_point": "op_neg", "primitives": ["neg"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers.", "solution": "def op_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_neg([1, 2, 3, 4]) == []\nassert op_neg([]) == []\nassert op_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg([5, 5, 5]) == []\nassert op_neg([3, 1, 2]) == []\nassert op_neg([10]) == []\nassert op_neg([2, 4, 6]) == []\nassert op_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_issorted", "entry_point": "op_issorted", "primitives": ["issorted"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return whether the list is sorted ascending.", "solution": "def op_issorted(xs):\n    r = list(xs)\n    return r == sorted(r)", "tests": "assert op_issorted([1, 2, 3, 4]) == True\nassert op_issorted([]) == True\nassert op_issorted([-2, -1, 0, 1, 2]) == True\nassert op_issorted([5, 5, 5]) == True\nassert op_issorted([3, 1, 2]) == False\nassert op_issorted([10]) == True\nassert op_issorted([2, 4, 6]) == True\nassert op_issorted([-7, 12, -7]) == False"}
{"id": "op_sortabs", "entry_point": "op_sortabs", "primitives": ["sortabs"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value.", "solution": "def op_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs([]) == []\nassert op_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs([10]) == [10]\nassert op_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_ages", "entry_point": "op_ages", "primitives": ["ages"], "difficulty": 0, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages.", "solution": "def op_ages(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return r", "tests": "assert op_ages([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages([]) == []\nassert op_ages([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_firstchar", "entry_point": "op_firstchar", "primitives": ["firstchar"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties).", "solution": "def op_firstchar(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar([]) == []\nassert op_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_firstchar(['x']) == ['x']\nassert op_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_square", "entry_point": "op_square", "primitives": ["square"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each.", "solution": "def op_square(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square([]) == []\nassert op_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square([5, 5, 5]) == [25, 25, 25]\nassert op_square([3, 1, 2]) == [9, 1, 4]\nassert op_square([10]) == [100]\nassert op_square([2, 4, 6]) == [4, 16, 36]\nassert op_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_dec", "entry_point": "op_dec", "primitives": ["dec"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each.", "solution": "def op_dec(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec([]) == []\nassert op_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec([5, 5, 5]) == [4, 4, 4]\nassert op_dec([3, 1, 2]) == [2, 0, 1]\nassert op_dec([10]) == [9]\nassert op_dec([2, 4, 6]) == [1, 3, 5]\nassert op_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_padto3", "entry_point": "op_padto3", "primitives": ["padto3"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements.", "solution": "def op_padto3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3([]) == [0, 0, 0]\nassert op_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3([10]) == [10, 0, 0]\nassert op_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sortage", "entry_point": "op_sortage", "primitives": ["sortage"], "difficulty": 0, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first.", "solution": "def op_sortage(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    return r", "tests": "assert op_sortage([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [{'name': 'Bo', 'age': 12}, {'name': 'Ada', 'age': 36}]\nassert op_sortage([]) == []\nassert op_sortage([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [{'name': 'El', 'age': 17}, {'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}]\nassert op_sortage([{'name': 'Fi', 'age': 41}]) == [{'name': 'Fi', 'age': 41}]"}
{"id": "op_lens", "entry_point": "op_lens", "primitives": ["lens"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; return the total number of characters.", "solution": "def op_lens(xs):\n    r = list(xs)\n    return sum(len(s) for s in r)", "tests": "assert op_lens(['Hello', 'world']) == 10\nassert op_lens([]) == 0\nassert op_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_lens(['one', 'one', 'Two']) == 9\nassert op_lens(['x']) == 1\nassert op_lens(['abc', 'de', '']) == 5"}
{"id": "op_strip", "entry_point": "op_strip", "primitives": ["strip"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each.", "solution": "def op_strip(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip([]) == []\nassert op_strip(['  a ', '', 'BC', 'bc']) == ['a', '', 'BC', 'bc']\nassert op_strip(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_strip(['x']) == ['x']\nassert op_strip(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_counts", "entry_point": "op_counts", "primitives": ["counts"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; return how many strings remain.", "solution": "def op_counts(xs):\n    r = list(xs)\n    return len(r)", "tests": "assert op_counts(['Hello', 'world']) == 2\nassert op_counts([]) == 0\nassert op_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_counts(['one', 'one', 'Two']) == 3\nassert op_counts(['x']) == 1\nassert op_counts(['abc', 'de', '']) == 3"}
{"id": "op_allpos", "entry_point": "op_allpos", "primitives": ["allpos"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return whether all values are positive.", "solution": "def op_allpos(xs):\n    r = list(xs)\n    return all(x > 0 for x in r)", "tests": "assert op_allpos([1, 2, 3, 4]) == True\nassert op_allpos([]) == True\nassert op_allpos([-2, -1, 0, 1, 2]) == False\nassert op_allpos([5, 5, 5]) == True\nassert op_allpos([3, 1, 2]) == True\nassert op_allpos([10]) == True\nassert op_allpos([2, 4, 6]) == True\nassert op_allpos([-7, 12, -7]) == False"}
{"id": "op_sortd", "entry_point": "op_sortd", "primitives": ["sortd"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending.", "solution": "def op_sortd(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd([]) == []\nassert op_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sortd([10]) == [10]\nassert op_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_names", "entry_point": "op_names", "primitives": ["names"], "difficulty": 0, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names.", "solution": "def op_names(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return r", "tests": "assert op_names([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names([]) == []\nassert op_names([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_evens", "entry_point": "op_evens", "primitives": ["evens"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers.", "solution": "def op_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_evens([1, 2, 3, 4]) == [2, 4]\nassert op_evens([]) == []\nassert op_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens([5, 5, 5]) == []\nassert op_evens([3, 1, 2]) == [2]\nassert op_evens([10]) == [10]\nassert op_evens([2, 4, 6]) == [2, 4, 6]\nassert op_evens([-7, 12, -7]) == [12]"}
{"id": "op_countrl", "entry_point": "op_countrl", "primitives": ["countrl"], "difficulty": 0, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); return how many records remain.", "solution": "def op_countrl(xs):\n    r = list(xs)\n    return len(r)", "tests": "assert op_countrl([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_countrl([]) == 0\nassert op_countrl([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_countrl([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_odds", "entry_point": "op_odds", "primitives": ["odds"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers.", "solution": "def op_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_odds([1, 2, 3, 4]) == [1, 3]\nassert op_odds([]) == []\nassert op_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds([5, 5, 5]) == [5, 5, 5]\nassert op_odds([3, 1, 2]) == [3, 1]\nassert op_odds([10]) == []\nassert op_odds([2, 4, 6]) == []\nassert op_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero", "entry_point": "op_oremptyzero", "primitives": ["oremptyzero"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero.", "solution": "def op_oremptyzero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return r", "tests": "assert op_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero([]) == [0]\nassert op_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero([10]) == [10]\nassert op_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropwhileneg", "entry_point": "op_dropwhileneg", "primitives": ["dropwhileneg"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values.", "solution": "def op_dropwhileneg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg([]) == []\nassert op_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg([10]) == [10]\nassert op_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_first3", "entry_point": "op_first3", "primitives": ["first3"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three.", "solution": "def op_first3(xs):\n    r = list(xs)\n    r = r[:3]\n    return r", "tests": "assert op_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3([]) == []\nassert op_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3([5, 5, 5]) == [5, 5, 5]\nassert op_first3([3, 1, 2]) == [3, 1, 2]\nassert op_first3([10]) == [10]\nassert op_first3([2, 4, 6]) == [2, 4, 6]\nassert op_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst", "entry_point": "op_dropfirst", "primitives": ["dropfirst"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element.", "solution": "def op_dropfirst(xs):\n    r = list(xs)\n    r = r[1:]\n    return r", "tests": "assert op_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst([]) == []\nassert op_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropfirst([10]) == []\nassert op_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_sum", "entry_point": "op_sum", "primitives": ["sum"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return their sum.", "solution": "def op_sum(xs):\n    r = list(xs)\n    return sum(r)", "tests": "assert op_sum([1, 2, 3, 4]) == 10\nassert op_sum([]) == 0\nassert op_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sum([5, 5, 5]) == 15\nassert op_sum([3, 1, 2]) == 6\nassert op_sum([10]) == 10\nassert op_sum([2, 4, 6]) == 12\nassert op_sum([-7, 12, -7]) == -2"}
{"id": "op_dropshort", "entry_point": "op_dropshort", "primitives": ["dropshort"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters.", "solution": "def op_dropshort(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort([]) == []\nassert op_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_dropshort(['x']) == []\nassert op_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_len", "entry_point": "op_len", "primitives": ["len"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return how many remain.", "solution": "def op_len(xs):\n    r = list(xs)\n    return len(r)", "tests": "assert op_len([1, 2, 3, 4]) == 4\nassert op_len([]) == 0\nassert op_len([-2, -1, 0, 1, 2]) == 5\nassert op_len([5, 5, 5]) == 3\nassert op_len([3, 1, 2]) == 3\nassert op_len([10]) == 1\nassert op_len([2, 4, 6]) == 3\nassert op_len([-7, 12, -7]) == 3"}
{"id": "op_gt5", "entry_point": "op_gt5", "primitives": ["gt5"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five.", "solution": "def op_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_gt5([1, 2, 3, 4]) == []\nassert op_gt5([]) == []\nassert op_gt5([-2, -1, 0, 1, 2]) == []\nassert op_gt5([5, 5, 5]) == []\nassert op_gt5([3, 1, 2]) == []\nassert op_gt5([10]) == [10]\nassert op_gt5([2, 4, 6]) == [6]\nassert op_gt5([-7, 12, -7]) == [12]"}
{"id": "op_rev", "entry_point": "op_rev", "primitives": ["rev"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order.", "solution": "def op_rev(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev([]) == []\nassert op_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev([5, 5, 5]) == [5, 5, 5]\nassert op_rev([3, 1, 2]) == [2, 1, 3]\nassert op_rev([10]) == [10]\nassert op_rev([2, 4, 6]) == [6, 4, 2]\nassert op_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_haszero", "entry_point": "op_haszero", "primitives": ["haszero"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return whether the list contains a zero.", "solution": "def op_haszero(xs):\n    r = list(xs)\n    return 0 in r", "tests": "assert op_haszero([1, 2, 3, 4]) == False\nassert op_haszero([]) == False\nassert op_haszero([-2, -1, 0, 1, 2]) == True\nassert op_haszero([5, 5, 5]) == False\nassert op_haszero([3, 1, 2]) == False\nassert op_haszero([10]) == False\nassert op_haszero([2, 4, 6]) == False\nassert op_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta", "entry_point": "op_sorta", "primitives": ["sorta"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending.", "solution": "def op_sorta(xs):\n    r = list(xs)\n    r = sorted(r)\n    return r", "tests": "assert op_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta([]) == []\nassert op_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sorta([10]) == [10]\nassert op_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_trimends", "entry_point": "op_trimends", "primitives": ["trimends"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements.", "solution": "def op_trimends(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return r", "tests": "assert op_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_trimends([]) == []\nassert op_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends([5, 5, 5]) == [5]\nassert op_trimends([3, 1, 2]) == [1]\nassert op_trimends([10]) == []\nassert op_trimends([2, 4, 6]) == [4]\nassert op_trimends([-7, 12, -7]) == [12]"}
{"id": "op_prod", "entry_point": "op_prod", "primitives": ["prod"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return their product.", "solution": "def op_prod(xs):\n    r = list(xs)\n    return __import__('math').prod(r)", "tests": "assert op_prod([1, 2, 3, 4]) == 24\nassert op_prod([]) == 1\nassert op_prod([-2, -1, 0, 1, 2]) == 0\nassert op_prod([5, 5, 5]) == 125\nassert op_prod([3, 1, 2]) == 6\nassert op_prod([10]) == 10\nassert op_prod([2, 4, 6]) == 48\nassert op_prod([-7, 12, -7]) == 588"}
{"id": "op_lower", "entry_point": "op_lower", "primitives": ["lower"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string.", "solution": "def op_lower(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_lower([]) == []\nassert op_lower(['  a ', '', 'BC', 'bc']) == ['  a ', '', 'bc', 'bc']\nassert op_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower(['x']) == ['x']\nassert op_lower(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_double", "entry_point": "op_double", "primitives": ["double"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each.", "solution": "def op_double(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double([]) == []\nassert op_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double([5, 5, 5]) == [10, 10, 10]\nassert op_double([3, 1, 2]) == [6, 2, 4]\nassert op_double([10]) == [20]\nassert op_double([2, 4, 6]) == [4, 8, 12]\nassert op_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_beforezero", "entry_point": "op_beforezero", "primitives": ["beforezero"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero.", "solution": "def op_beforezero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero([]) == []\nassert op_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero([10]) == [10]\nassert op_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_counteven", "entry_point": "op_counteven", "primitives": ["counteven"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return how many values are even.", "solution": "def op_counteven(xs):\n    r = list(xs)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_counteven([1, 2, 3, 4]) == 2\nassert op_counteven([]) == 0\nassert op_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_counteven([5, 5, 5]) == 0\nassert op_counteven([3, 1, 2]) == 1\nassert op_counteven([10]) == 1\nassert op_counteven([2, 4, 6]) == 3\nassert op_counteven([-7, 12, -7]) == 1"}
{"id": "op_absval", "entry_point": "op_absval", "primitives": ["absval"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each.", "solution": "def op_absval(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval([]) == []\nassert op_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval([5, 5, 5]) == [5, 5, 5]\nassert op_absval([3, 1, 2]) == [3, 1, 2]\nassert op_absval([10]) == [10]\nassert op_absval([2, 4, 6]) == [2, 4, 6]\nassert op_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_last3", "entry_point": "op_last3", "primitives": ["last3"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three.", "solution": "def op_last3(xs):\n    r = list(xs)\n    r = r[-3:]\n    return r", "tests": "assert op_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3([]) == []\nassert op_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3([5, 5, 5]) == [5, 5, 5]\nassert op_last3([3, 1, 2]) == [3, 1, 2]\nassert op_last3([10]) == [10]\nassert op_last3([2, 4, 6]) == [2, 4, 6]\nassert op_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_anyempty", "entry_point": "op_anyempty", "primitives": ["anyempty"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; return whether any string is empty.", "solution": "def op_anyempty(xs):\n    r = list(xs)\n    return any(s == '' for s in r)", "tests": "assert op_anyempty(['Hello', 'world']) == False\nassert op_anyempty([]) == False\nassert op_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_anyempty(['one', 'one', 'Two']) == False\nassert op_anyempty(['x']) == False\nassert op_anyempty(['abc', 'de', '']) == True"}
{"id": "op_takewhilepos", "entry_point": "op_takewhilepos", "primitives": ["takewhilepos"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive.", "solution": "def op_takewhilepos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos([]) == []\nassert op_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos([10]) == [10]\nassert op_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_inc", "entry_point": "op_inc", "primitives": ["inc"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each.", "solution": "def op_inc(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc([]) == []\nassert op_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc([5, 5, 5]) == [6, 6, 6]\nassert op_inc([3, 1, 2]) == [4, 2, 3]\nassert op_inc([10]) == [11]\nassert op_inc([2, 4, 6]) == [3, 5, 7]\nassert op_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_anyeven", "entry_point": "op_anyeven", "primitives": ["anyeven"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return whether any value is even.", "solution": "def op_anyeven(xs):\n    r = list(xs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_anyeven([1, 2, 3, 4]) == True\nassert op_anyeven([]) == False\nassert op_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_anyeven([5, 5, 5]) == False\nassert op_anyeven([3, 1, 2]) == True\nassert op_anyeven([10]) == True\nassert op_anyeven([2, 4, 6]) == True\nassert op_anyeven([-7, 12, -7]) == True"}
{"id": "op_max", "entry_point": "op_max", "primitives": ["max"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return the maximum (0 if empty).", "solution": "def op_max(xs):\n    r = list(xs)\n    return max(r) if r else 0", "tests": "assert op_max([1, 2, 3, 4]) == 4\nassert op_max([]) == 0\nassert op_max([-2, -1, 0, 1, 2]) == 2\nassert op_max([5, 5, 5]) == 5\nassert op_max([3, 1, 2]) == 3\nassert op_max([10]) == 10\nassert op_max([2, 4, 6]) == 6\nassert op_max([-7, 12, -7]) == 12"}
{"id": "op_negate", "entry_point": "op_negate", "primitives": ["negate"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each.", "solution": "def op_negate(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate([]) == []\nassert op_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_negate([10]) == [-10]\nassert op_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_oldest", "entry_point": "op_oldest", "primitives": ["oldest"], "difficulty": 0, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); return the name of the oldest person (empty if none).", "solution": "def op_oldest(xs):\n    r = list(xs)\n    return max(r, key=lambda d: d['age'])['name'] if r else ''", "tests": "assert op_oldest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada'\nassert op_oldest([]) == ''\nassert op_oldest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Dee'\nassert op_oldest([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_uniq", "entry_point": "op_uniq", "primitives": ["uniq"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence.", "solution": "def op_uniq(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq([]) == []\nassert op_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq([5, 5, 5]) == [5]\nassert op_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_uniq([10]) == [10]\nassert op_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_add10", "entry_point": "op_add10", "primitives": ["add10"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each.", "solution": "def op_add10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10([]) == []\nassert op_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10([5, 5, 5]) == [15, 15, 15]\nassert op_add10([3, 1, 2]) == [13, 11, 12]\nassert op_add10([10]) == [20]\nassert op_add10([2, 4, 6]) == [12, 14, 16]\nassert op_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_upper", "entry_point": "op_upper", "primitives": ["upper"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string.", "solution": "def op_upper(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper([]) == []\nassert op_upper(['  a ', '', 'BC', 'bc']) == ['  A ', '', 'BC', 'BC']\nassert op_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper(['x']) == ['X']\nassert op_upper(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_joinc", "entry_point": "op_joinc", "primitives": ["joinc"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; join them with commas.", "solution": "def op_joinc(xs):\n    r = list(xs)\n    return ','.join(r)", "tests": "assert op_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_joinc([]) == ''\nassert op_joinc(['  a ', '', 'BC', 'bc']) == '  a ,,BC,bc'\nassert op_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_joinc(['x']) == 'x'\nassert op_joinc(['abc', 'de', '']) == 'abc,de,'"}
{"id": "op_min", "entry_point": "op_min", "primitives": ["min"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return the minimum (0 if empty).", "solution": "def op_min(xs):\n    r = list(xs)\n    return min(r) if r else 0", "tests": "assert op_min([1, 2, 3, 4]) == 1\nassert op_min([]) == 0\nassert op_min([-2, -1, 0, 1, 2]) == -2\nassert op_min([5, 5, 5]) == 5\nassert op_min([3, 1, 2]) == 1\nassert op_min([10]) == 10\nassert op_min([2, 4, 6]) == 2\nassert op_min([-7, 12, -7]) == -7"}
{"id": "op_firsteven", "entry_point": "op_firsteven", "primitives": ["firsteven"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return the first even value (0 if none).", "solution": "def op_firsteven(xs):\n    r = list(xs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_firsteven([1, 2, 3, 4]) == 2\nassert op_firsteven([]) == 0\nassert op_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_firsteven([5, 5, 5]) == 0\nassert op_firsteven([3, 1, 2]) == 2\nassert op_firsteven([10]) == 10\nassert op_firsteven([2, 4, 6]) == 2\nassert op_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sortlen", "entry_point": "op_sortlen", "primitives": ["sortlen"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first.", "solution": "def op_sortlen(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen([]) == []\nassert op_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_sortlen(['x']) == ['x']\nassert op_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_longest", "entry_point": "op_longest", "primitives": ["longest"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; return the longest string (empty if none).", "solution": "def op_longest(xs):\n    r = list(xs)\n    return max(r, key=len) if r else ''", "tests": "assert op_longest(['Hello', 'world']) == 'Hello'\nassert op_longest([]) == ''\nassert op_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_longest(['one', 'one', 'Two']) == 'one'\nassert op_longest(['x']) == 'x'\nassert op_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_div3", "entry_point": "op_div3", "primitives": ["div3"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three.", "solution": "def op_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_div3([1, 2, 3, 4]) == [3]\nassert op_div3([]) == []\nassert op_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3([5, 5, 5]) == []\nassert op_div3([3, 1, 2]) == [3]\nassert op_div3([10]) == []\nassert op_div3([2, 4, 6]) == [6]\nassert op_div3([-7, 12, -7]) == [12]"}
{"id": "op_clamp10", "entry_point": "op_clamp10", "primitives": ["clamp10"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10.", "solution": "def op_clamp10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10([]) == []\nassert op_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10([10]) == [10]\nassert op_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_pos", "entry_point": "op_pos", "primitives": ["pos"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers.", "solution": "def op_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos([]) == []\nassert op_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos([5, 5, 5]) == [5, 5, 5]\nassert op_pos([3, 1, 2]) == [3, 1, 2]\nassert op_pos([10]) == [10]\nassert op_pos([2, 4, 6]) == [2, 4, 6]\nassert op_pos([-7, 12, -7]) == [12]"}
{"id": "op_uniqs", "entry_point": "op_uniqs", "primitives": ["uniqs"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first.", "solution": "def op_uniqs(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs([]) == []\nassert op_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ', '', 'BC', 'bc']\nassert op_uniqs(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs(['x']) == ['x']\nassert op_uniqs(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_maxlen", "entry_point": "op_maxlen", "primitives": ["maxlen"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; return the length of the longest string (0 if none).", "solution": "def op_maxlen(xs):\n    r = list(xs)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_maxlen(['Hello', 'world']) == 5\nassert op_maxlen([]) == 0\nassert op_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_maxlen(['one', 'one', 'Two']) == 3\nassert op_maxlen(['x']) == 1\nassert op_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_alldistinct", "entry_point": "op_alldistinct", "primitives": ["alldistinct"], "difficulty": 0, "split": "train", "type": "IL", "prompt": "Take a list of integers; return whether all values are distinct.", "solution": "def op_alldistinct(xs):\n    r = list(xs)\n    return len(r) == len(set(r))", "tests": "assert op_alldistinct([1, 2, 3, 4]) == True\nassert op_alldistinct([]) == True\nassert op_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_alldistinct([5, 5, 5]) == False\nassert op_alldistinct([3, 1, 2]) == True\nassert op_alldistinct([10]) == True\nassert op_alldistinct([2, 4, 6]) == True\nassert op_alldistinct([-7, 12, -7]) == False"}
{"id": "op_nonempty", "entry_point": "op_nonempty", "primitives": ["nonempty"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings.", "solution": "def op_nonempty(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty([]) == []\nassert op_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ', 'BC', 'bc']\nassert op_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_nonempty(['x']) == ['x']\nassert op_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_prefixup", "entry_point": "op_prefixup", "primitives": ["prefixup"], "difficulty": 0, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash.", "solution": "def op_prefixup(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup([]) == []\nassert op_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#BC', '#bc']\nassert op_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup(['x']) == ['#x']\nassert op_prefixup(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_uniq_oremptyzero", "entry_point": "op_uniq_oremptyzero", "primitives": ["uniq", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero.", "solution": "def op_uniq_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_oremptyzero([]) == [0]\nassert op_uniq_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_oremptyzero([5, 5, 5]) == [5]\nassert op_uniq_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_oremptyzero([10]) == [10]\nassert op_uniq_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_oremptyzero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_oremptyzero_padto3", "entry_point": "op_oremptyzero_padto3", "primitives": ["oremptyzero", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_oremptyzero_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_padto3([10]) == [10, 0, 0]\nassert op_oremptyzero_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_ages_square", "entry_point": "op_ages_square", "primitives": ["ages", "square"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each.", "solution": "def op_ages_square(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_ages_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1296, 144]\nassert op_ages_square([]) == []\nassert op_ages_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [324, 4225, 289]\nassert op_ages_square([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_strip_sortlen", "entry_point": "op_strip_sortlen", "primitives": ["strip", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first.", "solution": "def op_strip_sortlen(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_strip_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_sortlen([]) == []\nassert op_strip_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'a', 'BC', 'bc']\nassert op_strip_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_strip_sortlen(['x']) == ['x']\nassert op_strip_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_last3_trimends", "entry_point": "op_last3_trimends", "primitives": ["last3", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements.", "solution": "def op_last3_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_trimends([]) == []\nassert op_last3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_trimends([5, 5, 5]) == [5]\nassert op_last3_trimends([3, 1, 2]) == [1]\nassert op_last3_trimends([10]) == []\nassert op_last3_trimends([2, 4, 6]) == [4]\nassert op_last3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_first3_sum", "entry_point": "op_first3_sum", "primitives": ["first3", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return their sum.", "solution": "def op_first3_sum(xs):\n    r = list(xs)\n    r = r[:3]\n    return sum(r)", "tests": "assert op_first3_sum([1, 2, 3, 4]) == 6\nassert op_first3_sum([]) == 0\nassert op_first3_sum([-2, -1, 0, 1, 2]) == -3\nassert op_first3_sum([5, 5, 5]) == 15\nassert op_first3_sum([3, 1, 2]) == 6\nassert op_first3_sum([10]) == 10\nassert op_first3_sum([2, 4, 6]) == 12\nassert op_first3_sum([-7, 12, -7]) == -2"}
{"id": "op_neg_div3", "entry_point": "op_neg_div3", "primitives": ["neg", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three.", "solution": "def op_neg_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_neg_div3([1, 2, 3, 4]) == []\nassert op_neg_div3([]) == []\nassert op_neg_div3([-2, -1, 0, 1, 2]) == []\nassert op_neg_div3([5, 5, 5]) == []\nassert op_neg_div3([3, 1, 2]) == []\nassert op_neg_div3([10]) == []\nassert op_neg_div3([2, 4, 6]) == []\nassert op_neg_div3([-7, 12, -7]) == []"}
{"id": "op_negate_takewhilepos", "entry_point": "op_negate_takewhilepos", "primitives": ["negate", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive.", "solution": "def op_negate_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_takewhilepos([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos([]) == []\nassert op_negate_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_takewhilepos([5, 5, 5]) == []\nassert op_negate_takewhilepos([3, 1, 2]) == []\nassert op_negate_takewhilepos([10]) == []\nassert op_negate_takewhilepos([2, 4, 6]) == []\nassert op_negate_takewhilepos([-7, 12, -7]) == [7]"}
{"id": "op_pos_dropzeros", "entry_point": "op_pos_dropzeros", "primitives": ["pos", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the zeros.", "solution": "def op_pos_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_dropzeros([]) == []\nassert op_pos_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_dropzeros([10]) == [10]\nassert op_pos_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_last3_div3", "entry_point": "op_last3_div3", "primitives": ["last3", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three.", "solution": "def op_last3_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_div3([1, 2, 3, 4]) == [3]\nassert op_last3_div3([]) == []\nassert op_last3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_div3([5, 5, 5]) == []\nassert op_last3_div3([3, 1, 2]) == [3]\nassert op_last3_div3([10]) == []\nassert op_last3_div3([2, 4, 6]) == [6]\nassert op_last3_div3([-7, 12, -7]) == [12]"}
{"id": "op_rev_issorted", "entry_point": "op_rev_issorted", "primitives": ["rev", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return whether the list is sorted ascending.", "solution": "def op_rev_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return r == sorted(r)", "tests": "assert op_rev_issorted([1, 2, 3, 4]) == False\nassert op_rev_issorted([]) == True\nassert op_rev_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_issorted([5, 5, 5]) == True\nassert op_rev_issorted([3, 1, 2]) == False\nassert op_rev_issorted([10]) == True\nassert op_rev_issorted([2, 4, 6]) == False\nassert op_rev_issorted([-7, 12, -7]) == False"}
{"id": "op_lower_upper", "entry_point": "op_lower_upper", "primitives": ["lower", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then uppercase each string.", "solution": "def op_lower_upper(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_lower_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_lower_upper([]) == []\nassert op_lower_upper(['  a ', '', 'BC', 'bc']) == ['  A ', '', 'BC', 'BC']\nassert op_lower_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_lower_upper(['x']) == ['X']\nassert op_lower_upper(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_oremptyzero_counteven", "entry_point": "op_oremptyzero_counteven", "primitives": ["oremptyzero", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return how many values are even.", "solution": "def op_oremptyzero_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_counteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_counteven([]) == 1\nassert op_oremptyzero_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_oremptyzero_counteven([5, 5, 5]) == 0\nassert op_oremptyzero_counteven([3, 1, 2]) == 1\nassert op_oremptyzero_counteven([10]) == 1\nassert op_oremptyzero_counteven([2, 4, 6]) == 3\nassert op_oremptyzero_counteven([-7, 12, -7]) == 1"}
{"id": "op_nonempty_lower", "entry_point": "op_nonempty_lower", "primitives": ["nonempty", "lower"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then lowercase each string.", "solution": "def op_nonempty_lower(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_nonempty_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_nonempty_lower([]) == []\nassert op_nonempty_lower(['  a ', '', 'BC', 'bc']) == ['  a ', 'bc', 'bc']\nassert op_nonempty_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_nonempty_lower(['x']) == ['x']\nassert op_nonempty_lower(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_beforezero_gt5", "entry_point": "op_beforezero_gt5", "primitives": ["beforezero", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five.", "solution": "def op_beforezero_gt5(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_beforezero_gt5([]) == []\nassert op_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5([5, 5, 5]) == []\nassert op_beforezero_gt5([3, 1, 2]) == []\nassert op_beforezero_gt5([10]) == [10]\nassert op_beforezero_gt5([2, 4, 6]) == [6]\nassert op_beforezero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_sortlen", "entry_point": "op_uniqs_sortlen", "primitives": ["uniqs", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort by length, shortest first.", "solution": "def op_uniqs_sortlen(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_uniqs_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_sortlen([]) == []\nassert op_uniqs_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_uniqs_sortlen(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_sortlen(['x']) == ['x']\nassert op_uniqs_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_inc_max", "entry_point": "op_inc_max", "primitives": ["inc", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return the maximum (0 if empty).", "solution": "def op_inc_max(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_inc_max([1, 2, 3, 4]) == 5\nassert op_inc_max([]) == 0\nassert op_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_inc_max([5, 5, 5]) == 6\nassert op_inc_max([3, 1, 2]) == 4\nassert op_inc_max([10]) == 11\nassert op_inc_max([2, 4, 6]) == 7\nassert op_inc_max([-7, 12, -7]) == 13"}
{"id": "op_sortd_evens", "entry_point": "op_sortd_evens", "primitives": ["sortd", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers.", "solution": "def op_sortd_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_evens([1, 2, 3, 4]) == [4, 2]\nassert op_sortd_evens([]) == []\nassert op_sortd_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_sortd_evens([5, 5, 5]) == []\nassert op_sortd_evens([3, 1, 2]) == [2]\nassert op_sortd_evens([10]) == [10]\nassert op_sortd_evens([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_evens([-7, 12, -7]) == [12]"}
{"id": "op_trimends_issorted", "entry_point": "op_trimends_issorted", "primitives": ["trimends", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_trimends_issorted(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_trimends_issorted([1, 2, 3, 4]) == True\nassert op_trimends_issorted([]) == True\nassert op_trimends_issorted([-2, -1, 0, 1, 2]) == True\nassert op_trimends_issorted([5, 5, 5]) == True\nassert op_trimends_issorted([3, 1, 2]) == True\nassert op_trimends_issorted([10]) == True\nassert op_trimends_issorted([2, 4, 6]) == True\nassert op_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_pos_inc", "entry_point": "op_pos_inc", "primitives": ["pos", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each.", "solution": "def op_pos_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_pos_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_pos_inc([]) == []\nassert op_pos_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_pos_inc([5, 5, 5]) == [6, 6, 6]\nassert op_pos_inc([3, 1, 2]) == [4, 2, 3]\nassert op_pos_inc([10]) == [11]\nassert op_pos_inc([2, 4, 6]) == [3, 5, 7]\nassert op_pos_inc([-7, 12, -7]) == [13]"}
{"id": "op_prefixup_joinc", "entry_point": "op_prefixup_joinc", "primitives": ["prefixup", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then join them with commas.", "solution": "def op_prefixup_joinc(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return ','.join(r)", "tests": "assert op_prefixup_joinc(['Hello', 'world']) == '#Hello,#world'\nassert op_prefixup_joinc([]) == ''\nassert op_prefixup_joinc(['  a ', '', 'BC', 'bc']) == '#  a ,#,#BC,#bc'\nassert op_prefixup_joinc(['one', 'one', 'Two']) == '#one,#one,#Two'\nassert op_prefixup_joinc(['x']) == '#x'\nassert op_prefixup_joinc(['abc', 'de', '']) == '#abc,#de,#'"}
{"id": "op_evens_trimends", "entry_point": "op_evens_trimends", "primitives": ["evens", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements.", "solution": "def op_evens_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_evens_trimends([1, 2, 3, 4]) == []\nassert op_evens_trimends([]) == []\nassert op_evens_trimends([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_trimends([5, 5, 5]) == []\nassert op_evens_trimends([3, 1, 2]) == []\nassert op_evens_trimends([10]) == []\nassert op_evens_trimends([2, 4, 6]) == [4]\nassert op_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_inc_negate", "entry_point": "op_inc_negate", "primitives": ["inc", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then negate each.", "solution": "def op_inc_negate(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_inc_negate([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_inc_negate([]) == []\nassert op_inc_negate([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_inc_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_inc_negate([3, 1, 2]) == [-4, -2, -3]\nassert op_inc_negate([10]) == [-11]\nassert op_inc_negate([2, 4, 6]) == [-3, -5, -7]\nassert op_inc_negate([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_dropzeros_haszero", "entry_point": "op_dropzeros_haszero", "primitives": ["dropzeros", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return whether the list contains a zero.", "solution": "def op_dropzeros_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_haszero([]) == False\nassert op_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_haszero([5, 5, 5]) == False\nassert op_dropzeros_haszero([3, 1, 2]) == False\nassert op_dropzeros_haszero([10]) == False\nassert op_dropzeros_haszero([2, 4, 6]) == False\nassert op_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_prod", "entry_point": "op_dec_prod", "primitives": ["dec", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return their product.", "solution": "def op_dec_prod(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_dec_prod([1, 2, 3, 4]) == 0\nassert op_dec_prod([]) == 1\nassert op_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dec_prod([5, 5, 5]) == 64\nassert op_dec_prod([3, 1, 2]) == 0\nassert op_dec_prod([10]) == 9\nassert op_dec_prod([2, 4, 6]) == 15\nassert op_dec_prod([-7, 12, -7]) == 704"}
{"id": "op_double_dropfirst", "entry_point": "op_double_dropfirst", "primitives": ["double", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element.", "solution": "def op_double_dropfirst(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_double_dropfirst([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst([]) == []\nassert op_double_dropfirst([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_double_dropfirst([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst([10]) == []\nassert op_double_dropfirst([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst([-7, 12, -7]) == [24, -14]"}
{"id": "op_oremptyzero_odds", "entry_point": "op_oremptyzero_odds", "primitives": ["oremptyzero", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers.", "solution": "def op_oremptyzero_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_odds([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_odds([]) == []\nassert op_oremptyzero_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_odds([3, 1, 2]) == [3, 1]\nassert op_oremptyzero_odds([10]) == []\nassert op_oremptyzero_odds([2, 4, 6]) == []\nassert op_oremptyzero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_trimends", "entry_point": "op_uniq_trimends", "primitives": ["uniq", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements.", "solution": "def op_uniq_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_trimends([]) == []\nassert op_uniq_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_uniq_trimends([5, 5, 5]) == []\nassert op_uniq_trimends([3, 1, 2]) == [1]\nassert op_uniq_trimends([10]) == []\nassert op_uniq_trimends([2, 4, 6]) == [4]\nassert op_uniq_trimends([-7, 12, -7]) == []"}
{"id": "op_gt5_sum", "entry_point": "op_gt5_sum", "primitives": ["gt5", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return their sum.", "solution": "def op_gt5_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_gt5_sum([1, 2, 3, 4]) == 0\nassert op_gt5_sum([]) == 0\nassert op_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_sum([5, 5, 5]) == 0\nassert op_gt5_sum([3, 1, 2]) == 0\nassert op_gt5_sum([10]) == 10\nassert op_gt5_sum([2, 4, 6]) == 6\nassert op_gt5_sum([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_div3", "entry_point": "op_oremptyzero_div3", "primitives": ["oremptyzero", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep multiples of three.", "solution": "def op_oremptyzero_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_div3([]) == [0]\nassert op_oremptyzero_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_div3([5, 5, 5]) == []\nassert op_oremptyzero_div3([3, 1, 2]) == [3]\nassert op_oremptyzero_div3([10]) == []\nassert op_oremptyzero_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_odds", "entry_point": "op_dropzeros_odds", "primitives": ["dropzeros", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers.", "solution": "def op_dropzeros_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropzeros_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds([]) == []\nassert op_dropzeros_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_odds([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds([3, 1, 2]) == [3, 1]\nassert op_dropzeros_odds([10]) == []\nassert op_dropzeros_odds([2, 4, 6]) == []\nassert op_dropzeros_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_negate_first3", "entry_point": "op_negate_first3", "primitives": ["negate", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three.", "solution": "def op_negate_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_negate_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_first3([]) == []\nassert op_negate_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_negate_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_first3([10]) == [-10]\nassert op_negate_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_first3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_square_beforezero", "entry_point": "op_square_beforezero", "primitives": ["square", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero.", "solution": "def op_square_beforezero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_square_beforezero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_beforezero([]) == []\nassert op_square_beforezero([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_beforezero([5, 5, 5]) == [25, 25, 25]\nassert op_square_beforezero([3, 1, 2]) == [9, 1, 4]\nassert op_square_beforezero([10]) == [100]\nassert op_square_beforezero([2, 4, 6]) == [4, 16, 36]\nassert op_square_beforezero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_dropwhileneg_padto3", "entry_point": "op_dropwhileneg_padto3", "primitives": ["dropwhileneg", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements.", "solution": "def op_dropwhileneg_padto3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropwhileneg_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_padto3([]) == [0, 0, 0]\nassert op_dropwhileneg_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_padto3([10]) == [10, 0, 0]\nassert op_dropwhileneg_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_negate_padto3", "entry_point": "op_negate_padto3", "primitives": ["negate", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements.", "solution": "def op_negate_padto3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_negate_padto3([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_padto3([]) == [0, 0, 0]\nassert op_negate_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_padto3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_padto3([10]) == [-10, 0, 0]\nassert op_negate_padto3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_padto3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_absval_clamp10", "entry_point": "op_absval_clamp10", "primitives": ["absval", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10.", "solution": "def op_absval_clamp10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_absval_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_clamp10([]) == []\nassert op_absval_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_absval_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_absval_clamp10([10]) == [10]\nassert op_absval_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_absval_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_dropzeros_beforezero", "entry_point": "op_dropzeros_beforezero", "primitives": ["dropzeros", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero.", "solution": "def op_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_beforezero([]) == []\nassert op_dropzeros_beforezero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_beforezero([10]) == [10]\nassert op_dropzeros_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_nonempty_anyempty", "entry_point": "op_nonempty_anyempty", "primitives": ["nonempty", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then return whether any string is empty.", "solution": "def op_nonempty_anyempty(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return any(s == '' for s in r)", "tests": "assert op_nonempty_anyempty(['Hello', 'world']) == False\nassert op_nonempty_anyempty([]) == False\nassert op_nonempty_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_nonempty_anyempty(['one', 'one', 'Two']) == False\nassert op_nonempty_anyempty(['x']) == False\nassert op_nonempty_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dec_clamp10", "entry_point": "op_dec_clamp10", "primitives": ["dec", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cap each value at 10.", "solution": "def op_dec_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_clamp10([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_clamp10([]) == []\nassert op_dec_clamp10([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dec_clamp10([3, 1, 2]) == [2, 0, 1]\nassert op_dec_clamp10([10]) == [9]\nassert op_dec_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dec_clamp10([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_sorta_dropwhileneg", "entry_point": "op_sorta_dropwhileneg", "primitives": ["sorta", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values.", "solution": "def op_sorta_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sorta_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropwhileneg([]) == []\nassert op_sorta_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sorta_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropwhileneg([10]) == [10]\nassert op_sorta_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_sortabs", "entry_point": "op_beforezero_sortabs", "primitives": ["beforezero", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value.", "solution": "def op_beforezero_sortabs(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_beforezero_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sortabs([]) == []\nassert op_beforezero_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortabs([10]) == [10]\nassert op_beforezero_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_inc_len", "entry_point": "op_inc_len", "primitives": ["inc", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return how many remain.", "solution": "def op_inc_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return len(r)", "tests": "assert op_inc_len([1, 2, 3, 4]) == 4\nassert op_inc_len([]) == 0\nassert op_inc_len([-2, -1, 0, 1, 2]) == 5\nassert op_inc_len([5, 5, 5]) == 3\nassert op_inc_len([3, 1, 2]) == 3\nassert op_inc_len([10]) == 1\nassert op_inc_len([2, 4, 6]) == 3\nassert op_inc_len([-7, 12, -7]) == 3"}
{"id": "op_last3_pos", "entry_point": "op_last3_pos", "primitives": ["last3", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers.", "solution": "def op_last3_pos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_last3_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_pos([]) == []\nassert op_last3_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_pos([10]) == [10]\nassert op_last3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_pos([-7, 12, -7]) == [12]"}
{"id": "op_strip_longest", "entry_point": "op_strip_longest", "primitives": ["strip", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then return the longest string (empty if none).", "solution": "def op_strip_longest(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_strip_longest(['Hello', 'world']) == 'Hello'\nassert op_strip_longest([]) == ''\nassert op_strip_longest(['  a ', '', 'BC', 'bc']) == 'BC'\nassert op_strip_longest(['one', 'one', 'Two']) == 'one'\nassert op_strip_longest(['x']) == 'x'\nassert op_strip_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_dropfirst_dropwhileneg", "entry_point": "op_dropfirst_dropwhileneg", "primitives": ["dropfirst", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values.", "solution": "def op_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropwhileneg([]) == []\nassert op_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dropwhileneg([10]) == []\nassert op_dropfirst_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortd_padto3", "entry_point": "op_sortd_padto3", "primitives": ["sortd", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements.", "solution": "def op_sortd_padto3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortd_padto3([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_padto3([]) == [0, 0, 0]\nassert op_sortd_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_padto3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_padto3([10]) == [10, 0, 0]\nassert op_sortd_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_padto3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_oremptyzero_len", "entry_point": "op_oremptyzero_len", "primitives": ["oremptyzero", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return how many remain.", "solution": "def op_oremptyzero_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_oremptyzero_len([]) == 1\nassert op_oremptyzero_len([-2, -1, 0, 1, 2]) == 5\nassert op_oremptyzero_len([5, 5, 5]) == 3\nassert op_oremptyzero_len([3, 1, 2]) == 3\nassert op_oremptyzero_len([10]) == 1\nassert op_oremptyzero_len([2, 4, 6]) == 3\nassert op_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_oremptyzero_neg", "entry_point": "op_oremptyzero_neg", "primitives": ["oremptyzero", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers.", "solution": "def op_oremptyzero_neg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_oremptyzero_neg([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg([]) == []\nassert op_oremptyzero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_neg([5, 5, 5]) == []\nassert op_oremptyzero_neg([3, 1, 2]) == []\nassert op_oremptyzero_neg([10]) == []\nassert op_oremptyzero_neg([2, 4, 6]) == []\nassert op_oremptyzero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_first3_max", "entry_point": "op_first3_max", "primitives": ["first3", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return the maximum (0 if empty).", "solution": "def op_first3_max(xs):\n    r = list(xs)\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_first3_max([1, 2, 3, 4]) == 3\nassert op_first3_max([]) == 0\nassert op_first3_max([-2, -1, 0, 1, 2]) == 0\nassert op_first3_max([5, 5, 5]) == 5\nassert op_first3_max([3, 1, 2]) == 3\nassert op_first3_max([10]) == 10\nassert op_first3_max([2, 4, 6]) == 6\nassert op_first3_max([-7, 12, -7]) == 12"}
{"id": "op_trimends_first3", "entry_point": "op_trimends_first3", "primitives": ["trimends", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three.", "solution": "def op_trimends_first3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_trimends_first3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_first3([]) == []\nassert op_trimends_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_first3([5, 5, 5]) == [5]\nassert op_trimends_first3([3, 1, 2]) == [1]\nassert op_trimends_first3([10]) == []\nassert op_trimends_first3([2, 4, 6]) == [4]\nassert op_trimends_first3([-7, 12, -7]) == [12]"}
{"id": "op_prefixup_anyempty", "entry_point": "op_prefixup_anyempty", "primitives": ["prefixup", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then return whether any string is empty.", "solution": "def op_prefixup_anyempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_prefixup_anyempty(['Hello', 'world']) == False\nassert op_prefixup_anyempty([]) == False\nassert op_prefixup_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_prefixup_anyempty(['one', 'one', 'Two']) == False\nassert op_prefixup_anyempty(['x']) == False\nassert op_prefixup_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dec_double", "entry_point": "op_dec_double", "primitives": ["dec", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each.", "solution": "def op_dec_double(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dec_double([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_dec_double([]) == []\nassert op_dec_double([-2, -1, 0, 1, 2]) == [-6, -4, -2, 0, 2]\nassert op_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_dec_double([3, 1, 2]) == [4, 0, 2]\nassert op_dec_double([10]) == [18]\nassert op_dec_double([2, 4, 6]) == [2, 6, 10]\nassert op_dec_double([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_trimends_firsteven", "entry_point": "op_trimends_firsteven", "primitives": ["trimends", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_trimends_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_trimends_firsteven([]) == 0\nassert op_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_firsteven([5, 5, 5]) == 0\nassert op_trimends_firsteven([3, 1, 2]) == 0\nassert op_trimends_firsteven([10]) == 0\nassert op_trimends_firsteven([2, 4, 6]) == 4\nassert op_trimends_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_padto3", "entry_point": "op_dropfirst_padto3", "primitives": ["dropfirst", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_padto3([]) == [0, 0, 0]\nassert op_dropfirst_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_padto3_min", "entry_point": "op_padto3_min", "primitives": ["padto3", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_padto3_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_padto3_min([1, 2, 3, 4]) == 1\nassert op_padto3_min([]) == 0\nassert op_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_min([5, 5, 5]) == 5\nassert op_padto3_min([3, 1, 2]) == 1\nassert op_padto3_min([10]) == 0\nassert op_padto3_min([2, 4, 6]) == 2\nassert op_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_dropshort_nonempty", "entry_point": "op_dropshort_nonempty", "primitives": ["dropshort", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then drop empty strings.", "solution": "def op_dropshort_nonempty(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_dropshort_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort_nonempty([]) == []\nassert op_dropshort_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_dropshort_nonempty(['x']) == []\nassert op_dropshort_nonempty(['abc', 'de', '']) == ['abc']"}
{"id": "op_beforezero_dropwhileneg", "entry_point": "op_beforezero_dropwhileneg", "primitives": ["beforezero", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the leading negative values.", "solution": "def op_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_dropwhileneg([]) == []\nassert op_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_dropwhileneg([10]) == [10]\nassert op_beforezero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortlen_firstchar", "entry_point": "op_sortlen_firstchar", "primitives": ["sortlen", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then keep the first character of each (dropping empties).", "solution": "def op_sortlen_firstchar(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortlen_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_sortlen_firstchar([]) == []\nassert op_sortlen_firstchar(['  a ', '', 'BC', 'bc']) == ['B', 'b', ' ']\nassert op_sortlen_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_sortlen_firstchar(['x']) == ['x']\nassert op_sortlen_firstchar(['abc', 'de', '']) == ['d', 'a']"}
{"id": "op_uniqs_strip", "entry_point": "op_uniqs_strip", "primitives": ["uniqs", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then trim whitespace from each.", "solution": "def op_uniqs_strip(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_uniqs_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_strip([]) == []\nassert op_uniqs_strip(['  a ', '', 'BC', 'bc']) == ['a', '', 'BC', 'bc']\nassert op_uniqs_strip(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_strip(['x']) == ['x']\nassert op_uniqs_strip(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_odds_alldistinct", "entry_point": "op_odds_alldistinct", "primitives": ["odds", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return whether all values are distinct.", "solution": "def op_odds_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_odds_alldistinct([]) == True\nassert op_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_odds_alldistinct([5, 5, 5]) == False\nassert op_odds_alldistinct([3, 1, 2]) == True\nassert op_odds_alldistinct([10]) == True\nassert op_odds_alldistinct([2, 4, 6]) == True\nassert op_odds_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_oremptyzero", "entry_point": "op_dropwhileneg_oremptyzero", "primitives": ["dropwhileneg", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero.", "solution": "def op_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_oremptyzero([]) == [0]\nassert op_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_oremptyzero([10]) == [10]\nassert op_dropwhileneg_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_oremptyzero([-7, 12, -7]) == [12, -7]"}
{"id": "op_add10_div3", "entry_point": "op_add10_div3", "primitives": ["add10", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three.", "solution": "def op_add10_div3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_add10_div3([1, 2, 3, 4]) == [12]\nassert op_add10_div3([]) == []\nassert op_add10_div3([-2, -1, 0, 1, 2]) == [9, 12]\nassert op_add10_div3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_div3([3, 1, 2]) == [12]\nassert op_add10_div3([10]) == []\nassert op_add10_div3([2, 4, 6]) == [12]\nassert op_add10_div3([-7, 12, -7]) == [3, 3]"}
{"id": "op_clamp10_beforezero", "entry_point": "op_clamp10_beforezero", "primitives": ["clamp10", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero.", "solution": "def op_clamp10_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_beforezero([]) == []\nassert op_clamp10_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_beforezero([10]) == [10]\nassert op_clamp10_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_beforezero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_div3_beforezero", "entry_point": "op_div3_beforezero", "primitives": ["div3", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero.", "solution": "def op_div3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_beforezero([1, 2, 3, 4]) == [3]\nassert op_div3_beforezero([]) == []\nassert op_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero([5, 5, 5]) == []\nassert op_div3_beforezero([3, 1, 2]) == [3]\nassert op_div3_beforezero([10]) == []\nassert op_div3_beforezero([2, 4, 6]) == [6]\nassert op_div3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_alldistinct", "entry_point": "op_dropzeros_alldistinct", "primitives": ["dropzeros", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return whether all values are distinct.", "solution": "def op_dropzeros_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropzeros_alldistinct([1, 2, 3, 4]) == True\nassert op_dropzeros_alldistinct([]) == True\nassert op_dropzeros_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_alldistinct([5, 5, 5]) == False\nassert op_dropzeros_alldistinct([3, 1, 2]) == True\nassert op_dropzeros_alldistinct([10]) == True\nassert op_dropzeros_alldistinct([2, 4, 6]) == True\nassert op_dropzeros_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_min", "entry_point": "op_last3_min", "primitives": ["last3", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return the minimum (0 if empty).", "solution": "def op_last3_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    return min(r) if r else 0", "tests": "assert op_last3_min([1, 2, 3, 4]) == 2\nassert op_last3_min([]) == 0\nassert op_last3_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_min([5, 5, 5]) == 5\nassert op_last3_min([3, 1, 2]) == 1\nassert op_last3_min([10]) == 10\nassert op_last3_min([2, 4, 6]) == 2\nassert op_last3_min([-7, 12, -7]) == -7"}
{"id": "op_rev_dropwhileneg", "entry_point": "op_rev_dropwhileneg", "primitives": ["rev", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values.", "solution": "def op_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropwhileneg([]) == []\nassert op_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropwhileneg([10]) == [10]\nassert op_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropwhileneg_sortd", "entry_point": "op_dropwhileneg_sortd", "primitives": ["dropwhileneg", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending.", "solution": "def op_dropwhileneg_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_sortd([]) == []\nassert op_dropwhileneg_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropwhileneg_sortd([10]) == [10]\nassert op_dropwhileneg_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_double_gt5", "entry_point": "op_double_gt5", "primitives": ["double", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five.", "solution": "def op_double_gt5(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_double_gt5([]) == []\nassert op_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_double_gt5([3, 1, 2]) == [6]\nassert op_double_gt5([10]) == [20]\nassert op_double_gt5([2, 4, 6]) == [8, 12]\nassert op_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_firstchar_upper", "entry_point": "op_firstchar_upper", "primitives": ["firstchar", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then uppercase each string.", "solution": "def op_firstchar_upper(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_firstchar_upper(['Hello', 'world']) == ['H', 'W']\nassert op_firstchar_upper([]) == []\nassert op_firstchar_upper(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'B']\nassert op_firstchar_upper(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_firstchar_upper(['x']) == ['X']\nassert op_firstchar_upper(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_dec_absval", "entry_point": "op_dec_absval", "primitives": ["dec", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each.", "solution": "def op_dec_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_absval([]) == []\nassert op_dec_absval([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, 1]\nassert op_dec_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval([3, 1, 2]) == [2, 0, 1]\nassert op_dec_absval([10]) == [9]\nassert op_dec_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_absval([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_takewhilepos_pos", "entry_point": "op_takewhilepos_pos", "primitives": ["takewhilepos", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers.", "solution": "def op_takewhilepos_pos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_takewhilepos_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_pos([]) == []\nassert op_takewhilepos_pos([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_pos([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_pos([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_pos([10]) == [10]\nassert op_takewhilepos_pos([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_pos([-7, 12, -7]) == []"}
{"id": "op_negate_oremptyzero", "entry_point": "op_negate_oremptyzero", "primitives": ["negate", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero.", "solution": "def op_negate_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_oremptyzero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_oremptyzero([]) == [0]\nassert op_negate_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_oremptyzero([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_oremptyzero([10]) == [-10]\nassert op_negate_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_oremptyzero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_first3_odds", "entry_point": "op_first3_odds", "primitives": ["first3", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers.", "solution": "def op_first3_odds(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_first3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_first3_odds([]) == []\nassert op_first3_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_first3_odds([3, 1, 2]) == [3, 1]\nassert op_first3_odds([10]) == []\nassert op_first3_odds([2, 4, 6]) == []\nassert op_first3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_absval", "entry_point": "op_padto3_absval", "primitives": ["padto3", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_padto3_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_absval([]) == [0, 0, 0]\nassert op_padto3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_absval([10]) == [10, 0, 0]\nassert op_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_ages_takewhilepos", "entry_point": "op_ages_takewhilepos", "primitives": ["ages", "takewhilepos"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive.", "solution": "def op_ages_takewhilepos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_ages_takewhilepos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos([]) == []\nassert op_ages_takewhilepos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortalpha_upper", "entry_point": "op_sortalpha_upper", "primitives": ["sortalpha", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then uppercase each string.", "solution": "def op_sortalpha_upper(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_sortalpha_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortalpha_upper([]) == []\nassert op_sortalpha_upper(['  a ', '', 'BC', 'bc']) == ['', '  A ', 'BC', 'BC']\nassert op_sortalpha_upper(['one', 'one', 'Two']) == ['TWO', 'ONE', 'ONE']\nassert op_sortalpha_upper(['x']) == ['X']\nassert op_sortalpha_upper(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_dropzeros_takewhilepos", "entry_point": "op_dropzeros_takewhilepos", "primitives": ["dropzeros", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive.", "solution": "def op_dropzeros_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_takewhilepos([]) == []\nassert op_dropzeros_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos([10]) == [10]\nassert op_dropzeros_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dec_odds", "entry_point": "op_dec_odds", "primitives": ["dec", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the odd numbers.", "solution": "def op_dec_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dec_odds([]) == []\nassert op_dec_odds([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_dec_odds([5, 5, 5]) == []\nassert op_dec_odds([3, 1, 2]) == [1]\nassert op_dec_odds([10]) == [9]\nassert op_dec_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_odds([-7, 12, -7]) == [11]"}
{"id": "op_clamp10_min", "entry_point": "op_clamp10_min", "primitives": ["clamp10", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return the minimum (0 if empty).", "solution": "def op_clamp10_min(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return min(r) if r else 0", "tests": "assert op_clamp10_min([1, 2, 3, 4]) == 1\nassert op_clamp10_min([]) == 0\nassert op_clamp10_min([-2, -1, 0, 1, 2]) == -2\nassert op_clamp10_min([5, 5, 5]) == 5\nassert op_clamp10_min([3, 1, 2]) == 1\nassert op_clamp10_min([10]) == 10\nassert op_clamp10_min([2, 4, 6]) == 2\nassert op_clamp10_min([-7, 12, -7]) == -7"}
{"id": "op_div3_odds", "entry_point": "op_div3_odds", "primitives": ["div3", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers.", "solution": "def op_div3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_odds([1, 2, 3, 4]) == [3]\nassert op_div3_odds([]) == []\nassert op_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds([5, 5, 5]) == []\nassert op_div3_odds([3, 1, 2]) == [3]\nassert op_div3_odds([10]) == []\nassert op_div3_odds([2, 4, 6]) == []\nassert op_div3_odds([-7, 12, -7]) == []"}
{"id": "op_square_double", "entry_point": "op_square_double", "primitives": ["square", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each.", "solution": "def op_square_double(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_square_double([1, 2, 3, 4]) == [2, 8, 18, 32]\nassert op_square_double([]) == []\nassert op_square_double([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_square_double([5, 5, 5]) == [50, 50, 50]\nassert op_square_double([3, 1, 2]) == [18, 2, 8]\nassert op_square_double([10]) == [200]\nassert op_square_double([2, 4, 6]) == [8, 32, 72]\nassert op_square_double([-7, 12, -7]) == [98, 288, 98]"}
{"id": "op_firstchar_maxlen", "entry_point": "op_firstchar_maxlen", "primitives": ["firstchar", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then return the length of the longest string (0 if none).", "solution": "def op_firstchar_maxlen(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_firstchar_maxlen(['Hello', 'world']) == 1\nassert op_firstchar_maxlen([]) == 0\nassert op_firstchar_maxlen(['  a ', '', 'BC', 'bc']) == 1\nassert op_firstchar_maxlen(['one', 'one', 'Two']) == 1\nassert op_firstchar_maxlen(['x']) == 1\nassert op_firstchar_maxlen(['abc', 'de', '']) == 1"}
{"id": "op_first3_padto3", "entry_point": "op_first3_padto3", "primitives": ["first3", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_first3_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_padto3([]) == [0, 0, 0]\nassert op_first3_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_padto3([10]) == [10, 0, 0]\nassert op_first3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_evens_len", "entry_point": "op_evens_len", "primitives": ["evens", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return how many remain.", "solution": "def op_evens_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_evens_len([1, 2, 3, 4]) == 2\nassert op_evens_len([]) == 0\nassert op_evens_len([-2, -1, 0, 1, 2]) == 3\nassert op_evens_len([5, 5, 5]) == 0\nassert op_evens_len([3, 1, 2]) == 1\nassert op_evens_len([10]) == 1\nassert op_evens_len([2, 4, 6]) == 3\nassert op_evens_len([-7, 12, -7]) == 1"}
{"id": "op_sorta_neg", "entry_point": "op_sorta_neg", "primitives": ["sorta", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers.", "solution": "def op_sorta_neg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sorta_neg([1, 2, 3, 4]) == []\nassert op_sorta_neg([]) == []\nassert op_sorta_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_neg([5, 5, 5]) == []\nassert op_sorta_neg([3, 1, 2]) == []\nassert op_sorta_neg([10]) == []\nassert op_sorta_neg([2, 4, 6]) == []\nassert op_sorta_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_sum", "entry_point": "op_sortabs_sum", "primitives": ["sortabs", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return their sum.", "solution": "def op_sortabs_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return sum(r)", "tests": "assert op_sortabs_sum([1, 2, 3, 4]) == 10\nassert op_sortabs_sum([]) == 0\nassert op_sortabs_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_sum([5, 5, 5]) == 15\nassert op_sortabs_sum([3, 1, 2]) == 6\nassert op_sortabs_sum([10]) == 10\nassert op_sortabs_sum([2, 4, 6]) == 12\nassert op_sortabs_sum([-7, 12, -7]) == -2"}
{"id": "op_trimends_add10", "entry_point": "op_trimends_add10", "primitives": ["trimends", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each.", "solution": "def op_trimends_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_add10([]) == []\nassert op_trimends_add10([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10([5, 5, 5]) == [15]\nassert op_trimends_add10([3, 1, 2]) == [11]\nassert op_trimends_add10([10]) == []\nassert op_trimends_add10([2, 4, 6]) == [14]\nassert op_trimends_add10([-7, 12, -7]) == [22]"}
{"id": "op_uniq_div3", "entry_point": "op_uniq_div3", "primitives": ["uniq", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three.", "solution": "def op_uniq_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_div3([1, 2, 3, 4]) == [3]\nassert op_uniq_div3([]) == []\nassert op_uniq_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_div3([5, 5, 5]) == []\nassert op_uniq_div3([3, 1, 2]) == [3]\nassert op_uniq_div3([10]) == []\nassert op_uniq_div3([2, 4, 6]) == [6]\nassert op_uniq_div3([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_negate", "entry_point": "op_takewhilepos_negate", "primitives": ["takewhilepos", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each.", "solution": "def op_takewhilepos_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_negate([]) == []\nassert op_takewhilepos_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_takewhilepos_negate([10]) == [-10]\nassert op_takewhilepos_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_negate([-7, 12, -7]) == []"}
{"id": "op_odds_issorted", "entry_point": "op_odds_issorted", "primitives": ["odds", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_odds_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_odds_issorted([1, 2, 3, 4]) == True\nassert op_odds_issorted([]) == True\nassert op_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_issorted([5, 5, 5]) == True\nassert op_odds_issorted([3, 1, 2]) == False\nassert op_odds_issorted([10]) == True\nassert op_odds_issorted([2, 4, 6]) == True\nassert op_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_beforezero_dropfirst", "entry_point": "op_beforezero_dropfirst", "primitives": ["beforezero", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element.", "solution": "def op_beforezero_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_dropfirst([]) == []\nassert op_beforezero_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_dropfirst([5, 5, 5]) == [5, 5]\nassert op_beforezero_dropfirst([3, 1, 2]) == [1, 2]\nassert op_beforezero_dropfirst([10]) == []\nassert op_beforezero_dropfirst([2, 4, 6]) == [4, 6]\nassert op_beforezero_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropzeros_gt5", "entry_point": "op_dropzeros_gt5", "primitives": ["dropzeros", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five.", "solution": "def op_dropzeros_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_dropzeros_gt5([]) == []\nassert op_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_gt5([5, 5, 5]) == []\nassert op_dropzeros_gt5([3, 1, 2]) == []\nassert op_dropzeros_gt5([10]) == [10]\nassert op_dropzeros_gt5([2, 4, 6]) == [6]\nassert op_dropzeros_gt5([-7, 12, -7]) == [12]"}
{"id": "op_gt5_prod", "entry_point": "op_gt5_prod", "primitives": ["gt5", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return their product.", "solution": "def op_gt5_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return __import__('math').prod(r)", "tests": "assert op_gt5_prod([1, 2, 3, 4]) == 1\nassert op_gt5_prod([]) == 1\nassert op_gt5_prod([-2, -1, 0, 1, 2]) == 1\nassert op_gt5_prod([5, 5, 5]) == 1\nassert op_gt5_prod([3, 1, 2]) == 1\nassert op_gt5_prod([10]) == 10\nassert op_gt5_prod([2, 4, 6]) == 6\nassert op_gt5_prod([-7, 12, -7]) == 12"}
{"id": "op_sorta_add10", "entry_point": "op_sorta_add10", "primitives": ["sorta", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each.", "solution": "def op_sorta_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sorta_add10([]) == []\nassert op_sorta_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_sorta_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_add10([3, 1, 2]) == [11, 12, 13]\nassert op_sorta_add10([10]) == [20]\nassert op_sorta_add10([2, 4, 6]) == [12, 14, 16]\nassert op_sorta_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_beforezero_add10", "entry_point": "op_beforezero_add10", "primitives": ["beforezero", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each.", "solution": "def op_beforezero_add10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_beforezero_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_beforezero_add10([]) == []\nassert op_beforezero_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_beforezero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_beforezero_add10([10]) == [20]\nassert op_beforezero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_beforezero_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_first3_counteven", "entry_point": "op_first3_counteven", "primitives": ["first3", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return how many values are even.", "solution": "def op_first3_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_counteven([1, 2, 3, 4]) == 1\nassert op_first3_counteven([]) == 0\nassert op_first3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_counteven([5, 5, 5]) == 0\nassert op_first3_counteven([3, 1, 2]) == 1\nassert op_first3_counteven([10]) == 1\nassert op_first3_counteven([2, 4, 6]) == 3\nassert op_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_odds_rev", "entry_point": "op_odds_rev", "primitives": ["odds", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order.", "solution": "def op_odds_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_odds_rev([1, 2, 3, 4]) == [3, 1]\nassert op_odds_rev([]) == []\nassert op_odds_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_rev([5, 5, 5]) == [5, 5, 5]\nassert op_odds_rev([3, 1, 2]) == [1, 3]\nassert op_odds_rev([10]) == []\nassert op_odds_rev([2, 4, 6]) == []\nassert op_odds_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_max", "entry_point": "op_square_max", "primitives": ["square", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return the maximum (0 if empty).", "solution": "def op_square_max(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_square_max([1, 2, 3, 4]) == 16\nassert op_square_max([]) == 0\nassert op_square_max([-2, -1, 0, 1, 2]) == 4\nassert op_square_max([5, 5, 5]) == 25\nassert op_square_max([3, 1, 2]) == 9\nassert op_square_max([10]) == 100\nassert op_square_max([2, 4, 6]) == 36\nassert op_square_max([-7, 12, -7]) == 144"}
{"id": "op_div3_max", "entry_point": "op_div3_max", "primitives": ["div3", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return the maximum (0 if empty).", "solution": "def op_div3_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return max(r) if r else 0", "tests": "assert op_div3_max([1, 2, 3, 4]) == 3\nassert op_div3_max([]) == 0\nassert op_div3_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_max([5, 5, 5]) == 0\nassert op_div3_max([3, 1, 2]) == 3\nassert op_div3_max([10]) == 0\nassert op_div3_max([2, 4, 6]) == 6\nassert op_div3_max([-7, 12, -7]) == 12"}
{"id": "op_padto3_haszero", "entry_point": "op_padto3_haszero", "primitives": ["padto3", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_padto3_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_padto3_haszero([1, 2, 3, 4]) == False\nassert op_padto3_haszero([]) == True\nassert op_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_haszero([5, 5, 5]) == False\nassert op_padto3_haszero([3, 1, 2]) == False\nassert op_padto3_haszero([10]) == True\nassert op_padto3_haszero([2, 4, 6]) == False\nassert op_padto3_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_uniq", "entry_point": "op_div3_uniq", "primitives": ["div3", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence.", "solution": "def op_div3_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_uniq([1, 2, 3, 4]) == [3]\nassert op_div3_uniq([]) == []\nassert op_div3_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_uniq([5, 5, 5]) == []\nassert op_div3_uniq([3, 1, 2]) == [3]\nassert op_div3_uniq([10]) == []\nassert op_div3_uniq([2, 4, 6]) == [6]\nassert op_div3_uniq([-7, 12, -7]) == [12]"}
{"id": "op_absval_trimends", "entry_point": "op_absval_trimends", "primitives": ["absval", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements.", "solution": "def op_absval_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_absval_trimends([]) == []\nassert op_absval_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_absval_trimends([5, 5, 5]) == [5]\nassert op_absval_trimends([3, 1, 2]) == [1]\nassert op_absval_trimends([10]) == []\nassert op_absval_trimends([2, 4, 6]) == [4]\nassert op_absval_trimends([-7, 12, -7]) == [12]"}
{"id": "op_double_oremptyzero", "entry_point": "op_double_oremptyzero", "primitives": ["double", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero.", "solution": "def op_double_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_oremptyzero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero([]) == [0]\nassert op_double_oremptyzero([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero([10]) == [20]\nassert op_double_oremptyzero([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_ages_div3", "entry_point": "op_ages_div3", "primitives": ["ages", "div3"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three.", "solution": "def op_ages_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_div3([]) == []\nassert op_ages_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_square_padto3", "entry_point": "op_square_padto3", "primitives": ["square", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements.", "solution": "def op_square_padto3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_square_padto3([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_padto3([]) == [0, 0, 0]\nassert op_square_padto3([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3([3, 1, 2]) == [9, 1, 4]\nassert op_square_padto3([10]) == [100, 0, 0]\nassert op_square_padto3([2, 4, 6]) == [4, 16, 36]\nassert op_square_padto3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_first3_oremptyzero", "entry_point": "op_first3_oremptyzero", "primitives": ["first3", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero.", "solution": "def op_first3_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_oremptyzero([]) == [0]\nassert op_first3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_oremptyzero([10]) == [10]\nassert op_first3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_pos_rev", "entry_point": "op_pos_rev", "primitives": ["pos", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order.", "solution": "def op_pos_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_rev([]) == []\nassert op_pos_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_pos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_pos_rev([10]) == [10]\nassert op_pos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_pos_rev([-7, 12, -7]) == [12]"}
{"id": "op_inc_oremptyzero", "entry_point": "op_inc_oremptyzero", "primitives": ["inc", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero.", "solution": "def op_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_oremptyzero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_oremptyzero([]) == [0]\nassert op_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_inc_oremptyzero([10]) == [11]\nassert op_inc_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropzeros_sum", "entry_point": "op_dropzeros_sum", "primitives": ["dropzeros", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return their sum.", "solution": "def op_dropzeros_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_dropzeros_sum([1, 2, 3, 4]) == 10\nassert op_dropzeros_sum([]) == 0\nassert op_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_sum([5, 5, 5]) == 15\nassert op_dropzeros_sum([3, 1, 2]) == 6\nassert op_dropzeros_sum([10]) == 10\nassert op_dropzeros_sum([2, 4, 6]) == 12\nassert op_dropzeros_sum([-7, 12, -7]) == -2"}
{"id": "op_negate_counteven", "entry_point": "op_negate_counteven", "primitives": ["negate", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return how many values are even.", "solution": "def op_negate_counteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_negate_counteven([1, 2, 3, 4]) == 2\nassert op_negate_counteven([]) == 0\nassert op_negate_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_negate_counteven([5, 5, 5]) == 0\nassert op_negate_counteven([3, 1, 2]) == 1\nassert op_negate_counteven([10]) == 1\nassert op_negate_counteven([2, 4, 6]) == 3\nassert op_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_firsteven", "entry_point": "op_sortd_firsteven", "primitives": ["sortd", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return the first even value (0 if none).", "solution": "def op_sortd_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortd_firsteven([1, 2, 3, 4]) == 4\nassert op_sortd_firsteven([]) == 0\nassert op_sortd_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_firsteven([5, 5, 5]) == 0\nassert op_sortd_firsteven([3, 1, 2]) == 2\nassert op_sortd_firsteven([10]) == 10\nassert op_sortd_firsteven([2, 4, 6]) == 6\nassert op_sortd_firsteven([-7, 12, -7]) == 12"}
{"id": "op_uniqs_firstchar", "entry_point": "op_uniqs_firstchar", "primitives": ["uniqs", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then keep the first character of each (dropping empties).", "solution": "def op_uniqs_firstchar(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_uniqs_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_uniqs_firstchar([]) == []\nassert op_uniqs_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_uniqs_firstchar(['one', 'one', 'Two']) == ['o', 'T']\nassert op_uniqs_firstchar(['x']) == ['x']\nassert op_uniqs_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_gt5_absval", "entry_point": "op_gt5_absval", "primitives": ["gt5", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take the absolute value of each.", "solution": "def op_gt5_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_absval([1, 2, 3, 4]) == []\nassert op_gt5_absval([]) == []\nassert op_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_absval([5, 5, 5]) == []\nassert op_gt5_absval([3, 1, 2]) == []\nassert op_gt5_absval([10]) == [10]\nassert op_gt5_absval([2, 4, 6]) == [6]\nassert op_gt5_absval([-7, 12, -7]) == [12]"}
{"id": "op_uniq_counteven", "entry_point": "op_uniq_counteven", "primitives": ["uniq", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_uniq_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_counteven([1, 2, 3, 4]) == 2\nassert op_uniq_counteven([]) == 0\nassert op_uniq_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_uniq_counteven([5, 5, 5]) == 0\nassert op_uniq_counteven([3, 1, 2]) == 1\nassert op_uniq_counteven([10]) == 1\nassert op_uniq_counteven([2, 4, 6]) == 3\nassert op_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_negate", "entry_point": "op_clamp10_negate", "primitives": ["clamp10", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each.", "solution": "def op_clamp10_negate(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_clamp10_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_clamp10_negate([]) == []\nassert op_clamp10_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_clamp10_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_clamp10_negate([10]) == [-10]\nassert op_clamp10_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_clamp10_negate([-7, 12, -7]) == [7, -10, 7]"}
{"id": "op_div3_evens", "entry_point": "op_div3_evens", "primitives": ["div3", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers.", "solution": "def op_div3_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_div3_evens([1, 2, 3, 4]) == []\nassert op_div3_evens([]) == []\nassert op_div3_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_evens([5, 5, 5]) == []\nassert op_div3_evens([3, 1, 2]) == []\nassert op_div3_evens([10]) == []\nassert op_div3_evens([2, 4, 6]) == [6]\nassert op_div3_evens([-7, 12, -7]) == [12]"}
{"id": "op_gt5_uniq", "entry_point": "op_gt5_uniq", "primitives": ["gt5", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_gt5_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_gt5_uniq([1, 2, 3, 4]) == []\nassert op_gt5_uniq([]) == []\nassert op_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_gt5_uniq([5, 5, 5]) == []\nassert op_gt5_uniq([3, 1, 2]) == []\nassert op_gt5_uniq([10]) == [10]\nassert op_gt5_uniq([2, 4, 6]) == [6]\nassert op_gt5_uniq([-7, 12, -7]) == [12]"}
{"id": "op_uniq_neg", "entry_point": "op_uniq_neg", "primitives": ["uniq", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers.", "solution": "def op_uniq_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_neg([1, 2, 3, 4]) == []\nassert op_uniq_neg([]) == []\nassert op_uniq_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_neg([5, 5, 5]) == []\nassert op_uniq_neg([3, 1, 2]) == []\nassert op_uniq_neg([10]) == []\nassert op_uniq_neg([2, 4, 6]) == []\nassert op_uniq_neg([-7, 12, -7]) == [-7]"}
{"id": "op_odds_sortd", "entry_point": "op_odds_sortd", "primitives": ["odds", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort descending.", "solution": "def op_odds_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_odds_sortd([]) == []\nassert op_odds_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_odds_sortd([10]) == []\nassert op_odds_sortd([2, 4, 6]) == []\nassert op_odds_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_firsteven", "entry_point": "op_padto3_firsteven", "primitives": ["padto3", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return the first even value (0 if none).", "solution": "def op_padto3_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_firsteven([1, 2, 3, 4]) == 2\nassert op_padto3_firsteven([]) == 0\nassert op_padto3_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_firsteven([5, 5, 5]) == 0\nassert op_padto3_firsteven([3, 1, 2]) == 2\nassert op_padto3_firsteven([10]) == 10\nassert op_padto3_firsteven([2, 4, 6]) == 2\nassert op_padto3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_negate_issorted", "entry_point": "op_negate_issorted", "primitives": ["negate", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return whether the list is sorted ascending.", "solution": "def op_negate_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_negate_issorted([1, 2, 3, 4]) == False\nassert op_negate_issorted([]) == True\nassert op_negate_issorted([-2, -1, 0, 1, 2]) == False\nassert op_negate_issorted([5, 5, 5]) == True\nassert op_negate_issorted([3, 1, 2]) == False\nassert op_negate_issorted([10]) == True\nassert op_negate_issorted([2, 4, 6]) == False\nassert op_negate_issorted([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_uniq", "entry_point": "op_oremptyzero_uniq", "primitives": ["oremptyzero", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_uniq([]) == [0]\nassert op_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_uniq([10]) == [10]\nassert op_oremptyzero_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_odds_min", "entry_point": "op_odds_min", "primitives": ["odds", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return the minimum (0 if empty).", "solution": "def op_odds_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return min(r) if r else 0", "tests": "assert op_odds_min([1, 2, 3, 4]) == 1\nassert op_odds_min([]) == 0\nassert op_odds_min([-2, -1, 0, 1, 2]) == -1\nassert op_odds_min([5, 5, 5]) == 5\nassert op_odds_min([3, 1, 2]) == 1\nassert op_odds_min([10]) == 0\nassert op_odds_min([2, 4, 6]) == 0\nassert op_odds_min([-7, 12, -7]) == -7"}
{"id": "op_upper_longest", "entry_point": "op_upper_longest", "primitives": ["upper", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then return the longest string (empty if none).", "solution": "def op_upper_longest(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_upper_longest(['Hello', 'world']) == 'HELLO'\nassert op_upper_longest([]) == ''\nassert op_upper_longest(['  a ', '', 'BC', 'bc']) == '  A '\nassert op_upper_longest(['one', 'one', 'Two']) == 'ONE'\nassert op_upper_longest(['x']) == 'X'\nassert op_upper_longest(['abc', 'de', '']) == 'ABC'"}
{"id": "op_dropfirst_double", "entry_point": "op_dropfirst_double", "primitives": ["dropfirst", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then double each.", "solution": "def op_dropfirst_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropfirst_double([]) == []\nassert op_dropfirst_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_dropfirst_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_double([3, 1, 2]) == [2, 4]\nassert op_dropfirst_double([10]) == []\nassert op_dropfirst_double([2, 4, 6]) == [8, 12]\nassert op_dropfirst_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_oremptyzero_rev", "entry_point": "op_oremptyzero_rev", "primitives": ["oremptyzero", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order.", "solution": "def op_oremptyzero_rev(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_oremptyzero_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_oremptyzero_rev([]) == [0]\nassert op_oremptyzero_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_oremptyzero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_oremptyzero_rev([10]) == [10]\nassert op_oremptyzero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_oremptyzero_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst_add10", "entry_point": "op_dropfirst_add10", "primitives": ["dropfirst", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each.", "solution": "def op_dropfirst_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_add10([]) == []\nassert op_dropfirst_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_dropfirst_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_add10([3, 1, 2]) == [11, 12]\nassert op_dropfirst_add10([10]) == []\nassert op_dropfirst_add10([2, 4, 6]) == [14, 16]\nassert op_dropfirst_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_add10_dropwhileneg", "entry_point": "op_add10_dropwhileneg", "primitives": ["add10", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values.", "solution": "def op_add10_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_dropwhileneg([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropwhileneg([]) == []\nassert op_add10_dropwhileneg([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropwhileneg([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropwhileneg([10]) == [20]\nassert op_add10_dropwhileneg([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropwhileneg([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_negate_max", "entry_point": "op_negate_max", "primitives": ["negate", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return the maximum (0 if empty).", "solution": "def op_negate_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return max(r) if r else 0", "tests": "assert op_negate_max([1, 2, 3, 4]) == -1\nassert op_negate_max([]) == 0\nassert op_negate_max([-2, -1, 0, 1, 2]) == 2\nassert op_negate_max([5, 5, 5]) == -5\nassert op_negate_max([3, 1, 2]) == -1\nassert op_negate_max([10]) == -10\nassert op_negate_max([2, 4, 6]) == -2\nassert op_negate_max([-7, 12, -7]) == 7"}
{"id": "op_dropwhileneg_neg", "entry_point": "op_dropwhileneg_neg", "primitives": ["dropwhileneg", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers.", "solution": "def op_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg([]) == []\nassert op_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg([5, 5, 5]) == []\nassert op_dropwhileneg_neg([3, 1, 2]) == []\nassert op_dropwhileneg_neg([10]) == []\nassert op_dropwhileneg_neg([2, 4, 6]) == []\nassert op_dropwhileneg_neg([-7, 12, -7]) == [-7]"}
{"id": "op_double_prod", "entry_point": "op_double_prod", "primitives": ["double", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return their product.", "solution": "def op_double_prod(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_double_prod([1, 2, 3, 4]) == 384\nassert op_double_prod([]) == 1\nassert op_double_prod([-2, -1, 0, 1, 2]) == 0\nassert op_double_prod([5, 5, 5]) == 1000\nassert op_double_prod([3, 1, 2]) == 48\nassert op_double_prod([10]) == 20\nassert op_double_prod([2, 4, 6]) == 384\nassert op_double_prod([-7, 12, -7]) == 4704"}
{"id": "op_uniq_haszero", "entry_point": "op_uniq_haszero", "primitives": ["uniq", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_uniq_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_uniq_haszero([1, 2, 3, 4]) == False\nassert op_uniq_haszero([]) == False\nassert op_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_uniq_haszero([5, 5, 5]) == False\nassert op_uniq_haszero([3, 1, 2]) == False\nassert op_uniq_haszero([10]) == False\nassert op_uniq_haszero([2, 4, 6]) == False\nassert op_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_sum", "entry_point": "op_sortd_sum", "primitives": ["sortd", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return their sum.", "solution": "def op_sortd_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return sum(r)", "tests": "assert op_sortd_sum([1, 2, 3, 4]) == 10\nassert op_sortd_sum([]) == 0\nassert op_sortd_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_sum([5, 5, 5]) == 15\nassert op_sortd_sum([3, 1, 2]) == 6\nassert op_sortd_sum([10]) == 10\nassert op_sortd_sum([2, 4, 6]) == 12\nassert op_sortd_sum([-7, 12, -7]) == -2"}
{"id": "op_first3_negate", "entry_point": "op_first3_negate", "primitives": ["first3", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then negate each.", "solution": "def op_first3_negate(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_first3_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_first3_negate([]) == []\nassert op_first3_negate([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_first3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_first3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_first3_negate([10]) == [-10]\nassert op_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_first3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_uniq_dec", "entry_point": "op_uniq_dec", "primitives": ["uniq", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each.", "solution": "def op_uniq_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_uniq_dec([]) == []\nassert op_uniq_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_uniq_dec([5, 5, 5]) == [4]\nassert op_uniq_dec([3, 1, 2]) == [2, 0, 1]\nassert op_uniq_dec([10]) == [9]\nassert op_uniq_dec([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_dec([-7, 12, -7]) == [-8, 11]"}
{"id": "op_clamp10_alldistinct", "entry_point": "op_clamp10_alldistinct", "primitives": ["clamp10", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return whether all values are distinct.", "solution": "def op_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_clamp10_alldistinct([]) == True\nassert op_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_alldistinct([5, 5, 5]) == False\nassert op_clamp10_alldistinct([3, 1, 2]) == True\nassert op_clamp10_alldistinct([10]) == True\nassert op_clamp10_alldistinct([2, 4, 6]) == True\nassert op_clamp10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_trimends", "entry_point": "op_dropzeros_trimends", "primitives": ["dropzeros", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first and last elements.", "solution": "def op_dropzeros_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropzeros_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_dropzeros_trimends([]) == []\nassert op_dropzeros_trimends([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_trimends([5, 5, 5]) == [5]\nassert op_dropzeros_trimends([3, 1, 2]) == [1]\nassert op_dropzeros_trimends([10]) == []\nassert op_dropzeros_trimends([2, 4, 6]) == [4]\nassert op_dropzeros_trimends([-7, 12, -7]) == [12]"}
{"id": "op_gt5_last3", "entry_point": "op_gt5_last3", "primitives": ["gt5", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three.", "solution": "def op_gt5_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    return r", "tests": "assert op_gt5_last3([1, 2, 3, 4]) == []\nassert op_gt5_last3([]) == []\nassert op_gt5_last3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_last3([5, 5, 5]) == []\nassert op_gt5_last3([3, 1, 2]) == []\nassert op_gt5_last3([10]) == [10]\nassert op_gt5_last3([2, 4, 6]) == [6]\nassert op_gt5_last3([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_prod", "entry_point": "op_beforezero_prod", "primitives": ["beforezero", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return their product.", "solution": "def op_beforezero_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_beforezero_prod([]) == 1\nassert op_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_prod([5, 5, 5]) == 125\nassert op_beforezero_prod([3, 1, 2]) == 6\nassert op_beforezero_prod([10]) == 10\nassert op_beforezero_prod([2, 4, 6]) == 48\nassert op_beforezero_prod([-7, 12, -7]) == 588"}
{"id": "op_neg_rev", "entry_point": "op_neg_rev", "primitives": ["neg", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order.", "solution": "def op_neg_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_neg_rev([1, 2, 3, 4]) == []\nassert op_neg_rev([]) == []\nassert op_neg_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_rev([5, 5, 5]) == []\nassert op_neg_rev([3, 1, 2]) == []\nassert op_neg_rev([10]) == []\nassert op_neg_rev([2, 4, 6]) == []\nassert op_neg_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_inc", "entry_point": "op_uniq_inc", "primitives": ["uniq", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_uniq_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_uniq_inc([]) == []\nassert op_uniq_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_uniq_inc([5, 5, 5]) == [6]\nassert op_uniq_inc([3, 1, 2]) == [4, 2, 3]\nassert op_uniq_inc([10]) == [11]\nassert op_uniq_inc([2, 4, 6]) == [3, 5, 7]\nassert op_uniq_inc([-7, 12, -7]) == [-6, 13]"}
{"id": "op_sortabs_issorted", "entry_point": "op_sortabs_issorted", "primitives": ["sortabs", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_sortabs_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_sortabs_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_issorted([]) == True\nassert op_sortabs_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_issorted([5, 5, 5]) == True\nassert op_sortabs_issorted([3, 1, 2]) == True\nassert op_sortabs_issorted([10]) == True\nassert op_sortabs_issorted([2, 4, 6]) == True\nassert op_sortabs_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_odds", "entry_point": "op_uniq_odds", "primitives": ["uniq", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_uniq_odds(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_uniq_odds([]) == []\nassert op_uniq_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_uniq_odds([5, 5, 5]) == [5]\nassert op_uniq_odds([3, 1, 2]) == [3, 1]\nassert op_uniq_odds([10]) == []\nassert op_uniq_odds([2, 4, 6]) == []\nassert op_uniq_odds([-7, 12, -7]) == [-7]"}
{"id": "op_sortd_sortabs", "entry_point": "op_sortd_sortabs", "primitives": ["sortd", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value.", "solution": "def op_sortd_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortd_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sortabs([]) == []\nassert op_sortd_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortd_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sortabs([10]) == [10]\nassert op_sortd_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_uniq_prod", "entry_point": "op_uniq_prod", "primitives": ["uniq", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return their product.", "solution": "def op_uniq_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_uniq_prod([1, 2, 3, 4]) == 24\nassert op_uniq_prod([]) == 1\nassert op_uniq_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_prod([5, 5, 5]) == 5\nassert op_uniq_prod([3, 1, 2]) == 6\nassert op_uniq_prod([10]) == 10\nassert op_uniq_prod([2, 4, 6]) == 48\nassert op_uniq_prod([-7, 12, -7]) == -84"}
{"id": "op_sorta_takewhilepos", "entry_point": "op_sorta_takewhilepos", "primitives": ["sorta", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive.", "solution": "def op_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sorta_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_takewhilepos([]) == []\nassert op_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_takewhilepos([10]) == [10]\nassert op_sorta_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sortabs_dropzeros", "entry_point": "op_sortabs_dropzeros", "primitives": ["sortabs", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros.", "solution": "def op_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_dropzeros([]) == []\nassert op_sortabs_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_dropzeros([10]) == [10]\nassert op_sortabs_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_absval", "entry_point": "op_sortabs_absval", "primitives": ["sortabs", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each.", "solution": "def op_sortabs_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_absval([]) == []\nassert op_sortabs_absval([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_sortabs_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_absval([10]) == [10]\nassert op_sortabs_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_first3_div3", "entry_point": "op_first3_div3", "primitives": ["first3", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep multiples of three.", "solution": "def op_first3_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_div3([1, 2, 3, 4]) == [3]\nassert op_first3_div3([]) == []\nassert op_first3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_div3([5, 5, 5]) == []\nassert op_first3_div3([3, 1, 2]) == [3]\nassert op_first3_div3([10]) == []\nassert op_first3_div3([2, 4, 6]) == [6]\nassert op_first3_div3([-7, 12, -7]) == [12]"}
{"id": "op_absval_counteven", "entry_point": "op_absval_counteven", "primitives": ["absval", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return how many values are even.", "solution": "def op_absval_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_counteven([1, 2, 3, 4]) == 2\nassert op_absval_counteven([]) == 0\nassert op_absval_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_absval_counteven([5, 5, 5]) == 0\nassert op_absval_counteven([3, 1, 2]) == 1\nassert op_absval_counteven([10]) == 1\nassert op_absval_counteven([2, 4, 6]) == 3\nassert op_absval_counteven([-7, 12, -7]) == 1"}
{"id": "op_inc_rev", "entry_point": "op_inc_rev", "primitives": ["inc", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order.", "solution": "def op_inc_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_rev([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_rev([]) == []\nassert op_inc_rev([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_rev([5, 5, 5]) == [6, 6, 6]\nassert op_inc_rev([3, 1, 2]) == [3, 2, 4]\nassert op_inc_rev([10]) == [11]\nassert op_inc_rev([2, 4, 6]) == [7, 5, 3]\nassert op_inc_rev([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_firstchar_joinc", "entry_point": "op_firstchar_joinc", "primitives": ["firstchar", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then join them with commas.", "solution": "def op_firstchar_joinc(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return ','.join(r)", "tests": "assert op_firstchar_joinc(['Hello', 'world']) == 'H,w'\nassert op_firstchar_joinc([]) == ''\nassert op_firstchar_joinc(['  a ', '', 'BC', 'bc']) == ' ,B,b'\nassert op_firstchar_joinc(['one', 'one', 'Two']) == 'o,o,T'\nassert op_firstchar_joinc(['x']) == 'x'\nassert op_firstchar_joinc(['abc', 'de', '']) == 'a,d'"}
{"id": "op_double_sortabs", "entry_point": "op_double_sortabs", "primitives": ["double", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value.", "solution": "def op_double_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_sortabs([]) == []\nassert op_double_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_double_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_double_sortabs([10]) == [20]\nassert op_double_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_double_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_sortabs_max", "entry_point": "op_sortabs_max", "primitives": ["sortabs", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_sortabs_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_sortabs_max([1, 2, 3, 4]) == 4\nassert op_sortabs_max([]) == 0\nassert op_sortabs_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_max([5, 5, 5]) == 5\nassert op_sortabs_max([3, 1, 2]) == 3\nassert op_sortabs_max([10]) == 10\nassert op_sortabs_max([2, 4, 6]) == 6\nassert op_sortabs_max([-7, 12, -7]) == 12"}
{"id": "op_last3_anyeven", "entry_point": "op_last3_anyeven", "primitives": ["last3", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return whether any value is even.", "solution": "def op_last3_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_anyeven([1, 2, 3, 4]) == True\nassert op_last3_anyeven([]) == False\nassert op_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_anyeven([5, 5, 5]) == False\nassert op_last3_anyeven([3, 1, 2]) == True\nassert op_last3_anyeven([10]) == True\nassert op_last3_anyeven([2, 4, 6]) == True\nassert op_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_rev_counteven", "entry_point": "op_rev_counteven", "primitives": ["rev", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return how many values are even.", "solution": "def op_rev_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_counteven([1, 2, 3, 4]) == 2\nassert op_rev_counteven([]) == 0\nassert op_rev_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_rev_counteven([5, 5, 5]) == 0\nassert op_rev_counteven([3, 1, 2]) == 1\nassert op_rev_counteven([10]) == 1\nassert op_rev_counteven([2, 4, 6]) == 3\nassert op_rev_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_allpos", "entry_point": "op_neg_allpos", "primitives": ["neg", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return whether all values are positive.", "solution": "def op_neg_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_neg_allpos([1, 2, 3, 4]) == True\nassert op_neg_allpos([]) == True\nassert op_neg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_neg_allpos([5, 5, 5]) == True\nassert op_neg_allpos([3, 1, 2]) == True\nassert op_neg_allpos([10]) == True\nassert op_neg_allpos([2, 4, 6]) == True\nassert op_neg_allpos([-7, 12, -7]) == False"}
{"id": "op_sorta_first3", "entry_point": "op_sorta_first3", "primitives": ["sorta", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three.", "solution": "def op_sorta_first3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    return r", "tests": "assert op_sorta_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_first3([]) == []\nassert op_sorta_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_sorta_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_first3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_first3([10]) == [10]\nassert op_sorta_first3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_first3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_absval_uniq", "entry_point": "op_absval_uniq", "primitives": ["absval", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_absval_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_uniq([]) == []\nassert op_absval_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_uniq([5, 5, 5]) == [5]\nassert op_absval_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_absval_uniq([10]) == [10]\nassert op_absval_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_absval_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_double_pos", "entry_point": "op_double_pos", "primitives": ["double", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers.", "solution": "def op_double_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_pos([]) == []\nassert op_double_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_pos([10]) == [20]\nassert op_double_pos([2, 4, 6]) == [4, 8, 12]\nassert op_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_padto3_alldistinct", "entry_point": "op_padto3_alldistinct", "primitives": ["padto3", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return whether all values are distinct.", "solution": "def op_padto3_alldistinct(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r) == len(set(r))", "tests": "assert op_padto3_alldistinct([1, 2, 3, 4]) == True\nassert op_padto3_alldistinct([]) == False\nassert op_padto3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_padto3_alldistinct([5, 5, 5]) == False\nassert op_padto3_alldistinct([3, 1, 2]) == True\nassert op_padto3_alldistinct([10]) == False\nassert op_padto3_alldistinct([2, 4, 6]) == True\nassert op_padto3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_ages_dropwhileneg", "entry_point": "op_ages_dropwhileneg", "primitives": ["ages", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values.", "solution": "def op_ages_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropwhileneg([]) == []\nassert op_ages_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropwhileneg([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_takewhilepos_dropzeros", "entry_point": "op_takewhilepos_dropzeros", "primitives": ["takewhilepos", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros.", "solution": "def op_takewhilepos_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_dropzeros([]) == []\nassert op_takewhilepos_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropzeros([10]) == [10]\nassert op_takewhilepos_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropzeros([-7, 12, -7]) == []"}
{"id": "op_upper_firstchar", "entry_point": "op_upper_firstchar", "primitives": ["upper", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then keep the first character of each (dropping empties).", "solution": "def op_upper_firstchar(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_upper_firstchar(['Hello', 'world']) == ['H', 'W']\nassert op_upper_firstchar([]) == []\nassert op_upper_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'B']\nassert op_upper_firstchar(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_upper_firstchar(['x']) == ['X']\nassert op_upper_firstchar(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_gt5_sortd", "entry_point": "op_gt5_sortd", "primitives": ["gt5", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending.", "solution": "def op_gt5_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_sortd([1, 2, 3, 4]) == []\nassert op_gt5_sortd([]) == []\nassert op_gt5_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd([5, 5, 5]) == []\nassert op_gt5_sortd([3, 1, 2]) == []\nassert op_gt5_sortd([10]) == [10]\nassert op_gt5_sortd([2, 4, 6]) == [6]\nassert op_gt5_sortd([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_anyeven", "entry_point": "op_dropzeros_anyeven", "primitives": ["dropzeros", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return whether any value is even.", "solution": "def op_dropzeros_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_anyeven([]) == False\nassert op_dropzeros_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_anyeven([5, 5, 5]) == False\nassert op_dropzeros_anyeven([3, 1, 2]) == True\nassert op_dropzeros_anyeven([10]) == True\nassert op_dropzeros_anyeven([2, 4, 6]) == True\nassert op_dropzeros_anyeven([-7, 12, -7]) == True"}
{"id": "op_double_haszero", "entry_point": "op_double_haszero", "primitives": ["double", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return whether the list contains a zero.", "solution": "def op_double_haszero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_double_haszero([1, 2, 3, 4]) == False\nassert op_double_haszero([]) == False\nassert op_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_double_haszero([5, 5, 5]) == False\nassert op_double_haszero([3, 1, 2]) == False\nassert op_double_haszero([10]) == False\nassert op_double_haszero([2, 4, 6]) == False\nassert op_double_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_dropwhileneg", "entry_point": "op_trimends_dropwhileneg", "primitives": ["trimends", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values.", "solution": "def op_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_dropwhileneg([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_dropwhileneg([]) == []\nassert op_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_dropwhileneg([5, 5, 5]) == [5]\nassert op_trimends_dropwhileneg([3, 1, 2]) == [1]\nassert op_trimends_dropwhileneg([10]) == []\nassert op_trimends_dropwhileneg([2, 4, 6]) == [4]\nassert op_trimends_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_div3_alldistinct", "entry_point": "op_div3_alldistinct", "primitives": ["div3", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return whether all values are distinct.", "solution": "def op_div3_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_alldistinct([]) == True\nassert op_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_alldistinct([5, 5, 5]) == True\nassert op_div3_alldistinct([3, 1, 2]) == True\nassert op_div3_alldistinct([10]) == True\nassert op_div3_alldistinct([2, 4, 6]) == True\nassert op_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_neg_sortd", "entry_point": "op_neg_sortd", "primitives": ["neg", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending.", "solution": "def op_neg_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_neg_sortd([1, 2, 3, 4]) == []\nassert op_neg_sortd([]) == []\nassert op_neg_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_sortd([5, 5, 5]) == []\nassert op_neg_sortd([3, 1, 2]) == []\nassert op_neg_sortd([10]) == []\nassert op_neg_sortd([2, 4, 6]) == []\nassert op_neg_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_inc_sum", "entry_point": "op_inc_sum", "primitives": ["inc", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return their sum.", "solution": "def op_inc_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_inc_sum([1, 2, 3, 4]) == 14\nassert op_inc_sum([]) == 0\nassert op_inc_sum([-2, -1, 0, 1, 2]) == 5\nassert op_inc_sum([5, 5, 5]) == 18\nassert op_inc_sum([3, 1, 2]) == 9\nassert op_inc_sum([10]) == 11\nassert op_inc_sum([2, 4, 6]) == 15\nassert op_inc_sum([-7, 12, -7]) == 1"}
{"id": "op_sortabs_div3", "entry_point": "op_sortabs_div3", "primitives": ["sortabs", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three.", "solution": "def op_sortabs_div3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortabs_div3([1, 2, 3, 4]) == [3]\nassert op_sortabs_div3([]) == []\nassert op_sortabs_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortabs_div3([5, 5, 5]) == []\nassert op_sortabs_div3([3, 1, 2]) == [3]\nassert op_sortabs_div3([10]) == []\nassert op_sortabs_div3([2, 4, 6]) == [6]\nassert op_sortabs_div3([-7, 12, -7]) == [12]"}
{"id": "op_evens_issorted", "entry_point": "op_evens_issorted", "primitives": ["evens", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return whether the list is sorted ascending.", "solution": "def op_evens_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return r == sorted(r)", "tests": "assert op_evens_issorted([1, 2, 3, 4]) == True\nassert op_evens_issorted([]) == True\nassert op_evens_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_issorted([5, 5, 5]) == True\nassert op_evens_issorted([3, 1, 2]) == True\nassert op_evens_issorted([10]) == True\nassert op_evens_issorted([2, 4, 6]) == True\nassert op_evens_issorted([-7, 12, -7]) == True"}
{"id": "op_trimends_gt5", "entry_point": "op_trimends_gt5", "primitives": ["trimends", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep values greater than five.", "solution": "def op_trimends_gt5(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_trimends_gt5([1, 2, 3, 4]) == []\nassert op_trimends_gt5([]) == []\nassert op_trimends_gt5([-2, -1, 0, 1, 2]) == []\nassert op_trimends_gt5([5, 5, 5]) == []\nassert op_trimends_gt5([3, 1, 2]) == []\nassert op_trimends_gt5([10]) == []\nassert op_trimends_gt5([2, 4, 6]) == []\nassert op_trimends_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortlen_longest", "entry_point": "op_sortlen_longest", "primitives": ["sortlen", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then return the longest string (empty if none).", "solution": "def op_sortlen_longest(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return max(r, key=len) if r else ''", "tests": "assert op_sortlen_longest(['Hello', 'world']) == 'Hello'\nassert op_sortlen_longest([]) == ''\nassert op_sortlen_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_sortlen_longest(['one', 'one', 'Two']) == 'one'\nassert op_sortlen_longest(['x']) == 'x'\nassert op_sortlen_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_first3_sortabs", "entry_point": "op_first3_sortabs", "primitives": ["first3", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value.", "solution": "def op_first3_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs([]) == []\nassert op_first3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs([10]) == [10]\nassert op_first3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_len", "entry_point": "op_pos_len", "primitives": ["pos", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return how many remain.", "solution": "def op_pos_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return len(r)", "tests": "assert op_pos_len([1, 2, 3, 4]) == 4\nassert op_pos_len([]) == 0\nassert op_pos_len([-2, -1, 0, 1, 2]) == 2\nassert op_pos_len([5, 5, 5]) == 3\nassert op_pos_len([3, 1, 2]) == 3\nassert op_pos_len([10]) == 1\nassert op_pos_len([2, 4, 6]) == 3\nassert op_pos_len([-7, 12, -7]) == 1"}
{"id": "op_sortd_dropzeros", "entry_point": "op_sortd_dropzeros", "primitives": ["sortd", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros.", "solution": "def op_sortd_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortd_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_dropzeros([]) == []\nassert op_sortd_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_sortd_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropzeros([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropzeros([10]) == [10]\nassert op_sortd_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropzeros([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_firstchar_nonempty", "entry_point": "op_firstchar_nonempty", "primitives": ["firstchar", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then drop empty strings.", "solution": "def op_firstchar_nonempty(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_firstchar_nonempty(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_nonempty([]) == []\nassert op_firstchar_nonempty(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_nonempty(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_firstchar_nonempty(['x']) == ['x']\nassert op_firstchar_nonempty(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_last3_neg", "entry_point": "op_last3_neg", "primitives": ["last3", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers.", "solution": "def op_last3_neg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_last3_neg([1, 2, 3, 4]) == []\nassert op_last3_neg([]) == []\nassert op_last3_neg([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg([5, 5, 5]) == []\nassert op_last3_neg([3, 1, 2]) == []\nassert op_last3_neg([10]) == []\nassert op_last3_neg([2, 4, 6]) == []\nassert op_last3_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_oremptyzero", "entry_point": "op_clamp10_oremptyzero", "primitives": ["clamp10", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then if empty, use a single zero.", "solution": "def op_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_oremptyzero([]) == [0]\nassert op_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_oremptyzero([10]) == [10]\nassert op_clamp10_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_oremptyzero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_dropwhileneg_div3", "entry_point": "op_dropwhileneg_div3", "primitives": ["dropwhileneg", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three.", "solution": "def op_dropwhileneg_div3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropwhileneg_div3([1, 2, 3, 4]) == [3]\nassert op_dropwhileneg_div3([]) == []\nassert op_dropwhileneg_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_div3([5, 5, 5]) == []\nassert op_dropwhileneg_div3([3, 1, 2]) == [3]\nassert op_dropwhileneg_div3([10]) == []\nassert op_dropwhileneg_div3([2, 4, 6]) == [6]\nassert op_dropwhileneg_div3([-7, 12, -7]) == [12]"}
{"id": "op_inc_issorted", "entry_point": "op_inc_issorted", "primitives": ["inc", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return whether the list is sorted ascending.", "solution": "def op_inc_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_inc_issorted([1, 2, 3, 4]) == True\nassert op_inc_issorted([]) == True\nassert op_inc_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_issorted([5, 5, 5]) == True\nassert op_inc_issorted([3, 1, 2]) == False\nassert op_inc_issorted([10]) == True\nassert op_inc_issorted([2, 4, 6]) == True\nassert op_inc_issorted([-7, 12, -7]) == False"}
{"id": "op_double_clamp10", "entry_point": "op_double_clamp10", "primitives": ["double", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10.", "solution": "def op_double_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_clamp10([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_clamp10([]) == []\nassert op_double_clamp10([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_double_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_double_clamp10([10]) == [10]\nassert op_double_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_double_clamp10([-7, 12, -7]) == [-14, 10, -14]"}
{"id": "op_trimends_sorta", "entry_point": "op_trimends_sorta", "primitives": ["trimends", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending.", "solution": "def op_trimends_sorta(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    return r", "tests": "assert op_trimends_sorta([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_sorta([]) == []\nassert op_trimends_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_sorta([5, 5, 5]) == [5]\nassert op_trimends_sorta([3, 1, 2]) == [1]\nassert op_trimends_sorta([10]) == []\nassert op_trimends_sorta([2, 4, 6]) == [4]\nassert op_trimends_sorta([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_inc", "entry_point": "op_clamp10_inc", "primitives": ["clamp10", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each.", "solution": "def op_clamp10_inc(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_clamp10_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_clamp10_inc([]) == []\nassert op_clamp10_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_clamp10_inc([5, 5, 5]) == [6, 6, 6]\nassert op_clamp10_inc([3, 1, 2]) == [4, 2, 3]\nassert op_clamp10_inc([10]) == [11]\nassert op_clamp10_inc([2, 4, 6]) == [3, 5, 7]\nassert op_clamp10_inc([-7, 12, -7]) == [-6, 11, -6]"}
{"id": "op_negate_evens", "entry_point": "op_negate_evens", "primitives": ["negate", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers.", "solution": "def op_negate_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_evens([]) == []\nassert op_negate_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_evens([5, 5, 5]) == []\nassert op_negate_evens([3, 1, 2]) == [-2]\nassert op_negate_evens([10]) == [-10]\nassert op_negate_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_evens([-7, 12, -7]) == [-12]"}
{"id": "op_double_anyeven", "entry_point": "op_double_anyeven", "primitives": ["double", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return whether any value is even.", "solution": "def op_double_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_anyeven([1, 2, 3, 4]) == True\nassert op_double_anyeven([]) == False\nassert op_double_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_double_anyeven([5, 5, 5]) == True\nassert op_double_anyeven([3, 1, 2]) == True\nassert op_double_anyeven([10]) == True\nassert op_double_anyeven([2, 4, 6]) == True\nassert op_double_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_neg", "entry_point": "op_evens_neg", "primitives": ["evens", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers.", "solution": "def op_evens_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_neg([1, 2, 3, 4]) == []\nassert op_evens_neg([]) == []\nassert op_evens_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_neg([5, 5, 5]) == []\nassert op_evens_neg([3, 1, 2]) == []\nassert op_evens_neg([10]) == []\nassert op_evens_neg([2, 4, 6]) == []\nassert op_evens_neg([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_issorted", "entry_point": "op_dropwhileneg_issorted", "primitives": ["dropwhileneg", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_issorted([]) == True\nassert op_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_issorted([10]) == True\nassert op_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_issorted([-7, 12, -7]) == False"}
{"id": "op_trimends_len", "entry_point": "op_trimends_len", "primitives": ["trimends", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return how many remain.", "solution": "def op_trimends_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_trimends_len([1, 2, 3, 4]) == 2\nassert op_trimends_len([]) == 0\nassert op_trimends_len([-2, -1, 0, 1, 2]) == 3\nassert op_trimends_len([5, 5, 5]) == 1\nassert op_trimends_len([3, 1, 2]) == 1\nassert op_trimends_len([10]) == 0\nassert op_trimends_len([2, 4, 6]) == 1\nassert op_trimends_len([-7, 12, -7]) == 1"}
{"id": "op_sortd_neg", "entry_point": "op_sortd_neg", "primitives": ["sortd", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers.", "solution": "def op_sortd_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_neg([1, 2, 3, 4]) == []\nassert op_sortd_neg([]) == []\nassert op_sortd_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortd_neg([5, 5, 5]) == []\nassert op_sortd_neg([3, 1, 2]) == []\nassert op_sortd_neg([10]) == []\nassert op_sortd_neg([2, 4, 6]) == []\nassert op_sortd_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_prefixup_lower", "entry_point": "op_prefixup_lower", "primitives": ["prefixup", "lower"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then lowercase each string.", "solution": "def op_prefixup_lower(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_prefixup_lower(['Hello', 'world']) == ['#hello', '#world']\nassert op_prefixup_lower([]) == []\nassert op_prefixup_lower(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#bc', '#bc']\nassert op_prefixup_lower(['one', 'one', 'Two']) == ['#one', '#one', '#two']\nassert op_prefixup_lower(['x']) == ['#x']\nassert op_prefixup_lower(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_ages_sum", "entry_point": "op_ages_sum", "primitives": ["ages", "sum"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return their sum.", "solution": "def op_ages_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return sum(r)", "tests": "assert op_ages_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 48\nassert op_ages_sum([]) == 0\nassert op_ages_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 100\nassert op_ages_sum([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_first3_square", "entry_point": "op_first3_square", "primitives": ["first3", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each.", "solution": "def op_first3_square(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_first3_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_square([]) == []\nassert op_first3_square([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_first3_square([5, 5, 5]) == [25, 25, 25]\nassert op_first3_square([3, 1, 2]) == [9, 1, 4]\nassert op_first3_square([10]) == [100]\nassert op_first3_square([2, 4, 6]) == [4, 16, 36]\nassert op_first3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_div3_len", "entry_point": "op_div3_len", "primitives": ["div3", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return how many remain.", "solution": "def op_div3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_div3_len([1, 2, 3, 4]) == 1\nassert op_div3_len([]) == 0\nassert op_div3_len([-2, -1, 0, 1, 2]) == 1\nassert op_div3_len([5, 5, 5]) == 0\nassert op_div3_len([3, 1, 2]) == 1\nassert op_div3_len([10]) == 0\nassert op_div3_len([2, 4, 6]) == 1\nassert op_div3_len([-7, 12, -7]) == 1"}
{"id": "op_dec_negate", "entry_point": "op_dec_negate", "primitives": ["dec", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each.", "solution": "def op_dec_negate(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dec_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_dec_negate([]) == []\nassert op_dec_negate([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_dec_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_dec_negate([10]) == [-9]\nassert op_dec_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_negate([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_uniqs_prefixup", "entry_point": "op_uniqs_prefixup", "primitives": ["uniqs", "prefixup"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then prefix each with a hash.", "solution": "def op_uniqs_prefixup(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_uniqs_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_uniqs_prefixup([]) == []\nassert op_uniqs_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#BC', '#bc']\nassert op_uniqs_prefixup(['one', 'one', 'Two']) == ['#one', '#Two']\nassert op_uniqs_prefixup(['x']) == ['#x']\nassert op_uniqs_prefixup(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_first3_prod", "entry_point": "op_first3_prod", "primitives": ["first3", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return their product.", "solution": "def op_first3_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_first3_prod([1, 2, 3, 4]) == 6\nassert op_first3_prod([]) == 1\nassert op_first3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_first3_prod([5, 5, 5]) == 125\nassert op_first3_prod([3, 1, 2]) == 6\nassert op_first3_prod([10]) == 10\nassert op_first3_prod([2, 4, 6]) == 48\nassert op_first3_prod([-7, 12, -7]) == 588"}
{"id": "op_sortd_issorted", "entry_point": "op_sortd_issorted", "primitives": ["sortd", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return whether the list is sorted ascending.", "solution": "def op_sortd_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_sortd_issorted([1, 2, 3, 4]) == False\nassert op_sortd_issorted([]) == True\nassert op_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortd_issorted([5, 5, 5]) == True\nassert op_sortd_issorted([3, 1, 2]) == False\nassert op_sortd_issorted([10]) == True\nassert op_sortd_issorted([2, 4, 6]) == False\nassert op_sortd_issorted([-7, 12, -7]) == False"}
{"id": "op_clamp10_first3", "entry_point": "op_clamp10_first3", "primitives": ["clamp10", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the first three.", "solution": "def op_clamp10_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_first3([]) == []\nassert op_clamp10_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_clamp10_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_first3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_first3([10]) == [10]\nassert op_clamp10_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_first3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_inc_anyeven", "entry_point": "op_inc_anyeven", "primitives": ["inc", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return whether any value is even.", "solution": "def op_inc_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_anyeven([1, 2, 3, 4]) == True\nassert op_inc_anyeven([]) == False\nassert op_inc_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_anyeven([5, 5, 5]) == True\nassert op_inc_anyeven([3, 1, 2]) == True\nassert op_inc_anyeven([10]) == False\nassert op_inc_anyeven([2, 4, 6]) == False\nassert op_inc_anyeven([-7, 12, -7]) == True"}
{"id": "op_gt5_odds", "entry_point": "op_gt5_odds", "primitives": ["gt5", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the odd numbers.", "solution": "def op_gt5_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_odds([1, 2, 3, 4]) == []\nassert op_gt5_odds([]) == []\nassert op_gt5_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_odds([5, 5, 5]) == []\nassert op_gt5_odds([3, 1, 2]) == []\nassert op_gt5_odds([10]) == []\nassert op_gt5_odds([2, 4, 6]) == []\nassert op_gt5_odds([-7, 12, -7]) == []"}
{"id": "op_pos_dropwhileneg", "entry_point": "op_pos_dropwhileneg", "primitives": ["pos", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values.", "solution": "def op_pos_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_pos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_dropwhileneg([]) == []\nassert op_pos_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_pos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_pos_dropwhileneg([10]) == [10]\nassert op_pos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_double_rev", "entry_point": "op_double_rev", "primitives": ["double", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order.", "solution": "def op_double_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_rev([]) == []\nassert op_double_rev([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_rev([5, 5, 5]) == [10, 10, 10]\nassert op_double_rev([3, 1, 2]) == [4, 2, 6]\nassert op_double_rev([10]) == [20]\nassert op_double_rev([2, 4, 6]) == [12, 8, 4]\nassert op_double_rev([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_rev_last3", "entry_point": "op_rev_last3", "primitives": ["rev", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three.", "solution": "def op_rev_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_rev_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_last3([]) == []\nassert op_rev_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_rev_last3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_last3([10]) == [10]\nassert op_rev_last3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_square_sum", "entry_point": "op_square_sum", "primitives": ["square", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return their sum.", "solution": "def op_square_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_square_sum([1, 2, 3, 4]) == 30\nassert op_square_sum([]) == 0\nassert op_square_sum([-2, -1, 0, 1, 2]) == 10\nassert op_square_sum([5, 5, 5]) == 75\nassert op_square_sum([3, 1, 2]) == 14\nassert op_square_sum([10]) == 100\nassert op_square_sum([2, 4, 6]) == 56\nassert op_square_sum([-7, 12, -7]) == 242"}
{"id": "op_sortd_dec", "entry_point": "op_sortd_dec", "primitives": ["sortd", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each.", "solution": "def op_sortd_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortd_dec([]) == []\nassert op_sortd_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_sortd_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_dec([10]) == [9]\nassert op_sortd_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_dec([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_dec_counteven", "entry_point": "op_dec_counteven", "primitives": ["dec", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return how many values are even.", "solution": "def op_dec_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_counteven([1, 2, 3, 4]) == 2\nassert op_dec_counteven([]) == 0\nassert op_dec_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dec_counteven([5, 5, 5]) == 3\nassert op_dec_counteven([3, 1, 2]) == 2\nassert op_dec_counteven([10]) == 0\nassert op_dec_counteven([2, 4, 6]) == 0\nassert op_dec_counteven([-7, 12, -7]) == 2"}
{"id": "op_dec_uniq", "entry_point": "op_dec_uniq", "primitives": ["dec", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence.", "solution": "def op_dec_uniq(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dec_uniq([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_uniq([]) == []\nassert op_dec_uniq([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_uniq([5, 5, 5]) == [4]\nassert op_dec_uniq([3, 1, 2]) == [2, 0, 1]\nassert op_dec_uniq([10]) == [9]\nassert op_dec_uniq([2, 4, 6]) == [1, 3, 5]\nassert op_dec_uniq([-7, 12, -7]) == [-8, 11]"}
{"id": "op_sorta_div3", "entry_point": "op_sorta_div3", "primitives": ["sorta", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep multiples of three.", "solution": "def op_sorta_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_div3([]) == []\nassert op_sorta_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sorta_div3([5, 5, 5]) == []\nassert op_sorta_div3([3, 1, 2]) == [3]\nassert op_sorta_div3([10]) == []\nassert op_sorta_div3([2, 4, 6]) == [6]\nassert op_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_negate_odds", "entry_point": "op_negate_odds", "primitives": ["negate", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers.", "solution": "def op_negate_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_odds([]) == []\nassert op_negate_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_negate_odds([10]) == []\nassert op_negate_odds([2, 4, 6]) == []\nassert op_negate_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_evens_sortd", "entry_point": "op_evens_sortd", "primitives": ["evens", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending.", "solution": "def op_evens_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_evens_sortd([]) == []\nassert op_evens_sortd([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_sortd([5, 5, 5]) == []\nassert op_evens_sortd([3, 1, 2]) == [2]\nassert op_evens_sortd([10]) == [10]\nassert op_evens_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_evens_sortd([-7, 12, -7]) == [12]"}
{"id": "op_names_nonempty", "entry_point": "op_names_nonempty", "primitives": ["names", "nonempty"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop empty strings.", "solution": "def op_names_nonempty(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_names_nonempty([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_nonempty([]) == []\nassert op_names_nonempty([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_nonempty([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_dec_gt5", "entry_point": "op_dec_gt5", "primitives": ["dec", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five.", "solution": "def op_dec_gt5(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dec_gt5([1, 2, 3, 4]) == []\nassert op_dec_gt5([]) == []\nassert op_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dec_gt5([5, 5, 5]) == []\nassert op_dec_gt5([3, 1, 2]) == []\nassert op_dec_gt5([10]) == [9]\nassert op_dec_gt5([2, 4, 6]) == []\nassert op_dec_gt5([-7, 12, -7]) == [11]"}
{"id": "op_padto3_sortd", "entry_point": "op_padto3_sortd", "primitives": ["padto3", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending.", "solution": "def op_padto3_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_sortd([]) == [0, 0, 0]\nassert op_padto3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_padto3_sortd([10]) == [10, 0, 0]\nassert op_padto3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_trimends_negate", "entry_point": "op_trimends_negate", "primitives": ["trimends", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each.", "solution": "def op_trimends_negate(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_trimends_negate([1, 2, 3, 4]) == [-2, -3]\nassert op_trimends_negate([]) == []\nassert op_trimends_negate([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_negate([5, 5, 5]) == [-5]\nassert op_trimends_negate([3, 1, 2]) == [-1]\nassert op_trimends_negate([10]) == []\nassert op_trimends_negate([2, 4, 6]) == [-4]\nassert op_trimends_negate([-7, 12, -7]) == [-12]"}
{"id": "op_dropzeros_firsteven", "entry_point": "op_dropzeros_firsteven", "primitives": ["dropzeros", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return the first even value (0 if none).", "solution": "def op_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_firsteven([]) == 0\nassert op_dropzeros_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_firsteven([10]) == 10\nassert op_dropzeros_firsteven([2, 4, 6]) == 2\nassert op_dropzeros_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_inc", "entry_point": "op_evens_inc", "primitives": ["evens", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each.", "solution": "def op_evens_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_evens_inc([1, 2, 3, 4]) == [3, 5]\nassert op_evens_inc([]) == []\nassert op_evens_inc([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_evens_inc([5, 5, 5]) == []\nassert op_evens_inc([3, 1, 2]) == [3]\nassert op_evens_inc([10]) == [11]\nassert op_evens_inc([2, 4, 6]) == [3, 5, 7]\nassert op_evens_inc([-7, 12, -7]) == [13]"}
{"id": "op_padto3_inc", "entry_point": "op_padto3_inc", "primitives": ["padto3", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each.", "solution": "def op_padto3_inc(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_padto3_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_padto3_inc([]) == [1, 1, 1]\nassert op_padto3_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_padto3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_padto3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_padto3_inc([10]) == [11, 1, 1]\nassert op_padto3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_padto3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropwhileneg_beforezero", "entry_point": "op_dropwhileneg_beforezero", "primitives": ["dropwhileneg", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero.", "solution": "def op_dropwhileneg_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_beforezero([]) == []\nassert op_dropwhileneg_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_beforezero([10]) == [10]\nassert op_dropwhileneg_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_oremptyzero_anyeven", "entry_point": "op_oremptyzero_anyeven", "primitives": ["oremptyzero", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return whether any value is even.", "solution": "def op_oremptyzero_anyeven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_oremptyzero_anyeven([1, 2, 3, 4]) == True\nassert op_oremptyzero_anyeven([]) == True\nassert op_oremptyzero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_anyeven([5, 5, 5]) == False\nassert op_oremptyzero_anyeven([3, 1, 2]) == True\nassert op_oremptyzero_anyeven([10]) == True\nassert op_oremptyzero_anyeven([2, 4, 6]) == True\nassert op_oremptyzero_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortage_countrl", "entry_point": "op_sortage_countrl", "primitives": ["sortage", "countrl"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then return how many records remain.", "solution": "def op_sortage_countrl(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    return len(r)", "tests": "assert op_sortage_countrl([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_sortage_countrl([]) == 0\nassert op_sortage_countrl([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_sortage_countrl([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_ages_allpos", "entry_point": "op_ages_allpos", "primitives": ["ages", "allpos"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return whether all values are positive.", "solution": "def op_ages_allpos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return all(x > 0 for x in r)", "tests": "assert op_ages_allpos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_allpos([]) == True\nassert op_ages_allpos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_allpos([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_neg_min", "entry_point": "op_neg_min", "primitives": ["neg", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_neg_min(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_neg_min([1, 2, 3, 4]) == 0\nassert op_neg_min([]) == 0\nassert op_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_neg_min([5, 5, 5]) == 0\nassert op_neg_min([3, 1, 2]) == 0\nassert op_neg_min([10]) == 0\nassert op_neg_min([2, 4, 6]) == 0\nassert op_neg_min([-7, 12, -7]) == -7"}
{"id": "op_add10_firsteven", "entry_point": "op_add10_firsteven", "primitives": ["add10", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return the first even value (0 if none).", "solution": "def op_add10_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_add10_firsteven([]) == 0\nassert op_add10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_add10_firsteven([5, 5, 5]) == 0\nassert op_add10_firsteven([3, 1, 2]) == 12\nassert op_add10_firsteven([10]) == 20\nassert op_add10_firsteven([2, 4, 6]) == 12\nassert op_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_pos_sortd", "entry_point": "op_pos_sortd", "primitives": ["pos", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending.", "solution": "def op_pos_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_pos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_sortd([]) == []\nassert op_pos_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_pos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_pos_sortd([10]) == [10]\nassert op_pos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_pos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_ages_first3", "entry_point": "op_ages_first3", "primitives": ["ages", "first3"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three.", "solution": "def op_ages_first3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    return r", "tests": "assert op_ages_first3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_first3([]) == []\nassert op_ages_first3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_first3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropwhileneg_sum", "entry_point": "op_dropwhileneg_sum", "primitives": ["dropwhileneg", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return their sum.", "solution": "def op_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_dropwhileneg_sum([]) == 0\nassert op_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 3\nassert op_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_dropwhileneg_sum([10]) == 10\nassert op_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_dropwhileneg_sum([-7, 12, -7]) == 5"}
{"id": "op_absval_negate", "entry_point": "op_absval_negate", "primitives": ["absval", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each.", "solution": "def op_absval_negate(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_absval_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_absval_negate([]) == []\nassert op_absval_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, -1, -2]\nassert op_absval_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_absval_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_absval_negate([10]) == [-10]\nassert op_absval_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_absval_negate([-7, 12, -7]) == [-7, -12, -7]"}
{"id": "op_gt5_issorted", "entry_point": "op_gt5_issorted", "primitives": ["gt5", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_gt5_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_gt5_issorted([1, 2, 3, 4]) == True\nassert op_gt5_issorted([]) == True\nassert op_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_issorted([5, 5, 5]) == True\nassert op_gt5_issorted([3, 1, 2]) == True\nassert op_gt5_issorted([10]) == True\nassert op_gt5_issorted([2, 4, 6]) == True\nassert op_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_add10_absval", "entry_point": "op_add10_absval", "primitives": ["add10", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each.", "solution": "def op_add10_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_absval([]) == []\nassert op_add10_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_absval([3, 1, 2]) == [13, 11, 12]\nassert op_add10_absval([10]) == [20]\nassert op_add10_absval([2, 4, 6]) == [12, 14, 16]\nassert op_add10_absval([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_dropzeros_evens", "entry_point": "op_dropzeros_evens", "primitives": ["dropzeros", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers.", "solution": "def op_dropzeros_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropzeros_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropzeros_evens([]) == []\nassert op_dropzeros_evens([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_dropzeros_evens([5, 5, 5]) == []\nassert op_dropzeros_evens([3, 1, 2]) == [2]\nassert op_dropzeros_evens([10]) == [10]\nassert op_dropzeros_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_evens([-7, 12, -7]) == [12]"}
{"id": "op_odds_max", "entry_point": "op_odds_max", "primitives": ["odds", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return the maximum (0 if empty).", "solution": "def op_odds_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return max(r) if r else 0", "tests": "assert op_odds_max([1, 2, 3, 4]) == 3\nassert op_odds_max([]) == 0\nassert op_odds_max([-2, -1, 0, 1, 2]) == 1\nassert op_odds_max([5, 5, 5]) == 5\nassert op_odds_max([3, 1, 2]) == 3\nassert op_odds_max([10]) == 0\nassert op_odds_max([2, 4, 6]) == 0\nassert op_odds_max([-7, 12, -7]) == -7"}
{"id": "op_negate_sum", "entry_point": "op_negate_sum", "primitives": ["negate", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return their sum.", "solution": "def op_negate_sum(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_negate_sum([1, 2, 3, 4]) == -10\nassert op_negate_sum([]) == 0\nassert op_negate_sum([-2, -1, 0, 1, 2]) == 0\nassert op_negate_sum([5, 5, 5]) == -15\nassert op_negate_sum([3, 1, 2]) == -6\nassert op_negate_sum([10]) == -10\nassert op_negate_sum([2, 4, 6]) == -12\nassert op_negate_sum([-7, 12, -7]) == 2"}
{"id": "op_ages_pos", "entry_point": "op_ages_pos", "primitives": ["ages", "pos"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers.", "solution": "def op_ages_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_pos([]) == []\nassert op_ages_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_gt5_rev", "entry_point": "op_gt5_rev", "primitives": ["gt5", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order.", "solution": "def op_gt5_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    return r", "tests": "assert op_gt5_rev([1, 2, 3, 4]) == []\nassert op_gt5_rev([]) == []\nassert op_gt5_rev([-2, -1, 0, 1, 2]) == []\nassert op_gt5_rev([5, 5, 5]) == []\nassert op_gt5_rev([3, 1, 2]) == []\nassert op_gt5_rev([10]) == [10]\nassert op_gt5_rev([2, 4, 6]) == [6]\nassert op_gt5_rev([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_dropwhileneg", "entry_point": "op_dropzeros_dropwhileneg", "primitives": ["dropzeros", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values.", "solution": "def op_dropzeros_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_dropwhileneg([]) == []\nassert op_dropzeros_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_dropwhileneg([10]) == [10]\nassert op_dropzeros_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_gt5_square", "entry_point": "op_gt5_square", "primitives": ["gt5", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then square each.", "solution": "def op_gt5_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_square([1, 2, 3, 4]) == []\nassert op_gt5_square([]) == []\nassert op_gt5_square([-2, -1, 0, 1, 2]) == []\nassert op_gt5_square([5, 5, 5]) == []\nassert op_gt5_square([3, 1, 2]) == []\nassert op_gt5_square([10]) == [100]\nassert op_gt5_square([2, 4, 6]) == [36]\nassert op_gt5_square([-7, 12, -7]) == [144]"}
{"id": "op_clamp10_trimends", "entry_point": "op_clamp10_trimends", "primitives": ["clamp10", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements.", "solution": "def op_clamp10_trimends(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_clamp10_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_clamp10_trimends([]) == []\nassert op_clamp10_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_clamp10_trimends([5, 5, 5]) == [5]\nassert op_clamp10_trimends([3, 1, 2]) == [1]\nassert op_clamp10_trimends([10]) == []\nassert op_clamp10_trimends([2, 4, 6]) == [4]\nassert op_clamp10_trimends([-7, 12, -7]) == [10]"}
{"id": "op_dropzeros_add10", "entry_point": "op_dropzeros_add10", "primitives": ["dropzeros", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each.", "solution": "def op_dropzeros_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropzeros_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropzeros_add10([]) == []\nassert op_dropzeros_add10([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_dropzeros_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropzeros_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropzeros_add10([10]) == [20]\nassert op_dropzeros_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_padto3_oremptyzero", "entry_point": "op_padto3_oremptyzero", "primitives": ["padto3", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_padto3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_oremptyzero([10]) == [10, 0, 0]\nassert op_padto3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_gt5_first3", "entry_point": "op_gt5_first3", "primitives": ["gt5", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the first three.", "solution": "def op_gt5_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_first3([1, 2, 3, 4]) == []\nassert op_gt5_first3([]) == []\nassert op_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_first3([5, 5, 5]) == []\nassert op_gt5_first3([3, 1, 2]) == []\nassert op_gt5_first3([10]) == [10]\nassert op_gt5_first3([2, 4, 6]) == [6]\nassert op_gt5_first3([-7, 12, -7]) == [12]"}
{"id": "op_double_add10", "entry_point": "op_double_add10", "primitives": ["double", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each.", "solution": "def op_double_add10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_double_add10([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_add10([]) == []\nassert op_double_add10([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_double_add10([5, 5, 5]) == [20, 20, 20]\nassert op_double_add10([3, 1, 2]) == [16, 12, 14]\nassert op_double_add10([10]) == [30]\nassert op_double_add10([2, 4, 6]) == [14, 18, 22]\nassert op_double_add10([-7, 12, -7]) == [-4, 34, -4]"}
{"id": "op_beforezero_min", "entry_point": "op_beforezero_min", "primitives": ["beforezero", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return the minimum (0 if empty).", "solution": "def op_beforezero_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return min(r) if r else 0", "tests": "assert op_beforezero_min([1, 2, 3, 4]) == 1\nassert op_beforezero_min([]) == 0\nassert op_beforezero_min([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_min([5, 5, 5]) == 5\nassert op_beforezero_min([3, 1, 2]) == 1\nassert op_beforezero_min([10]) == 10\nassert op_beforezero_min([2, 4, 6]) == 2\nassert op_beforezero_min([-7, 12, -7]) == -7"}
{"id": "op_add10_clamp10", "entry_point": "op_add10_clamp10", "primitives": ["add10", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10.", "solution": "def op_add10_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_clamp10([]) == []\nassert op_add10_clamp10([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_add10_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_add10_clamp10([10]) == [10]\nassert op_add10_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_add10_clamp10([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_uniq_takewhilepos", "entry_point": "op_uniq_takewhilepos", "primitives": ["uniq", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive.", "solution": "def op_uniq_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_takewhilepos([]) == []\nassert op_uniq_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos([5, 5, 5]) == [5]\nassert op_uniq_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_takewhilepos([10]) == [10]\nassert op_uniq_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_gt5_min", "entry_point": "op_gt5_min", "primitives": ["gt5", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_gt5_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_gt5_min([1, 2, 3, 4]) == 0\nassert op_gt5_min([]) == 0\nassert op_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_min([5, 5, 5]) == 0\nassert op_gt5_min([3, 1, 2]) == 0\nassert op_gt5_min([10]) == 10\nassert op_gt5_min([2, 4, 6]) == 6\nassert op_gt5_min([-7, 12, -7]) == 12"}
{"id": "op_inc_odds", "entry_point": "op_inc_odds", "primitives": ["inc", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers.", "solution": "def op_inc_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_odds([]) == []\nassert op_inc_odds([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_inc_odds([5, 5, 5]) == []\nassert op_inc_odds([3, 1, 2]) == [3]\nassert op_inc_odds([10]) == [11]\nassert op_inc_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_last3_square", "entry_point": "op_last3_square", "primitives": ["last3", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each.", "solution": "def op_last3_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_square([]) == []\nassert op_last3_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_last3_square([5, 5, 5]) == [25, 25, 25]\nassert op_last3_square([3, 1, 2]) == [9, 1, 4]\nassert op_last3_square([10]) == [100]\nassert op_last3_square([2, 4, 6]) == [4, 16, 36]\nassert op_last3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_lower_joinc", "entry_point": "op_lower_joinc", "primitives": ["lower", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then join them with commas.", "solution": "def op_lower_joinc(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return ','.join(r)", "tests": "assert op_lower_joinc(['Hello', 'world']) == 'hello,world'\nassert op_lower_joinc([]) == ''\nassert op_lower_joinc(['  a ', '', 'BC', 'bc']) == '  a ,,bc,bc'\nassert op_lower_joinc(['one', 'one', 'Two']) == 'one,one,two'\nassert op_lower_joinc(['x']) == 'x'\nassert op_lower_joinc(['abc', 'de', '']) == 'abc,de,'"}
{"id": "op_negate_prod", "entry_point": "op_negate_prod", "primitives": ["negate", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return their product.", "solution": "def op_negate_prod(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_negate_prod([1, 2, 3, 4]) == 24\nassert op_negate_prod([]) == 1\nassert op_negate_prod([-2, -1, 0, 1, 2]) == 0\nassert op_negate_prod([5, 5, 5]) == -125\nassert op_negate_prod([3, 1, 2]) == -6\nassert op_negate_prod([10]) == -10\nassert op_negate_prod([2, 4, 6]) == -48\nassert op_negate_prod([-7, 12, -7]) == -588"}
{"id": "op_pos_odds", "entry_point": "op_pos_odds", "primitives": ["pos", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers.", "solution": "def op_pos_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_pos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_pos_odds([]) == []\nassert op_pos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_pos_odds([3, 1, 2]) == [3, 1]\nassert op_pos_odds([10]) == []\nassert op_pos_odds([2, 4, 6]) == []\nassert op_pos_odds([-7, 12, -7]) == []"}
{"id": "op_sorta_sortabs", "entry_point": "op_sorta_sortabs", "primitives": ["sorta", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value.", "solution": "def op_sorta_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_sortabs([]) == []\nassert op_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sorta_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_sortabs([10]) == [10]\nassert op_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_prefixup_upper", "entry_point": "op_prefixup_upper", "primitives": ["prefixup", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then uppercase each string.", "solution": "def op_prefixup_upper(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_prefixup_upper(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_prefixup_upper([]) == []\nassert op_prefixup_upper(['  a ', '', 'BC', 'bc']) == ['#  A ', '#', '#BC', '#BC']\nassert op_prefixup_upper(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_prefixup_upper(['x']) == ['#X']\nassert op_prefixup_upper(['abc', 'de', '']) == ['#ABC', '#DE', '#']"}
{"id": "op_ages_anyeven", "entry_point": "op_ages_anyeven", "primitives": ["ages", "anyeven"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return whether any value is even.", "solution": "def op_ages_anyeven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_ages_anyeven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_anyeven([]) == False\nassert op_ages_anyeven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_anyeven([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_div3_sortd", "entry_point": "op_div3_sortd", "primitives": ["div3", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending.", "solution": "def op_div3_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_div3_sortd([1, 2, 3, 4]) == [3]\nassert op_div3_sortd([]) == []\nassert op_div3_sortd([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_sortd([5, 5, 5]) == []\nassert op_div3_sortd([3, 1, 2]) == [3]\nassert op_div3_sortd([10]) == []\nassert op_div3_sortd([2, 4, 6]) == [6]\nassert op_div3_sortd([-7, 12, -7]) == [12]"}
{"id": "op_sortd_anyeven", "entry_point": "op_sortd_anyeven", "primitives": ["sortd", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return whether any value is even.", "solution": "def op_sortd_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortd_anyeven([1, 2, 3, 4]) == True\nassert op_sortd_anyeven([]) == False\nassert op_sortd_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortd_anyeven([5, 5, 5]) == False\nassert op_sortd_anyeven([3, 1, 2]) == True\nassert op_sortd_anyeven([10]) == True\nassert op_sortd_anyeven([2, 4, 6]) == True\nassert op_sortd_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_alldistinct", "entry_point": "op_trimends_alldistinct", "primitives": ["trimends", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return whether all values are distinct.", "solution": "def op_trimends_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_alldistinct([]) == True\nassert op_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_alldistinct([5, 5, 5]) == True\nassert op_trimends_alldistinct([3, 1, 2]) == True\nassert op_trimends_alldistinct([10]) == True\nassert op_trimends_alldistinct([2, 4, 6]) == True\nassert op_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_first3_absval", "entry_point": "op_first3_absval", "primitives": ["first3", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each.", "solution": "def op_first3_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_absval([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_absval([]) == []\nassert op_first3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_first3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_first3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_first3_absval([10]) == [10]\nassert op_first3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_first3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_gt5_firsteven", "entry_point": "op_gt5_firsteven", "primitives": ["gt5", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return the first even value (0 if none).", "solution": "def op_gt5_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_firsteven([]) == 0\nassert op_gt5_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_firsteven([5, 5, 5]) == 0\nassert op_gt5_firsteven([3, 1, 2]) == 0\nassert op_gt5_firsteven([10]) == 10\nassert op_gt5_firsteven([2, 4, 6]) == 6\nassert op_gt5_firsteven([-7, 12, -7]) == 12"}
{"id": "op_beforezero_alldistinct", "entry_point": "op_beforezero_alldistinct", "primitives": ["beforezero", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return whether all values are distinct.", "solution": "def op_beforezero_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_alldistinct([]) == True\nassert op_beforezero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_alldistinct([5, 5, 5]) == False\nassert op_beforezero_alldistinct([3, 1, 2]) == True\nassert op_beforezero_alldistinct([10]) == True\nassert op_beforezero_alldistinct([2, 4, 6]) == True\nassert op_beforezero_alldistinct([-7, 12, -7]) == False"}
{"id": "op_rev_firsteven", "entry_point": "op_rev_firsteven", "primitives": ["rev", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return the first even value (0 if none).", "solution": "def op_rev_firsteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_rev_firsteven([1, 2, 3, 4]) == 4\nassert op_rev_firsteven([]) == 0\nassert op_rev_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_rev_firsteven([5, 5, 5]) == 0\nassert op_rev_firsteven([3, 1, 2]) == 2\nassert op_rev_firsteven([10]) == 10\nassert op_rev_firsteven([2, 4, 6]) == 6\nassert op_rev_firsteven([-7, 12, -7]) == 12"}
{"id": "op_nonempty_uniqs", "entry_point": "op_nonempty_uniqs", "primitives": ["nonempty", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop duplicate strings keeping the first.", "solution": "def op_nonempty_uniqs(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_nonempty_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_uniqs([]) == []\nassert op_nonempty_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ', 'BC', 'bc']\nassert op_nonempty_uniqs(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_nonempty_uniqs(['x']) == ['x']\nassert op_nonempty_uniqs(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_div3_square", "entry_point": "op_div3_square", "primitives": ["div3", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each.", "solution": "def op_div3_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_div3_square([1, 2, 3, 4]) == [9]\nassert op_div3_square([]) == []\nassert op_div3_square([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_square([5, 5, 5]) == []\nassert op_div3_square([3, 1, 2]) == [9]\nassert op_div3_square([10]) == []\nassert op_div3_square([2, 4, 6]) == [36]\nassert op_div3_square([-7, 12, -7]) == [144]"}
{"id": "op_neg_firsteven", "entry_point": "op_neg_firsteven", "primitives": ["neg", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_neg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_firsteven([]) == 0\nassert op_neg_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_neg_firsteven([5, 5, 5]) == 0\nassert op_neg_firsteven([3, 1, 2]) == 0\nassert op_neg_firsteven([10]) == 0\nassert op_neg_firsteven([2, 4, 6]) == 0\nassert op_neg_firsteven([-7, 12, -7]) == 0"}
{"id": "op_rev_sortd", "entry_point": "op_rev_sortd", "primitives": ["rev", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending.", "solution": "def op_rev_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_sortd([]) == []\nassert op_rev_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_rev_sortd([10]) == [10]\nassert op_rev_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_rev_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_uniqs_upper", "entry_point": "op_uniqs_upper", "primitives": ["uniqs", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then uppercase each string.", "solution": "def op_uniqs_upper(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_uniqs_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_uniqs_upper([]) == []\nassert op_uniqs_upper(['  a ', '', 'BC', 'bc']) == ['  A ', '', 'BC', 'BC']\nassert op_uniqs_upper(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_uniqs_upper(['x']) == ['X']\nassert op_uniqs_upper(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_rev_len", "entry_point": "op_rev_len", "primitives": ["rev", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return how many remain.", "solution": "def op_rev_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_rev_len([1, 2, 3, 4]) == 4\nassert op_rev_len([]) == 0\nassert op_rev_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_len([5, 5, 5]) == 3\nassert op_rev_len([3, 1, 2]) == 3\nassert op_rev_len([10]) == 1\nassert op_rev_len([2, 4, 6]) == 3\nassert op_rev_len([-7, 12, -7]) == 3"}
{"id": "op_inc_beforezero", "entry_point": "op_inc_beforezero", "primitives": ["inc", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero.", "solution": "def op_inc_beforezero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_inc_beforezero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_beforezero([]) == []\nassert op_inc_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_beforezero([3, 1, 2]) == [4, 2, 3]\nassert op_inc_beforezero([10]) == [11]\nassert op_inc_beforezero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_beforezero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_evens_first3", "entry_point": "op_evens_first3", "primitives": ["evens", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three.", "solution": "def op_evens_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_evens_first3([1, 2, 3, 4]) == [2, 4]\nassert op_evens_first3([]) == []\nassert op_evens_first3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_first3([5, 5, 5]) == []\nassert op_evens_first3([3, 1, 2]) == [2]\nassert op_evens_first3([10]) == [10]\nassert op_evens_first3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_first3([-7, 12, -7]) == [12]"}
{"id": "op_odds_clamp10", "entry_point": "op_odds_clamp10", "primitives": ["odds", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10.", "solution": "def op_odds_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_odds_clamp10([1, 2, 3, 4]) == [1, 3]\nassert op_odds_clamp10([]) == []\nassert op_odds_clamp10([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_odds_clamp10([3, 1, 2]) == [3, 1]\nassert op_odds_clamp10([10]) == []\nassert op_odds_clamp10([2, 4, 6]) == []\nassert op_odds_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero_last3", "entry_point": "op_oremptyzero_last3", "primitives": ["oremptyzero", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three.", "solution": "def op_oremptyzero_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_last3([]) == [0]\nassert op_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_last3([10]) == [10]\nassert op_oremptyzero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_inc_firsteven", "entry_point": "op_inc_firsteven", "primitives": ["inc", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return the first even value (0 if none).", "solution": "def op_inc_firsteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_inc_firsteven([1, 2, 3, 4]) == 2\nassert op_inc_firsteven([]) == 0\nassert op_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_inc_firsteven([5, 5, 5]) == 6\nassert op_inc_firsteven([3, 1, 2]) == 4\nassert op_inc_firsteven([10]) == 0\nassert op_inc_firsteven([2, 4, 6]) == 0\nassert op_inc_firsteven([-7, 12, -7]) == -6"}
{"id": "op_prefixup_strip", "entry_point": "op_prefixup_strip", "primitives": ["prefixup", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then trim whitespace from each.", "solution": "def op_prefixup_strip(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_prefixup_strip(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_strip([]) == []\nassert op_prefixup_strip(['  a ', '', 'BC', 'bc']) == ['#  a', '#', '#BC', '#bc']\nassert op_prefixup_strip(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup_strip(['x']) == ['#x']\nassert op_prefixup_strip(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_upper_maxlen", "entry_point": "op_upper_maxlen", "primitives": ["upper", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then return the length of the longest string (0 if none).", "solution": "def op_upper_maxlen(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_upper_maxlen(['Hello', 'world']) == 5\nassert op_upper_maxlen([]) == 0\nassert op_upper_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_upper_maxlen(['one', 'one', 'Two']) == 3\nassert op_upper_maxlen(['x']) == 1\nassert op_upper_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_dropfirst_haszero", "entry_point": "op_dropfirst_haszero", "primitives": ["dropfirst", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return whether the list contains a zero.", "solution": "def op_dropfirst_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    return 0 in r", "tests": "assert op_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_haszero([]) == False\nassert op_dropfirst_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_haszero([5, 5, 5]) == False\nassert op_dropfirst_haszero([3, 1, 2]) == False\nassert op_dropfirst_haszero([10]) == False\nassert op_dropfirst_haszero([2, 4, 6]) == False\nassert op_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_last3_counteven", "entry_point": "op_last3_counteven", "primitives": ["last3", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return how many values are even.", "solution": "def op_last3_counteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_last3_counteven([1, 2, 3, 4]) == 2\nassert op_last3_counteven([]) == 0\nassert op_last3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_last3_counteven([5, 5, 5]) == 0\nassert op_last3_counteven([3, 1, 2]) == 1\nassert op_last3_counteven([10]) == 1\nassert op_last3_counteven([2, 4, 6]) == 3\nassert op_last3_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_evens", "entry_point": "op_neg_evens", "primitives": ["neg", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the even numbers.", "solution": "def op_neg_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_evens([1, 2, 3, 4]) == []\nassert op_neg_evens([]) == []\nassert op_neg_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_evens([5, 5, 5]) == []\nassert op_neg_evens([3, 1, 2]) == []\nassert op_neg_evens([10]) == []\nassert op_neg_evens([2, 4, 6]) == []\nassert op_neg_evens([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_add10", "entry_point": "op_oremptyzero_add10", "primitives": ["oremptyzero", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each.", "solution": "def op_oremptyzero_add10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_oremptyzero_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_oremptyzero_add10([]) == [10]\nassert op_oremptyzero_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_oremptyzero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_oremptyzero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_oremptyzero_add10([10]) == [20]\nassert op_oremptyzero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_oremptyzero_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_clamp10_issorted", "entry_point": "op_clamp10_issorted", "primitives": ["clamp10", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_clamp10_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_issorted([]) == True\nassert op_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_issorted([5, 5, 5]) == True\nassert op_clamp10_issorted([3, 1, 2]) == False\nassert op_clamp10_issorted([10]) == True\nassert op_clamp10_issorted([2, 4, 6]) == True\nassert op_clamp10_issorted([-7, 12, -7]) == False"}
{"id": "op_strip_nonempty", "entry_point": "op_strip_nonempty", "primitives": ["strip", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop empty strings.", "solution": "def op_strip_nonempty(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_strip_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_nonempty([]) == []\nassert op_strip_nonempty(['  a ', '', 'BC', 'bc']) == ['a', 'BC', 'bc']\nassert op_strip_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_strip_nonempty(['x']) == ['x']\nassert op_strip_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_gt5_evens", "entry_point": "op_gt5_evens", "primitives": ["gt5", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers.", "solution": "def op_gt5_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_gt5_evens([1, 2, 3, 4]) == []\nassert op_gt5_evens([]) == []\nassert op_gt5_evens([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens([5, 5, 5]) == []\nassert op_gt5_evens([3, 1, 2]) == []\nassert op_gt5_evens([10]) == [10]\nassert op_gt5_evens([2, 4, 6]) == [6]\nassert op_gt5_evens([-7, 12, -7]) == [12]"}
{"id": "op_sorta_inc", "entry_point": "op_sorta_inc", "primitives": ["sorta", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each.", "solution": "def op_sorta_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_inc([]) == []\nassert op_sorta_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_sorta_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_inc([10]) == [11]\nassert op_sorta_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_trimends_div3", "entry_point": "op_trimends_div3", "primitives": ["trimends", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep multiples of three.", "solution": "def op_trimends_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_div3([1, 2, 3, 4]) == [3]\nassert op_trimends_div3([]) == []\nassert op_trimends_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_div3([5, 5, 5]) == []\nassert op_trimends_div3([3, 1, 2]) == []\nassert op_trimends_div3([10]) == []\nassert op_trimends_div3([2, 4, 6]) == []\nassert op_trimends_div3([-7, 12, -7]) == [12]"}
{"id": "op_pos_sorta", "entry_point": "op_pos_sorta", "primitives": ["pos", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort ascending.", "solution": "def op_pos_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_pos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_sorta([]) == []\nassert op_pos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_pos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_pos_sorta([10]) == [10]\nassert op_pos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_pos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_sortlen_nonempty", "entry_point": "op_sortlen_nonempty", "primitives": ["sortlen", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop empty strings.", "solution": "def op_sortlen_nonempty(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_sortlen_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_nonempty([]) == []\nassert op_sortlen_nonempty(['  a ', '', 'BC', 'bc']) == ['BC', 'bc', '  a ']\nassert op_sortlen_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_sortlen_nonempty(['x']) == ['x']\nassert op_sortlen_nonempty(['abc', 'de', '']) == ['de', 'abc']"}
{"id": "op_square_pos", "entry_point": "op_square_pos", "primitives": ["square", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers.", "solution": "def op_square_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_pos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_pos([]) == []\nassert op_square_pos([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_square_pos([5, 5, 5]) == [25, 25, 25]\nassert op_square_pos([3, 1, 2]) == [9, 1, 4]\nassert op_square_pos([10]) == [100]\nassert op_square_pos([2, 4, 6]) == [4, 16, 36]\nassert op_square_pos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_odds_dropzeros", "entry_point": "op_odds_dropzeros", "primitives": ["odds", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros.", "solution": "def op_odds_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_dropzeros([1, 2, 3, 4]) == [1, 3]\nassert op_odds_dropzeros([]) == []\nassert op_odds_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_odds_dropzeros([3, 1, 2]) == [3, 1]\nassert op_odds_dropzeros([10]) == []\nassert op_odds_dropzeros([2, 4, 6]) == []\nassert op_odds_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_uniq", "entry_point": "op_evens_uniq", "primitives": ["evens", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop duplicates keeping first occurrence.", "solution": "def op_evens_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_evens_uniq([1, 2, 3, 4]) == [2, 4]\nassert op_evens_uniq([]) == []\nassert op_evens_uniq([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_uniq([5, 5, 5]) == []\nassert op_evens_uniq([3, 1, 2]) == [2]\nassert op_evens_uniq([10]) == [10]\nassert op_evens_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_evens_uniq([-7, 12, -7]) == [12]"}
{"id": "op_sortalpha_anyempty", "entry_point": "op_sortalpha_anyempty", "primitives": ["sortalpha", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then return whether any string is empty.", "solution": "def op_sortalpha_anyempty(xs):\n    r = list(xs)\n    r = sorted(r)\n    return any(s == '' for s in r)", "tests": "assert op_sortalpha_anyempty(['Hello', 'world']) == False\nassert op_sortalpha_anyempty([]) == False\nassert op_sortalpha_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_sortalpha_anyempty(['one', 'one', 'Two']) == False\nassert op_sortalpha_anyempty(['x']) == False\nassert op_sortalpha_anyempty(['abc', 'de', '']) == True"}
{"id": "op_dec_last3", "entry_point": "op_dec_last3", "primitives": ["dec", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three.", "solution": "def op_dec_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_last3([]) == []\nassert op_dec_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dec_last3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_last3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_last3([10]) == [9]\nassert op_dec_last3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_last3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropfirst_pos", "entry_point": "op_dropfirst_pos", "primitives": ["dropfirst", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers.", "solution": "def op_dropfirst_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_pos([]) == []\nassert op_dropfirst_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropfirst_pos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_pos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_pos([10]) == []\nassert op_dropfirst_pos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_pos([-7, 12, -7]) == [12]"}
{"id": "op_names_prefixup", "entry_point": "op_names_prefixup", "primitives": ["names", "prefixup"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then prefix each with a hash.", "solution": "def op_names_prefixup(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_names_prefixup([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['#Ada', '#Bo']\nassert op_names_prefixup([]) == []\nassert op_names_prefixup([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['#Cy', '#Dee', '#El']\nassert op_names_prefixup([{'name': 'Fi', 'age': 41}]) == ['#Fi']"}
{"id": "op_dropshort_counts", "entry_point": "op_dropshort_counts", "primitives": ["dropshort", "counts"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then return how many strings remain.", "solution": "def op_dropshort_counts(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return len(r)", "tests": "assert op_dropshort_counts(['Hello', 'world']) == 2\nassert op_dropshort_counts([]) == 0\nassert op_dropshort_counts(['  a ', '', 'BC', 'bc']) == 1\nassert op_dropshort_counts(['one', 'one', 'Two']) == 3\nassert op_dropshort_counts(['x']) == 0\nassert op_dropshort_counts(['abc', 'de', '']) == 1"}
{"id": "op_odds_oremptyzero", "entry_point": "op_odds_oremptyzero", "primitives": ["odds", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero.", "solution": "def op_odds_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_odds_oremptyzero([1, 2, 3, 4]) == [1, 3]\nassert op_odds_oremptyzero([]) == [0]\nassert op_odds_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_odds_oremptyzero([3, 1, 2]) == [3, 1]\nassert op_odds_oremptyzero([10]) == [0]\nassert op_odds_oremptyzero([2, 4, 6]) == [0]\nassert op_odds_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_first3_firsteven", "entry_point": "op_first3_firsteven", "primitives": ["first3", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return the first even value (0 if none).", "solution": "def op_first3_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_firsteven([1, 2, 3, 4]) == 2\nassert op_first3_firsteven([]) == 0\nassert op_first3_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_first3_firsteven([5, 5, 5]) == 0\nassert op_first3_firsteven([3, 1, 2]) == 2\nassert op_first3_firsteven([10]) == 10\nassert op_first3_firsteven([2, 4, 6]) == 2\nassert op_first3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_trimends", "entry_point": "op_takewhilepos_trimends", "primitives": ["takewhilepos", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements.", "solution": "def op_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_takewhilepos_trimends([]) == []\nassert op_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_trimends([5, 5, 5]) == [5]\nassert op_takewhilepos_trimends([3, 1, 2]) == [1]\nassert op_takewhilepos_trimends([10]) == []\nassert op_takewhilepos_trimends([2, 4, 6]) == [4]\nassert op_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_dropshort_lower", "entry_point": "op_dropshort_lower", "primitives": ["dropshort", "lower"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then lowercase each string.", "solution": "def op_dropshort_lower(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_dropshort_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_dropshort_lower([]) == []\nassert op_dropshort_lower(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_dropshort_lower(['x']) == []\nassert op_dropshort_lower(['abc', 'de', '']) == ['abc']"}
{"id": "op_nonempty_joinc", "entry_point": "op_nonempty_joinc", "primitives": ["nonempty", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then join them with commas.", "solution": "def op_nonempty_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return ','.join(r)", "tests": "assert op_nonempty_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_nonempty_joinc([]) == ''\nassert op_nonempty_joinc(['  a ', '', 'BC', 'bc']) == '  a ,BC,bc'\nassert op_nonempty_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_nonempty_joinc(['x']) == 'x'\nassert op_nonempty_joinc(['abc', 'de', '']) == 'abc,de'"}
{"id": "op_sorta_issorted", "entry_point": "op_sorta_issorted", "primitives": ["sorta", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return whether the list is sorted ascending.", "solution": "def op_sorta_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_sorta_issorted([1, 2, 3, 4]) == True\nassert op_sorta_issorted([]) == True\nassert op_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_issorted([5, 5, 5]) == True\nassert op_sorta_issorted([3, 1, 2]) == True\nassert op_sorta_issorted([10]) == True\nassert op_sorta_issorted([2, 4, 6]) == True\nassert op_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_first3_dropwhileneg", "entry_point": "op_first3_dropwhileneg", "primitives": ["first3", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values.", "solution": "def op_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropwhileneg([]) == []\nassert op_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropwhileneg([10]) == [10]\nassert op_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortabs_uniq", "entry_point": "op_sortabs_uniq", "primitives": ["sortabs", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_uniq([]) == []\nassert op_sortabs_uniq([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_uniq([5, 5, 5]) == [5]\nassert op_sortabs_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_uniq([10]) == [10]\nassert op_sortabs_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_takewhilepos_issorted", "entry_point": "op_takewhilepos_issorted", "primitives": ["takewhilepos", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_takewhilepos_issorted([]) == True\nassert op_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_issorted([5, 5, 5]) == True\nassert op_takewhilepos_issorted([3, 1, 2]) == False\nassert op_takewhilepos_issorted([10]) == True\nassert op_takewhilepos_issorted([2, 4, 6]) == True\nassert op_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_ages_absval", "entry_point": "op_ages_absval", "primitives": ["ages", "absval"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each.", "solution": "def op_ages_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_absval([]) == []\nassert op_ages_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_absval([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_clamp10_dropwhileneg", "entry_point": "op_clamp10_dropwhileneg", "primitives": ["clamp10", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values.", "solution": "def op_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropwhileneg([]) == []\nassert op_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropwhileneg([10]) == [10]\nassert op_clamp10_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_rev_trimends", "entry_point": "op_rev_trimends", "primitives": ["rev", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements.", "solution": "def op_rev_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_rev_trimends([]) == []\nassert op_rev_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_rev_trimends([5, 5, 5]) == [5]\nassert op_rev_trimends([3, 1, 2]) == [1]\nassert op_rev_trimends([10]) == []\nassert op_rev_trimends([2, 4, 6]) == [4]\nassert op_rev_trimends([-7, 12, -7]) == [12]"}
{"id": "op_gt5_dropwhileneg", "entry_point": "op_gt5_dropwhileneg", "primitives": ["gt5", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the leading negative values.", "solution": "def op_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_gt5_dropwhileneg([]) == []\nassert op_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_gt5_dropwhileneg([10]) == [10]\nassert op_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_inc_counteven", "entry_point": "op_inc_counteven", "primitives": ["inc", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return how many values are even.", "solution": "def op_inc_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_counteven([1, 2, 3, 4]) == 2\nassert op_inc_counteven([]) == 0\nassert op_inc_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_inc_counteven([5, 5, 5]) == 3\nassert op_inc_counteven([3, 1, 2]) == 2\nassert op_inc_counteven([10]) == 0\nassert op_inc_counteven([2, 4, 6]) == 0\nassert op_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_dropfirst_takewhilepos", "entry_point": "op_dropfirst_takewhilepos", "primitives": ["dropfirst", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive.", "solution": "def op_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_takewhilepos([]) == []\nassert op_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_takewhilepos([10]) == []\nassert op_dropfirst_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_ages_sortabs", "entry_point": "op_ages_sortabs", "primitives": ["ages", "sortabs"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value.", "solution": "def op_ages_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sortabs([]) == []\nassert op_ages_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sortabs([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_first3_gt5", "entry_point": "op_first3_gt5", "primitives": ["first3", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five.", "solution": "def op_first3_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_gt5([1, 2, 3, 4]) == []\nassert op_first3_gt5([]) == []\nassert op_first3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_gt5([5, 5, 5]) == []\nassert op_first3_gt5([3, 1, 2]) == []\nassert op_first3_gt5([10]) == [10]\nassert op_first3_gt5([2, 4, 6]) == [6]\nassert op_first3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_add10_negate", "entry_point": "op_add10_negate", "primitives": ["add10", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each.", "solution": "def op_add10_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_add10_negate([]) == []\nassert op_add10_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_add10_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_add10_negate([10]) == [-20]\nassert op_add10_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_negate([-7, 12, -7]) == [-3, -22, -3]"}
{"id": "op_uniq_padto3", "entry_point": "op_uniq_padto3", "primitives": ["uniq", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_uniq_padto3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_padto3([]) == [0, 0, 0]\nassert op_uniq_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_uniq_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_padto3([10]) == [10, 0, 0]\nassert op_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_strip_joinc", "entry_point": "op_strip_joinc", "primitives": ["strip", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then join them with commas.", "solution": "def op_strip_joinc(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return ','.join(r)", "tests": "assert op_strip_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_strip_joinc([]) == ''\nassert op_strip_joinc(['  a ', '', 'BC', 'bc']) == 'a,,BC,bc'\nassert op_strip_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_strip_joinc(['x']) == 'x'\nassert op_strip_joinc(['abc', 'de', '']) == 'abc,de,'"}
{"id": "op_odds_last3", "entry_point": "op_odds_last3", "primitives": ["odds", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three.", "solution": "def op_odds_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_odds_last3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_last3([]) == []\nassert op_odds_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_last3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_last3([3, 1, 2]) == [3, 1]\nassert op_odds_last3([10]) == []\nassert op_odds_last3([2, 4, 6]) == []\nassert op_odds_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_takewhilepos_padto3", "entry_point": "op_takewhilepos_padto3", "primitives": ["takewhilepos", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_takewhilepos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_padto3([10]) == [10, 0, 0]\nassert op_takewhilepos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_add10_alldistinct", "entry_point": "op_add10_alldistinct", "primitives": ["add10", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return whether all values are distinct.", "solution": "def op_add10_alldistinct(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_add10_alldistinct([]) == True\nassert op_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_add10_alldistinct([5, 5, 5]) == False\nassert op_add10_alldistinct([3, 1, 2]) == True\nassert op_add10_alldistinct([10]) == True\nassert op_add10_alldistinct([2, 4, 6]) == True\nassert op_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_prod", "entry_point": "op_dropzeros_prod", "primitives": ["dropzeros", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return their product.", "solution": "def op_dropzeros_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_dropzeros_prod([1, 2, 3, 4]) == 24\nassert op_dropzeros_prod([]) == 1\nassert op_dropzeros_prod([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_prod([5, 5, 5]) == 125\nassert op_dropzeros_prod([3, 1, 2]) == 6\nassert op_dropzeros_prod([10]) == 10\nassert op_dropzeros_prod([2, 4, 6]) == 48\nassert op_dropzeros_prod([-7, 12, -7]) == 588"}
{"id": "op_trimends_clamp10", "entry_point": "op_trimends_clamp10", "primitives": ["trimends", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cap each value at 10.", "solution": "def op_trimends_clamp10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_trimends_clamp10([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_clamp10([]) == []\nassert op_trimends_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_clamp10([5, 5, 5]) == [5]\nassert op_trimends_clamp10([3, 1, 2]) == [1]\nassert op_trimends_clamp10([10]) == []\nassert op_trimends_clamp10([2, 4, 6]) == [4]\nassert op_trimends_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_add10_issorted", "entry_point": "op_add10_issorted", "primitives": ["add10", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return whether the list is sorted ascending.", "solution": "def op_add10_issorted(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_add10_issorted([1, 2, 3, 4]) == True\nassert op_add10_issorted([]) == True\nassert op_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_add10_issorted([5, 5, 5]) == True\nassert op_add10_issorted([3, 1, 2]) == False\nassert op_add10_issorted([10]) == True\nassert op_add10_issorted([2, 4, 6]) == True\nassert op_add10_issorted([-7, 12, -7]) == False"}
{"id": "op_add10_gt5", "entry_point": "op_add10_gt5", "primitives": ["add10", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five.", "solution": "def op_add10_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_gt5([]) == []\nassert op_add10_gt5([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5([10]) == [20]\nassert op_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_dropwhileneg_min", "entry_point": "op_dropwhileneg_min", "primitives": ["dropwhileneg", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return the minimum (0 if empty).", "solution": "def op_dropwhileneg_min(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return min(r) if r else 0", "tests": "assert op_dropwhileneg_min([1, 2, 3, 4]) == 1\nassert op_dropwhileneg_min([]) == 0\nassert op_dropwhileneg_min([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_min([5, 5, 5]) == 5\nassert op_dropwhileneg_min([3, 1, 2]) == 1\nassert op_dropwhileneg_min([10]) == 10\nassert op_dropwhileneg_min([2, 4, 6]) == 2\nassert op_dropwhileneg_min([-7, 12, -7]) == -7"}
{"id": "op_oremptyzero_dec", "entry_point": "op_oremptyzero_dec", "primitives": ["oremptyzero", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each.", "solution": "def op_oremptyzero_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_oremptyzero_dec([]) == [-1]\nassert op_oremptyzero_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_oremptyzero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_oremptyzero_dec([3, 1, 2]) == [2, 0, 1]\nassert op_oremptyzero_dec([10]) == [9]\nassert op_oremptyzero_dec([2, 4, 6]) == [1, 3, 5]\nassert op_oremptyzero_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_sortlen_counts", "entry_point": "op_sortlen_counts", "primitives": ["sortlen", "counts"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then return how many strings remain.", "solution": "def op_sortlen_counts(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return len(r)", "tests": "assert op_sortlen_counts(['Hello', 'world']) == 2\nassert op_sortlen_counts([]) == 0\nassert op_sortlen_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortlen_counts(['one', 'one', 'Two']) == 3\nassert op_sortlen_counts(['x']) == 1\nassert op_sortlen_counts(['abc', 'de', '']) == 3"}
{"id": "op_sorta_alldistinct", "entry_point": "op_sorta_alldistinct", "primitives": ["sorta", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return whether all values are distinct.", "solution": "def op_sorta_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    return len(r) == len(set(r))", "tests": "assert op_sorta_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_alldistinct([]) == True\nassert op_sorta_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sorta_alldistinct([5, 5, 5]) == False\nassert op_sorta_alldistinct([3, 1, 2]) == True\nassert op_sorta_alldistinct([10]) == True\nassert op_sorta_alldistinct([2, 4, 6]) == True\nassert op_sorta_alldistinct([-7, 12, -7]) == False"}
{"id": "op_absval_inc", "entry_point": "op_absval_inc", "primitives": ["absval", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add one to each.", "solution": "def op_absval_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_inc([]) == []\nassert op_absval_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 2, 3]\nassert op_absval_inc([5, 5, 5]) == [6, 6, 6]\nassert op_absval_inc([3, 1, 2]) == [4, 2, 3]\nassert op_absval_inc([10]) == [11]\nassert op_absval_inc([2, 4, 6]) == [3, 5, 7]\nassert op_absval_inc([-7, 12, -7]) == [8, 13, 8]"}
{"id": "op_padto3_gt5", "entry_point": "op_padto3_gt5", "primitives": ["padto3", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five.", "solution": "def op_padto3_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_gt5([1, 2, 3, 4]) == []\nassert op_padto3_gt5([]) == []\nassert op_padto3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5([5, 5, 5]) == []\nassert op_padto3_gt5([3, 1, 2]) == []\nassert op_padto3_gt5([10]) == [10]\nassert op_padto3_gt5([2, 4, 6]) == [6]\nassert op_padto3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_sortalpha", "entry_point": "op_uniqs_sortalpha", "primitives": ["uniqs", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically.", "solution": "def op_uniqs_sortalpha(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return r", "tests": "assert op_uniqs_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_sortalpha([]) == []\nassert op_uniqs_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'BC', 'bc']\nassert op_uniqs_sortalpha(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_uniqs_sortalpha(['x']) == ['x']\nassert op_uniqs_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_sortabs_negate", "entry_point": "op_sortabs_negate", "primitives": ["sortabs", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then negate each.", "solution": "def op_sortabs_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sortabs_negate([]) == []\nassert op_sortabs_negate([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortabs_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_negate([10]) == [-10]\nassert op_sortabs_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_dropzeros_first3", "entry_point": "op_dropzeros_first3", "primitives": ["dropzeros", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three.", "solution": "def op_dropzeros_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_first3([]) == []\nassert op_dropzeros_first3([-2, -1, 0, 1, 2]) == [-2, -1, 1]\nassert op_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_first3([10]) == [10]\nassert op_dropzeros_first3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg_len", "entry_point": "op_neg_len", "primitives": ["neg", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return how many remain.", "solution": "def op_neg_len(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_neg_len([1, 2, 3, 4]) == 0\nassert op_neg_len([]) == 0\nassert op_neg_len([-2, -1, 0, 1, 2]) == 2\nassert op_neg_len([5, 5, 5]) == 0\nassert op_neg_len([3, 1, 2]) == 0\nassert op_neg_len([10]) == 0\nassert op_neg_len([2, 4, 6]) == 0\nassert op_neg_len([-7, 12, -7]) == 2"}
{"id": "op_nonempty_upper", "entry_point": "op_nonempty_upper", "primitives": ["nonempty", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then uppercase each string.", "solution": "def op_nonempty_upper(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_nonempty_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_nonempty_upper([]) == []\nassert op_nonempty_upper(['  a ', '', 'BC', 'bc']) == ['  A ', 'BC', 'BC']\nassert op_nonempty_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_nonempty_upper(['x']) == ['X']\nassert op_nonempty_upper(['abc', 'de', '']) == ['ABC', 'DE']"}
{"id": "op_sortd_square", "entry_point": "op_sortd_square", "primitives": ["sortd", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each.", "solution": "def op_sortd_square(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortd_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_square([]) == []\nassert op_sortd_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sortd_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_square([10]) == [100]\nassert op_sortd_square([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_rev_uniq", "entry_point": "op_rev_uniq", "primitives": ["rev", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence.", "solution": "def op_rev_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_uniq([]) == []\nassert op_rev_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_uniq([5, 5, 5]) == [5]\nassert op_rev_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_uniq([10]) == [10]\nassert op_rev_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropwhileneg_inc", "entry_point": "op_dropwhileneg_inc", "primitives": ["dropwhileneg", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each.", "solution": "def op_dropwhileneg_inc(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropwhileneg_inc([]) == []\nassert op_dropwhileneg_inc([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_inc([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_inc([3, 1, 2]) == [4, 2, 3]\nassert op_dropwhileneg_inc([10]) == [11]\nassert op_dropwhileneg_inc([2, 4, 6]) == [3, 5, 7]\nassert op_dropwhileneg_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_add10_beforezero", "entry_point": "op_add10_beforezero", "primitives": ["add10", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero.", "solution": "def op_add10_beforezero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_add10_beforezero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_beforezero([]) == []\nassert op_add10_beforezero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_beforezero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_beforezero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_beforezero([10]) == [20]\nassert op_add10_beforezero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_beforezero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_add10_neg", "entry_point": "op_add10_neg", "primitives": ["add10", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers.", "solution": "def op_add10_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_neg([1, 2, 3, 4]) == []\nassert op_add10_neg([]) == []\nassert op_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg([5, 5, 5]) == []\nassert op_add10_neg([3, 1, 2]) == []\nassert op_add10_neg([10]) == []\nassert op_add10_neg([2, 4, 6]) == []\nassert op_add10_neg([-7, 12, -7]) == []"}
{"id": "op_square_dropzeros", "entry_point": "op_square_dropzeros", "primitives": ["square", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the zeros.", "solution": "def op_square_dropzeros(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_square_dropzeros([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_dropzeros([]) == []\nassert op_square_dropzeros([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_square_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_square_dropzeros([3, 1, 2]) == [9, 1, 4]\nassert op_square_dropzeros([10]) == [100]\nassert op_square_dropzeros([2, 4, 6]) == [4, 16, 36]\nassert op_square_dropzeros([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_div3_dec", "entry_point": "op_div3_dec", "primitives": ["div3", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each.", "solution": "def op_div3_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_dec([1, 2, 3, 4]) == [2]\nassert op_div3_dec([]) == []\nassert op_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_dec([5, 5, 5]) == []\nassert op_div3_dec([3, 1, 2]) == [2]\nassert op_div3_dec([10]) == []\nassert op_div3_dec([2, 4, 6]) == [5]\nassert op_div3_dec([-7, 12, -7]) == [11]"}
{"id": "op_sortalpha_lens", "entry_point": "op_sortalpha_lens", "primitives": ["sortalpha", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then return the total number of characters.", "solution": "def op_sortalpha_lens(xs):\n    r = list(xs)\n    r = sorted(r)\n    return sum(len(s) for s in r)", "tests": "assert op_sortalpha_lens(['Hello', 'world']) == 10\nassert op_sortalpha_lens([]) == 0\nassert op_sortalpha_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_sortalpha_lens(['one', 'one', 'Two']) == 9\nassert op_sortalpha_lens(['x']) == 1\nassert op_sortalpha_lens(['abc', 'de', '']) == 5"}
{"id": "op_inc_prod", "entry_point": "op_inc_prod", "primitives": ["inc", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return their product.", "solution": "def op_inc_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_inc_prod([1, 2, 3, 4]) == 120\nassert op_inc_prod([]) == 1\nassert op_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_inc_prod([5, 5, 5]) == 216\nassert op_inc_prod([3, 1, 2]) == 24\nassert op_inc_prod([10]) == 11\nassert op_inc_prod([2, 4, 6]) == 105\nassert op_inc_prod([-7, 12, -7]) == 468"}
{"id": "op_sorta_haszero", "entry_point": "op_sorta_haszero", "primitives": ["sorta", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return whether the list contains a zero.", "solution": "def op_sorta_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    return 0 in r", "tests": "assert op_sorta_haszero([1, 2, 3, 4]) == False\nassert op_sorta_haszero([]) == False\nassert op_sorta_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_haszero([5, 5, 5]) == False\nassert op_sorta_haszero([3, 1, 2]) == False\nassert op_sorta_haszero([10]) == False\nassert op_sorta_haszero([2, 4, 6]) == False\nassert op_sorta_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_beforezero", "entry_point": "op_uniq_beforezero", "primitives": ["uniq", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero.", "solution": "def op_uniq_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_beforezero([]) == []\nassert op_uniq_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_beforezero([5, 5, 5]) == [5]\nassert op_uniq_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_beforezero([10]) == [10]\nassert op_uniq_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_first3_dropzeros", "entry_point": "op_first3_dropzeros", "primitives": ["first3", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros.", "solution": "def op_first3_dropzeros(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_first3_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropzeros([]) == []\nassert op_first3_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropzeros([10]) == [10]\nassert op_first3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropshort_uniqs", "entry_point": "op_dropshort_uniqs", "primitives": ["dropshort", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then drop duplicate strings keeping the first.", "solution": "def op_dropshort_uniqs(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropshort_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort_uniqs([]) == []\nassert op_dropshort_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_uniqs(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_dropshort_uniqs(['x']) == []\nassert op_dropshort_uniqs(['abc', 'de', '']) == ['abc']"}
{"id": "op_takewhilepos_len", "entry_point": "op_takewhilepos_len", "primitives": ["takewhilepos", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return how many remain.", "solution": "def op_takewhilepos_len(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_takewhilepos_len([1, 2, 3, 4]) == 4\nassert op_takewhilepos_len([]) == 0\nassert op_takewhilepos_len([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_len([5, 5, 5]) == 3\nassert op_takewhilepos_len([3, 1, 2]) == 3\nassert op_takewhilepos_len([10]) == 1\nassert op_takewhilepos_len([2, 4, 6]) == 3\nassert op_takewhilepos_len([-7, 12, -7]) == 0"}
{"id": "op_rev_dropfirst", "entry_point": "op_rev_dropfirst", "primitives": ["rev", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element.", "solution": "def op_rev_dropfirst(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    return r", "tests": "assert op_rev_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dropfirst([]) == []\nassert op_rev_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_rev_dropfirst([5, 5, 5]) == [5, 5]\nassert op_rev_dropfirst([3, 1, 2]) == [1, 3]\nassert op_rev_dropfirst([10]) == []\nassert op_rev_dropfirst([2, 4, 6]) == [4, 2]\nassert op_rev_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_sorta_last3", "entry_point": "op_sorta_last3", "primitives": ["sorta", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the last three.", "solution": "def op_sorta_last3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[-3:]\n    return r", "tests": "assert op_sorta_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_last3([]) == []\nassert op_sorta_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sorta_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_last3([10]) == [10]\nassert op_sorta_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_oremptyzero_first3", "entry_point": "op_oremptyzero_first3", "primitives": ["oremptyzero", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three.", "solution": "def op_oremptyzero_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_first3([]) == [0]\nassert op_oremptyzero_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_oremptyzero_first3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_first3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_first3([10]) == [10]\nassert op_oremptyzero_first3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_odds_add10", "entry_point": "op_odds_add10", "primitives": ["odds", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each.", "solution": "def op_odds_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_odds_add10([1, 2, 3, 4]) == [11, 13]\nassert op_odds_add10([]) == []\nassert op_odds_add10([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_add10([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10([3, 1, 2]) == [13, 11]\nassert op_odds_add10([10]) == []\nassert op_odds_add10([2, 4, 6]) == []\nassert op_odds_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_sortd_min", "entry_point": "op_sortd_min", "primitives": ["sortd", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return the minimum (0 if empty).", "solution": "def op_sortd_min(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_sortd_min([1, 2, 3, 4]) == 1\nassert op_sortd_min([]) == 0\nassert op_sortd_min([-2, -1, 0, 1, 2]) == -2\nassert op_sortd_min([5, 5, 5]) == 5\nassert op_sortd_min([3, 1, 2]) == 1\nassert op_sortd_min([10]) == 10\nassert op_sortd_min([2, 4, 6]) == 2\nassert op_sortd_min([-7, 12, -7]) == -7"}
{"id": "op_dropshort_sortalpha", "entry_point": "op_dropshort_sortalpha", "primitives": ["dropshort", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then sort alphabetically.", "solution": "def op_dropshort_sortalpha(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r)\n    return r", "tests": "assert op_dropshort_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort_sortalpha([]) == []\nassert op_dropshort_sortalpha(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_dropshort_sortalpha(['x']) == []\nassert op_dropshort_sortalpha(['abc', 'de', '']) == ['abc']"}
{"id": "op_sortabs_dec", "entry_point": "op_sortabs_dec", "primitives": ["sortabs", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each.", "solution": "def op_sortabs_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortabs_dec([]) == []\nassert op_sortabs_dec([-2, -1, 0, 1, 2]) == [-1, -2, 0, -3, 1]\nassert op_sortabs_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sortabs_dec([10]) == [9]\nassert op_sortabs_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sortabs_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_trimends_counteven", "entry_point": "op_trimends_counteven", "primitives": ["trimends", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return how many values are even.", "solution": "def op_trimends_counteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_trimends_counteven([]) == 0\nassert op_trimends_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_counteven([5, 5, 5]) == 0\nassert op_trimends_counteven([3, 1, 2]) == 0\nassert op_trimends_counteven([10]) == 0\nassert op_trimends_counteven([2, 4, 6]) == 1\nassert op_trimends_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortabs_haszero", "entry_point": "op_sortabs_haszero", "primitives": ["sortabs", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return whether the list contains a zero.", "solution": "def op_sortabs_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_haszero([]) == False\nassert op_sortabs_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_haszero([5, 5, 5]) == False\nassert op_sortabs_haszero([3, 1, 2]) == False\nassert op_sortabs_haszero([10]) == False\nassert op_sortabs_haszero([2, 4, 6]) == False\nassert op_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_square_odds", "entry_point": "op_square_odds", "primitives": ["square", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers.", "solution": "def op_square_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_odds([1, 2, 3, 4]) == [1, 9]\nassert op_square_odds([]) == []\nassert op_square_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_odds([5, 5, 5]) == [25, 25, 25]\nassert op_square_odds([3, 1, 2]) == [9, 1]\nassert op_square_odds([10]) == []\nassert op_square_odds([2, 4, 6]) == []\nassert op_square_odds([-7, 12, -7]) == [49, 49]"}
{"id": "op_dropwhileneg_double", "entry_point": "op_dropwhileneg_double", "primitives": ["dropwhileneg", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each.", "solution": "def op_dropwhileneg_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_double([]) == []\nassert op_dropwhileneg_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropwhileneg_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_double([10]) == [20]\nassert op_dropwhileneg_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_last3_firsteven", "entry_point": "op_last3_firsteven", "primitives": ["last3", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return the first even value (0 if none).", "solution": "def op_last3_firsteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_last3_firsteven([1, 2, 3, 4]) == 2\nassert op_last3_firsteven([]) == 0\nassert op_last3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_last3_firsteven([5, 5, 5]) == 0\nassert op_last3_firsteven([3, 1, 2]) == 2\nassert op_last3_firsteven([10]) == 10\nassert op_last3_firsteven([2, 4, 6]) == 2\nassert op_last3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_div3_padto3", "entry_point": "op_div3_padto3", "primitives": ["div3", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements.", "solution": "def op_div3_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_div3_padto3([]) == [0, 0, 0]\nassert op_div3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_div3_padto3([10]) == [0, 0, 0]\nassert op_div3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_div3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sorta_anyeven", "entry_point": "op_sorta_anyeven", "primitives": ["sorta", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return whether any value is even.", "solution": "def op_sorta_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_anyeven([]) == False\nassert op_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_anyeven([5, 5, 5]) == False\nassert op_sorta_anyeven([3, 1, 2]) == True\nassert op_sorta_anyeven([10]) == True\nassert op_sorta_anyeven([2, 4, 6]) == True\nassert op_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_sortd", "entry_point": "op_absval_sortd", "primitives": ["absval", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending.", "solution": "def op_absval_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_sortd([]) == []\nassert op_absval_sortd([-2, -1, 0, 1, 2]) == [2, 2, 1, 1, 0]\nassert op_absval_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_absval_sortd([10]) == [10]\nassert op_absval_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_absval_sortd([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_pos_beforezero", "entry_point": "op_pos_beforezero", "primitives": ["pos", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero.", "solution": "def op_pos_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_beforezero([]) == []\nassert op_pos_beforezero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_pos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_pos_beforezero([10]) == [10]\nassert op_pos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_div3_dropzeros", "entry_point": "op_div3_dropzeros", "primitives": ["div3", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros.", "solution": "def op_div3_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_div3_dropzeros([1, 2, 3, 4]) == [3]\nassert op_div3_dropzeros([]) == []\nassert op_div3_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros([5, 5, 5]) == []\nassert op_div3_dropzeros([3, 1, 2]) == [3]\nassert op_div3_dropzeros([10]) == []\nassert op_div3_dropzeros([2, 4, 6]) == [6]\nassert op_div3_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_gt5_dropzeros", "entry_point": "op_gt5_dropzeros", "primitives": ["gt5", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros.", "solution": "def op_gt5_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_gt5_dropzeros([]) == []\nassert op_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropzeros([5, 5, 5]) == []\nassert op_gt5_dropzeros([3, 1, 2]) == []\nassert op_gt5_dropzeros([10]) == [10]\nassert op_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_odds_sorta", "entry_point": "op_odds_sorta", "primitives": ["odds", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending.", "solution": "def op_odds_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_odds_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sorta([]) == []\nassert op_odds_sorta([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sorta([3, 1, 2]) == [1, 3]\nassert op_odds_sorta([10]) == []\nassert op_odds_sorta([2, 4, 6]) == []\nassert op_odds_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_first3_dec", "entry_point": "op_first3_dec", "primitives": ["first3", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each.", "solution": "def op_first3_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_dec([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_dec([]) == []\nassert op_first3_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_first3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_first3_dec([10]) == [9]\nassert op_first3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_first3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_takewhilepos_clamp10", "entry_point": "op_takewhilepos_clamp10", "primitives": ["takewhilepos", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10.", "solution": "def op_takewhilepos_clamp10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_takewhilepos_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_clamp10([]) == []\nassert op_takewhilepos_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_clamp10([10]) == [10]\nassert op_takewhilepos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_clamp10([-7, 12, -7]) == []"}
{"id": "op_dropshort_strip", "entry_point": "op_dropshort_strip", "primitives": ["dropshort", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then trim whitespace from each.", "solution": "def op_dropshort_strip(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_dropshort_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort_strip([]) == []\nassert op_dropshort_strip(['  a ', '', 'BC', 'bc']) == ['a']\nassert op_dropshort_strip(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_dropshort_strip(['x']) == []\nassert op_dropshort_strip(['abc', 'de', '']) == ['abc']"}
{"id": "op_odds_div3", "entry_point": "op_odds_div3", "primitives": ["odds", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three.", "solution": "def op_odds_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_div3([1, 2, 3, 4]) == [3]\nassert op_odds_div3([]) == []\nassert op_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3([5, 5, 5]) == []\nassert op_odds_div3([3, 1, 2]) == [3]\nassert op_odds_div3([10]) == []\nassert op_odds_div3([2, 4, 6]) == []\nassert op_odds_div3([-7, 12, -7]) == []"}
{"id": "op_square_add10", "entry_point": "op_square_add10", "primitives": ["square", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each.", "solution": "def op_square_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_square_add10([]) == []\nassert op_square_add10([-2, -1, 0, 1, 2]) == [14, 11, 10, 11, 14]\nassert op_square_add10([5, 5, 5]) == [35, 35, 35]\nassert op_square_add10([3, 1, 2]) == [19, 11, 14]\nassert op_square_add10([10]) == [110]\nassert op_square_add10([2, 4, 6]) == [14, 26, 46]\nassert op_square_add10([-7, 12, -7]) == [59, 154, 59]"}
{"id": "op_absval_len", "entry_point": "op_absval_len", "primitives": ["absval", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return how many remain.", "solution": "def op_absval_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return len(r)", "tests": "assert op_absval_len([1, 2, 3, 4]) == 4\nassert op_absval_len([]) == 0\nassert op_absval_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_len([5, 5, 5]) == 3\nassert op_absval_len([3, 1, 2]) == 3\nassert op_absval_len([10]) == 1\nassert op_absval_len([2, 4, 6]) == 3\nassert op_absval_len([-7, 12, -7]) == 3"}
{"id": "op_inc_uniq", "entry_point": "op_inc_uniq", "primitives": ["inc", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_inc_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_uniq([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_uniq([]) == []\nassert op_inc_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_uniq([5, 5, 5]) == [6]\nassert op_inc_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_inc_uniq([10]) == [11]\nassert op_inc_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_inc_uniq([-7, 12, -7]) == [-6, 13]"}
{"id": "op_trimends_takewhilepos", "entry_point": "op_trimends_takewhilepos", "primitives": ["trimends", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive.", "solution": "def op_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_trimends_takewhilepos([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_takewhilepos([]) == []\nassert op_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_trimends_takewhilepos([5, 5, 5]) == [5]\nassert op_trimends_takewhilepos([3, 1, 2]) == [1]\nassert op_trimends_takewhilepos([10]) == []\nassert op_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_trimends_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_evens_gt5", "entry_point": "op_evens_gt5", "primitives": ["evens", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five.", "solution": "def op_evens_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_gt5([1, 2, 3, 4]) == []\nassert op_evens_gt5([]) == []\nassert op_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5([5, 5, 5]) == []\nassert op_evens_gt5([3, 1, 2]) == []\nassert op_evens_gt5([10]) == [10]\nassert op_evens_gt5([2, 4, 6]) == [6]\nassert op_evens_gt5([-7, 12, -7]) == [12]"}
{"id": "op_ages_padto3", "entry_point": "op_ages_padto3", "primitives": ["ages", "padto3"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements.", "solution": "def op_ages_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12, 0]\nassert op_ages_padto3([]) == [0, 0, 0]\nassert op_ages_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_padto3([{'name': 'Fi', 'age': 41}]) == [41, 0, 0]"}
{"id": "op_takewhilepos_anyeven", "entry_point": "op_takewhilepos_anyeven", "primitives": ["takewhilepos", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return whether any value is even.", "solution": "def op_takewhilepos_anyeven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_takewhilepos_anyeven([1, 2, 3, 4]) == True\nassert op_takewhilepos_anyeven([]) == False\nassert op_takewhilepos_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_anyeven([5, 5, 5]) == False\nassert op_takewhilepos_anyeven([3, 1, 2]) == True\nassert op_takewhilepos_anyeven([10]) == True\nassert op_takewhilepos_anyeven([2, 4, 6]) == True\nassert op_takewhilepos_anyeven([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_trimends", "entry_point": "op_dropwhileneg_trimends", "primitives": ["dropwhileneg", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements.", "solution": "def op_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_dropwhileneg_trimends([]) == []\nassert op_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_dropwhileneg_trimends([3, 1, 2]) == [1]\nassert op_dropwhileneg_trimends([10]) == []\nassert op_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_last3_issorted", "entry_point": "op_last3_issorted", "primitives": ["last3", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_last3_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_last3_issorted([1, 2, 3, 4]) == True\nassert op_last3_issorted([]) == True\nassert op_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_issorted([5, 5, 5]) == True\nassert op_last3_issorted([3, 1, 2]) == False\nassert op_last3_issorted([10]) == True\nassert op_last3_issorted([2, 4, 6]) == True\nassert op_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_beforezero_uniq", "entry_point": "op_beforezero_uniq", "primitives": ["beforezero", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_uniq([]) == []\nassert op_beforezero_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_uniq([5, 5, 5]) == [5]\nassert op_beforezero_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_uniq([10]) == [10]\nassert op_beforezero_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_evens_prod", "entry_point": "op_evens_prod", "primitives": ["evens", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return their product.", "solution": "def op_evens_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_evens_prod([1, 2, 3, 4]) == 8\nassert op_evens_prod([]) == 1\nassert op_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_prod([5, 5, 5]) == 1\nassert op_evens_prod([3, 1, 2]) == 2\nassert op_evens_prod([10]) == 10\nassert op_evens_prod([2, 4, 6]) == 48\nassert op_evens_prod([-7, 12, -7]) == 12"}
{"id": "op_dec_pos", "entry_point": "op_dec_pos", "primitives": ["dec", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers.", "solution": "def op_dec_pos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dec_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_pos([]) == []\nassert op_dec_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_dec_pos([5, 5, 5]) == [4, 4, 4]\nassert op_dec_pos([3, 1, 2]) == [2, 1]\nassert op_dec_pos([10]) == [9]\nassert op_dec_pos([2, 4, 6]) == [1, 3, 5]\nassert op_dec_pos([-7, 12, -7]) == [11]"}
{"id": "op_neg_alldistinct", "entry_point": "op_neg_alldistinct", "primitives": ["neg", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return whether all values are distinct.", "solution": "def op_neg_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return len(r) == len(set(r))", "tests": "assert op_neg_alldistinct([1, 2, 3, 4]) == True\nassert op_neg_alldistinct([]) == True\nassert op_neg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_neg_alldistinct([5, 5, 5]) == True\nassert op_neg_alldistinct([3, 1, 2]) == True\nassert op_neg_alldistinct([10]) == True\nassert op_neg_alldistinct([2, 4, 6]) == True\nassert op_neg_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_uniq", "entry_point": "op_last3_uniq", "primitives": ["last3", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop duplicates keeping first occurrence.", "solution": "def op_last3_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_uniq([]) == []\nassert op_last3_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_uniq([5, 5, 5]) == [5]\nassert op_last3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_last3_uniq([10]) == [10]\nassert op_last3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_last3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_neg_pos", "entry_point": "op_neg_pos", "primitives": ["neg", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers.", "solution": "def op_neg_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_neg_pos([1, 2, 3, 4]) == []\nassert op_neg_pos([]) == []\nassert op_neg_pos([-2, -1, 0, 1, 2]) == []\nassert op_neg_pos([5, 5, 5]) == []\nassert op_neg_pos([3, 1, 2]) == []\nassert op_neg_pos([10]) == []\nassert op_neg_pos([2, 4, 6]) == []\nassert op_neg_pos([-7, 12, -7]) == []"}
{"id": "op_absval_double", "entry_point": "op_absval_double", "primitives": ["absval", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then double each.", "solution": "def op_absval_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_absval_double([]) == []\nassert op_absval_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_absval_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_double([3, 1, 2]) == [6, 2, 4]\nassert op_absval_double([10]) == [20]\nassert op_absval_double([2, 4, 6]) == [4, 8, 12]\nassert op_absval_double([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_double_sum", "entry_point": "op_double_sum", "primitives": ["double", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return their sum.", "solution": "def op_double_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return sum(r)", "tests": "assert op_double_sum([1, 2, 3, 4]) == 20\nassert op_double_sum([]) == 0\nassert op_double_sum([-2, -1, 0, 1, 2]) == 0\nassert op_double_sum([5, 5, 5]) == 30\nassert op_double_sum([3, 1, 2]) == 12\nassert op_double_sum([10]) == 20\nassert op_double_sum([2, 4, 6]) == 24\nassert op_double_sum([-7, 12, -7]) == -4"}
{"id": "op_inc_dec", "entry_point": "op_inc_dec", "primitives": ["inc", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each.", "solution": "def op_inc_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_dec([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_dec([]) == []\nassert op_inc_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_dec([5, 5, 5]) == [5, 5, 5]\nassert op_inc_dec([3, 1, 2]) == [3, 1, 2]\nassert op_inc_dec([10]) == [10]\nassert op_inc_dec([2, 4, 6]) == [2, 4, 6]\nassert op_inc_dec([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_absval", "entry_point": "op_rev_absval", "primitives": ["rev", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each.", "solution": "def op_rev_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_absval([]) == []\nassert op_rev_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_rev_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_absval([3, 1, 2]) == [2, 1, 3]\nassert op_rev_absval([10]) == [10]\nassert op_rev_absval([2, 4, 6]) == [6, 4, 2]\nassert op_rev_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_alldistinct", "entry_point": "op_double_alldistinct", "primitives": ["double", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return whether all values are distinct.", "solution": "def op_double_alldistinct(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_double_alldistinct([1, 2, 3, 4]) == True\nassert op_double_alldistinct([]) == True\nassert op_double_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_double_alldistinct([5, 5, 5]) == False\nassert op_double_alldistinct([3, 1, 2]) == True\nassert op_double_alldistinct([10]) == True\nassert op_double_alldistinct([2, 4, 6]) == True\nassert op_double_alldistinct([-7, 12, -7]) == False"}
{"id": "op_add10_trimends", "entry_point": "op_add10_trimends", "primitives": ["add10", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements.", "solution": "def op_add10_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_add10_trimends([]) == []\nassert op_add10_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_trimends([5, 5, 5]) == [15]\nassert op_add10_trimends([3, 1, 2]) == [11]\nassert op_add10_trimends([10]) == []\nassert op_add10_trimends([2, 4, 6]) == [14]\nassert op_add10_trimends([-7, 12, -7]) == [22]"}
{"id": "op_padto3_neg", "entry_point": "op_padto3_neg", "primitives": ["padto3", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_padto3_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_neg([1, 2, 3, 4]) == []\nassert op_padto3_neg([]) == []\nassert op_padto3_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_padto3_neg([5, 5, 5]) == []\nassert op_padto3_neg([3, 1, 2]) == []\nassert op_padto3_neg([10]) == []\nassert op_padto3_neg([2, 4, 6]) == []\nassert op_padto3_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_haszero", "entry_point": "op_neg_haszero", "primitives": ["neg", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return whether the list contains a zero.", "solution": "def op_neg_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return 0 in r", "tests": "assert op_neg_haszero([1, 2, 3, 4]) == False\nassert op_neg_haszero([]) == False\nassert op_neg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_haszero([5, 5, 5]) == False\nassert op_neg_haszero([3, 1, 2]) == False\nassert op_neg_haszero([10]) == False\nassert op_neg_haszero([2, 4, 6]) == False\nassert op_neg_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_absval", "entry_point": "op_sortd_absval", "primitives": ["sortd", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each.", "solution": "def op_sortd_absval(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortd_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_absval([]) == []\nassert op_sortd_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sortd_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_absval([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_absval([10]) == [10]\nassert op_sortd_absval([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_absval([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_sortd_len", "entry_point": "op_sortd_len", "primitives": ["sortd", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return how many remain.", "solution": "def op_sortd_len(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return len(r)", "tests": "assert op_sortd_len([1, 2, 3, 4]) == 4\nassert op_sortd_len([]) == 0\nassert op_sortd_len([-2, -1, 0, 1, 2]) == 5\nassert op_sortd_len([5, 5, 5]) == 3\nassert op_sortd_len([3, 1, 2]) == 3\nassert op_sortd_len([10]) == 1\nassert op_sortd_len([2, 4, 6]) == 3\nassert op_sortd_len([-7, 12, -7]) == 3"}
{"id": "op_negate_gt5", "entry_point": "op_negate_gt5", "primitives": ["negate", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five.", "solution": "def op_negate_gt5(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_negate_gt5([1, 2, 3, 4]) == []\nassert op_negate_gt5([]) == []\nassert op_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_negate_gt5([5, 5, 5]) == []\nassert op_negate_gt5([3, 1, 2]) == []\nassert op_negate_gt5([10]) == []\nassert op_negate_gt5([2, 4, 6]) == []\nassert op_negate_gt5([-7, 12, -7]) == [7, 7]"}
{"id": "op_upper_sortalpha", "entry_point": "op_upper_sortalpha", "primitives": ["upper", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort alphabetically.", "solution": "def op_upper_sortalpha(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_upper_sortalpha(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_sortalpha([]) == []\nassert op_upper_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  A ', 'BC', 'BC']\nassert op_upper_sortalpha(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_sortalpha(['x']) == ['X']\nassert op_upper_sortalpha(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_sortabs_firsteven", "entry_point": "op_sortabs_firsteven", "primitives": ["sortabs", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return the first even value (0 if none).", "solution": "def op_sortabs_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_sortabs_firsteven([]) == 0\nassert op_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_firsteven([5, 5, 5]) == 0\nassert op_sortabs_firsteven([3, 1, 2]) == 2\nassert op_sortabs_firsteven([10]) == 10\nassert op_sortabs_firsteven([2, 4, 6]) == 2\nassert op_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_pos_sum", "entry_point": "op_pos_sum", "primitives": ["pos", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return their sum.", "solution": "def op_pos_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return sum(r)", "tests": "assert op_pos_sum([1, 2, 3, 4]) == 10\nassert op_pos_sum([]) == 0\nassert op_pos_sum([-2, -1, 0, 1, 2]) == 3\nassert op_pos_sum([5, 5, 5]) == 15\nassert op_pos_sum([3, 1, 2]) == 6\nassert op_pos_sum([10]) == 10\nassert op_pos_sum([2, 4, 6]) == 12\nassert op_pos_sum([-7, 12, -7]) == 12"}
{"id": "op_double_max", "entry_point": "op_double_max", "primitives": ["double", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return the maximum (0 if empty).", "solution": "def op_double_max(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_double_max([1, 2, 3, 4]) == 8\nassert op_double_max([]) == 0\nassert op_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_double_max([5, 5, 5]) == 10\nassert op_double_max([3, 1, 2]) == 6\nassert op_double_max([10]) == 20\nassert op_double_max([2, 4, 6]) == 12\nassert op_double_max([-7, 12, -7]) == 24"}
{"id": "op_dropfirst_inc", "entry_point": "op_dropfirst_inc", "primitives": ["dropfirst", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add one to each.", "solution": "def op_dropfirst_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_dropfirst_inc([]) == []\nassert op_dropfirst_inc([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_dropfirst_inc([5, 5, 5]) == [6, 6]\nassert op_dropfirst_inc([3, 1, 2]) == [2, 3]\nassert op_dropfirst_inc([10]) == []\nassert op_dropfirst_inc([2, 4, 6]) == [5, 7]\nassert op_dropfirst_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_dropzeros_sortd", "entry_point": "op_dropzeros_sortd", "primitives": ["dropzeros", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending.", "solution": "def op_dropzeros_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_sortd([]) == []\nassert op_dropzeros_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_sortd([10]) == [10]\nassert op_dropzeros_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_dropfirst_sorta", "entry_point": "op_dropfirst_sorta", "primitives": ["dropfirst", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending.", "solution": "def op_dropfirst_sorta(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    return r", "tests": "assert op_dropfirst_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sorta([]) == []\nassert op_dropfirst_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_sorta([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sorta([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sorta([10]) == []\nassert op_dropfirst_sorta([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_upper_uniqs", "entry_point": "op_upper_uniqs", "primitives": ["upper", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop duplicate strings keeping the first.", "solution": "def op_upper_uniqs(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_upper_uniqs(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_uniqs([]) == []\nassert op_upper_uniqs(['  a ', '', 'BC', 'bc']) == ['  A ', '', 'BC']\nassert op_upper_uniqs(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_upper_uniqs(['x']) == ['X']\nassert op_upper_uniqs(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_pos_max", "entry_point": "op_pos_max", "primitives": ["pos", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_pos_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_pos_max([1, 2, 3, 4]) == 4\nassert op_pos_max([]) == 0\nassert op_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_pos_max([5, 5, 5]) == 5\nassert op_pos_max([3, 1, 2]) == 3\nassert op_pos_max([10]) == 10\nassert op_pos_max([2, 4, 6]) == 6\nassert op_pos_max([-7, 12, -7]) == 12"}
{"id": "op_ages_sorta", "entry_point": "op_ages_sorta", "primitives": ["ages", "sorta"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending.", "solution": "def op_ages_sorta(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    return r", "tests": "assert op_ages_sorta([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sorta([]) == []\nassert op_ages_sorta([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sorta([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_padto3_max", "entry_point": "op_padto3_max", "primitives": ["padto3", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_padto3_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_padto3_max([1, 2, 3, 4]) == 4\nassert op_padto3_max([]) == 0\nassert op_padto3_max([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_max([5, 5, 5]) == 5\nassert op_padto3_max([3, 1, 2]) == 3\nassert op_padto3_max([10]) == 10\nassert op_padto3_max([2, 4, 6]) == 6\nassert op_padto3_max([-7, 12, -7]) == 12"}
{"id": "op_evens_dropfirst", "entry_point": "op_evens_dropfirst", "primitives": ["evens", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element.", "solution": "def op_evens_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_evens_dropfirst([1, 2, 3, 4]) == [4]\nassert op_evens_dropfirst([]) == []\nassert op_evens_dropfirst([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropfirst([5, 5, 5]) == []\nassert op_evens_dropfirst([3, 1, 2]) == []\nassert op_evens_dropfirst([10]) == []\nassert op_evens_dropfirst([2, 4, 6]) == [4, 6]\nassert op_evens_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sorta_dec", "entry_point": "op_sorta_dec", "primitives": ["sorta", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each.", "solution": "def op_sorta_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sorta_dec([]) == []\nassert op_sorta_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_sorta_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sorta_dec([10]) == [9]\nassert op_sorta_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sorta_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_beforezero_odds", "entry_point": "op_beforezero_odds", "primitives": ["beforezero", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the odd numbers.", "solution": "def op_beforezero_odds(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_beforezero_odds([1, 2, 3, 4]) == [1, 3]\nassert op_beforezero_odds([]) == []\nassert op_beforezero_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_odds([3, 1, 2]) == [3, 1]\nassert op_beforezero_odds([10]) == []\nassert op_beforezero_odds([2, 4, 6]) == []\nassert op_beforezero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_allpos", "entry_point": "op_square_allpos", "primitives": ["square", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return whether all values are positive.", "solution": "def op_square_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_square_allpos([1, 2, 3, 4]) == True\nassert op_square_allpos([]) == True\nassert op_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_square_allpos([5, 5, 5]) == True\nassert op_square_allpos([3, 1, 2]) == True\nassert op_square_allpos([10]) == True\nassert op_square_allpos([2, 4, 6]) == True\nassert op_square_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_haszero", "entry_point": "op_inc_haszero", "primitives": ["inc", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return whether the list contains a zero.", "solution": "def op_inc_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_inc_haszero([1, 2, 3, 4]) == False\nassert op_inc_haszero([]) == False\nassert op_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_inc_haszero([5, 5, 5]) == False\nassert op_inc_haszero([3, 1, 2]) == False\nassert op_inc_haszero([10]) == False\nassert op_inc_haszero([2, 4, 6]) == False\nassert op_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_prefixup_dropshort", "entry_point": "op_prefixup_dropshort", "primitives": ["prefixup", "dropshort"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop strings shorter than three characters.", "solution": "def op_prefixup_dropshort(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_prefixup_dropshort(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_dropshort([]) == []\nassert op_prefixup_dropshort(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_prefixup_dropshort(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup_dropshort(['x']) == []\nassert op_prefixup_dropshort(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_double_neg", "entry_point": "op_double_neg", "primitives": ["double", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the negative numbers.", "solution": "def op_double_neg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_double_neg([1, 2, 3, 4]) == []\nassert op_double_neg([]) == []\nassert op_double_neg([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_neg([5, 5, 5]) == []\nassert op_double_neg([3, 1, 2]) == []\nassert op_double_neg([10]) == []\nassert op_double_neg([2, 4, 6]) == []\nassert op_double_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_beforezero_negate", "entry_point": "op_beforezero_negate", "primitives": ["beforezero", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each.", "solution": "def op_beforezero_negate(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_beforezero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_beforezero_negate([]) == []\nassert op_beforezero_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_beforezero_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_beforezero_negate([10]) == [-10]\nassert op_beforezero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_beforezero_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_first3_evens", "entry_point": "op_first3_evens", "primitives": ["first3", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the even numbers.", "solution": "def op_first3_evens(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_first3_evens([1, 2, 3, 4]) == [2]\nassert op_first3_evens([]) == []\nassert op_first3_evens([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_first3_evens([5, 5, 5]) == []\nassert op_first3_evens([3, 1, 2]) == [2]\nassert op_first3_evens([10]) == [10]\nassert op_first3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_first3_evens([-7, 12, -7]) == [12]"}
{"id": "op_last3_haszero", "entry_point": "op_last3_haszero", "primitives": ["last3", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return whether the list contains a zero.", "solution": "def op_last3_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    return 0 in r", "tests": "assert op_last3_haszero([1, 2, 3, 4]) == False\nassert op_last3_haszero([]) == False\nassert op_last3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_last3_haszero([5, 5, 5]) == False\nassert op_last3_haszero([3, 1, 2]) == False\nassert op_last3_haszero([10]) == False\nassert op_last3_haszero([2, 4, 6]) == False\nassert op_last3_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_uniq", "entry_point": "op_odds_uniq", "primitives": ["odds", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_odds_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_odds_uniq([]) == []\nassert op_odds_uniq([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_uniq([5, 5, 5]) == [5]\nassert op_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_odds_uniq([10]) == []\nassert op_odds_uniq([2, 4, 6]) == []\nassert op_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_lower_sortlen", "entry_point": "op_lower_sortlen", "primitives": ["lower", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort by length, shortest first.", "solution": "def op_lower_sortlen(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_lower_sortlen(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortlen([]) == []\nassert op_lower_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'bc', 'bc', '  a ']\nassert op_lower_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_sortlen(['x']) == ['x']\nassert op_lower_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_dropwhileneg_haszero", "entry_point": "op_dropwhileneg_haszero", "primitives": ["dropwhileneg", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_haszero([]) == False\nassert op_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_haszero([10]) == False\nassert op_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_oremptyzero", "entry_point": "op_takewhilepos_oremptyzero", "primitives": ["takewhilepos", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero.", "solution": "def op_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_takewhilepos_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_oremptyzero([]) == [0]\nassert op_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_oremptyzero([10]) == [10]\nassert op_takewhilepos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_clamp10_neg", "entry_point": "op_clamp10_neg", "primitives": ["clamp10", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers.", "solution": "def op_clamp10_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_neg([1, 2, 3, 4]) == []\nassert op_clamp10_neg([]) == []\nassert op_clamp10_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_neg([5, 5, 5]) == []\nassert op_clamp10_neg([3, 1, 2]) == []\nassert op_clamp10_neg([10]) == []\nassert op_clamp10_neg([2, 4, 6]) == []\nassert op_clamp10_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_add10", "entry_point": "op_clamp10_add10", "primitives": ["clamp10", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each.", "solution": "def op_clamp10_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_add10([]) == []\nassert op_clamp10_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_clamp10_add10([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_add10([3, 1, 2]) == [13, 11, 12]\nassert op_clamp10_add10([10]) == [20]\nassert op_clamp10_add10([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_add10([-7, 12, -7]) == [3, 20, 3]"}
{"id": "op_first3_dropfirst", "entry_point": "op_first3_dropfirst", "primitives": ["first3", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element.", "solution": "def op_first3_dropfirst(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    return r", "tests": "assert op_first3_dropfirst([1, 2, 3, 4]) == [2, 3]\nassert op_first3_dropfirst([]) == []\nassert op_first3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_first3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_first3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_first3_dropfirst([10]) == []\nassert op_first3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_first3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_sorta", "entry_point": "op_padto3_sorta", "primitives": ["padto3", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending.", "solution": "def op_padto3_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sorta([]) == [0, 0, 0]\nassert op_padto3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sorta([10]) == [0, 0, 10]\nassert op_padto3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dec_padto3", "entry_point": "op_dec_padto3", "primitives": ["dec", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_dec_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_padto3([]) == [0, 0, 0]\nassert op_dec_padto3([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_padto3([10]) == [9, 0, 0]\nassert op_dec_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_padto3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_sortabs_clamp10", "entry_point": "op_sortabs_clamp10", "primitives": ["sortabs", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10.", "solution": "def op_sortabs_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_clamp10([]) == []\nassert op_sortabs_clamp10([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_clamp10([10]) == [10]\nassert op_sortabs_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_takewhilepos_firsteven", "entry_point": "op_takewhilepos_firsteven", "primitives": ["takewhilepos", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return the first even value (0 if none).", "solution": "def op_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_firsteven([]) == 0\nassert op_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_takewhilepos_firsteven([10]) == 10\nassert op_takewhilepos_firsteven([2, 4, 6]) == 2\nassert op_takewhilepos_firsteven([-7, 12, -7]) == 0"}
{"id": "op_square_len", "entry_point": "op_square_len", "primitives": ["square", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return how many remain.", "solution": "def op_square_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_square_len([1, 2, 3, 4]) == 4\nassert op_square_len([]) == 0\nassert op_square_len([-2, -1, 0, 1, 2]) == 5\nassert op_square_len([5, 5, 5]) == 3\nassert op_square_len([3, 1, 2]) == 3\nassert op_square_len([10]) == 1\nassert op_square_len([2, 4, 6]) == 3\nassert op_square_len([-7, 12, -7]) == 3"}
{"id": "op_rev_pos", "entry_point": "op_rev_pos", "primitives": ["rev", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the positive numbers.", "solution": "def op_rev_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_pos([]) == []\nassert op_rev_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_pos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_pos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_pos([10]) == [10]\nassert op_rev_pos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_pos([-7, 12, -7]) == [12]"}
{"id": "op_evens_anyeven", "entry_point": "op_evens_anyeven", "primitives": ["evens", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return whether any value is even.", "solution": "def op_evens_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_anyeven([1, 2, 3, 4]) == True\nassert op_evens_anyeven([]) == False\nassert op_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_evens_anyeven([5, 5, 5]) == False\nassert op_evens_anyeven([3, 1, 2]) == True\nassert op_evens_anyeven([10]) == True\nassert op_evens_anyeven([2, 4, 6]) == True\nassert op_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_odds_padto3", "entry_point": "op_odds_padto3", "primitives": ["odds", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements.", "solution": "def op_odds_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_odds_padto3([1, 2, 3, 4]) == [1, 3, 0]\nassert op_odds_padto3([]) == [0, 0, 0]\nassert op_odds_padto3([-2, -1, 0, 1, 2]) == [-1, 1, 0]\nassert op_odds_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_padto3([3, 1, 2]) == [3, 1, 0]\nassert op_odds_padto3([10]) == [0, 0, 0]\nassert op_odds_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_odds_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_trimends_pos", "entry_point": "op_trimends_pos", "primitives": ["trimends", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers.", "solution": "def op_trimends_pos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_trimends_pos([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_pos([]) == []\nassert op_trimends_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_pos([5, 5, 5]) == [5]\nassert op_trimends_pos([3, 1, 2]) == [1]\nassert op_trimends_pos([10]) == []\nassert op_trimends_pos([2, 4, 6]) == [4]\nassert op_trimends_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_evens", "entry_point": "op_dropwhileneg_evens", "primitives": ["dropwhileneg", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers.", "solution": "def op_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropwhileneg_evens([]) == []\nassert op_dropwhileneg_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropwhileneg_evens([5, 5, 5]) == []\nassert op_dropwhileneg_evens([3, 1, 2]) == [2]\nassert op_dropwhileneg_evens([10]) == [10]\nassert op_dropwhileneg_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_evens([-7, 12, -7]) == [12]"}
{"id": "op_neg_dropwhileneg", "entry_point": "op_neg_dropwhileneg", "primitives": ["neg", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values.", "solution": "def op_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_dropwhileneg([]) == []\nassert op_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropwhileneg([5, 5, 5]) == []\nassert op_neg_dropwhileneg([3, 1, 2]) == []\nassert op_neg_dropwhileneg([10]) == []\nassert op_neg_dropwhileneg([2, 4, 6]) == []\nassert op_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dropfirst_allpos", "entry_point": "op_dropfirst_allpos", "primitives": ["dropfirst", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return whether all values are positive.", "solution": "def op_dropfirst_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_allpos([]) == True\nassert op_dropfirst_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_allpos([5, 5, 5]) == True\nassert op_dropfirst_allpos([3, 1, 2]) == True\nassert op_dropfirst_allpos([10]) == True\nassert op_dropfirst_allpos([2, 4, 6]) == True\nassert op_dropfirst_allpos([-7, 12, -7]) == False"}
{"id": "op_double_len", "entry_point": "op_double_len", "primitives": ["double", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return how many remain.", "solution": "def op_double_len(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_double_len([1, 2, 3, 4]) == 4\nassert op_double_len([]) == 0\nassert op_double_len([-2, -1, 0, 1, 2]) == 5\nassert op_double_len([5, 5, 5]) == 3\nassert op_double_len([3, 1, 2]) == 3\nassert op_double_len([10]) == 1\nassert op_double_len([2, 4, 6]) == 3\nassert op_double_len([-7, 12, -7]) == 3"}
{"id": "op_strip_uniqs", "entry_point": "op_strip_uniqs", "primitives": ["strip", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first.", "solution": "def op_strip_uniqs(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_strip_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_uniqs([]) == []\nassert op_strip_uniqs(['  a ', '', 'BC', 'bc']) == ['a', '', 'BC', 'bc']\nassert op_strip_uniqs(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_strip_uniqs(['x']) == ['x']\nassert op_strip_uniqs(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_uniq_add10", "entry_point": "op_uniq_add10", "primitives": ["uniq", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_uniq_add10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_uniq_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10([]) == []\nassert op_uniq_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10([5, 5, 5]) == [15]\nassert op_uniq_add10([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10([10]) == [20]\nassert op_uniq_add10([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropzeros_square", "entry_point": "op_dropzeros_square", "primitives": ["dropzeros", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each.", "solution": "def op_dropzeros_square(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropzeros_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropzeros_square([]) == []\nassert op_dropzeros_square([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_dropzeros_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropzeros_square([10]) == [100]\nassert op_dropzeros_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sortage_names", "entry_point": "op_sortage_names", "primitives": ["sortage", "names"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the names.", "solution": "def op_sortage_names(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['name'] for d in r]\n    return r", "tests": "assert op_sortage_names([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Bo', 'Ada']\nassert op_sortage_names([]) == []\nassert op_sortage_names([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['El', 'Cy', 'Dee']\nassert op_sortage_names([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_neg_sum", "entry_point": "op_neg_sum", "primitives": ["neg", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return their sum.", "solution": "def op_neg_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_neg_sum([1, 2, 3, 4]) == 0\nassert op_neg_sum([]) == 0\nassert op_neg_sum([-2, -1, 0, 1, 2]) == -3\nassert op_neg_sum([5, 5, 5]) == 0\nassert op_neg_sum([3, 1, 2]) == 0\nassert op_neg_sum([10]) == 0\nassert op_neg_sum([2, 4, 6]) == 0\nassert op_neg_sum([-7, 12, -7]) == -14"}
{"id": "op_firstchar_lower", "entry_point": "op_firstchar_lower", "primitives": ["firstchar", "lower"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then lowercase each string.", "solution": "def op_firstchar_lower(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_firstchar_lower(['Hello', 'world']) == ['h', 'w']\nassert op_firstchar_lower([]) == []\nassert op_firstchar_lower(['  a ', '', 'BC', 'bc']) == [' ', 'b', 'b']\nassert op_firstchar_lower(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_firstchar_lower(['x']) == ['x']\nassert op_firstchar_lower(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_pos_oremptyzero", "entry_point": "op_pos_oremptyzero", "primitives": ["pos", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero.", "solution": "def op_pos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_pos_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_oremptyzero([]) == [0]\nassert op_pos_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_pos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_pos_oremptyzero([10]) == [10]\nassert op_pos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_names_dropshort", "entry_point": "op_names_dropshort", "primitives": ["names", "dropshort"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop strings shorter than three characters.", "solution": "def op_names_dropshort(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_names_dropshort([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada']\nassert op_names_dropshort([]) == []\nassert op_names_dropshort([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Dee']\nassert op_names_dropshort([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sorta_oremptyzero", "entry_point": "op_sorta_oremptyzero", "primitives": ["sorta", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero.", "solution": "def op_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_oremptyzero([]) == [0]\nassert op_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_oremptyzero([10]) == [10]\nassert op_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_gt5_allpos", "entry_point": "op_gt5_allpos", "primitives": ["gt5", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return whether all values are positive.", "solution": "def op_gt5_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_allpos([1, 2, 3, 4]) == True\nassert op_gt5_allpos([]) == True\nassert op_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_allpos([5, 5, 5]) == True\nassert op_gt5_allpos([3, 1, 2]) == True\nassert op_gt5_allpos([10]) == True\nassert op_gt5_allpos([2, 4, 6]) == True\nassert op_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_sorta", "entry_point": "op_inc_sorta", "primitives": ["inc", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending.", "solution": "def op_inc_sorta(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_inc_sorta([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sorta([]) == []\nassert op_inc_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_sorta([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sorta([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sorta([10]) == [11]\nassert op_inc_sorta([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_uniq_absval", "entry_point": "op_uniq_absval", "primitives": ["uniq", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_uniq_absval(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_absval([]) == []\nassert op_uniq_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_uniq_absval([5, 5, 5]) == [5]\nassert op_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_absval([10]) == [10]\nassert op_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_dec_max", "entry_point": "op_dec_max", "primitives": ["dec", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return the maximum (0 if empty).", "solution": "def op_dec_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_dec_max([1, 2, 3, 4]) == 3\nassert op_dec_max([]) == 0\nassert op_dec_max([-2, -1, 0, 1, 2]) == 1\nassert op_dec_max([5, 5, 5]) == 4\nassert op_dec_max([3, 1, 2]) == 2\nassert op_dec_max([10]) == 9\nassert op_dec_max([2, 4, 6]) == 5\nassert op_dec_max([-7, 12, -7]) == 11"}
{"id": "op_dropzeros_allpos", "entry_point": "op_dropzeros_allpos", "primitives": ["dropzeros", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return whether all values are positive.", "solution": "def op_dropzeros_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_dropzeros_allpos([]) == True\nassert op_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_allpos([5, 5, 5]) == True\nassert op_dropzeros_allpos([3, 1, 2]) == True\nassert op_dropzeros_allpos([10]) == True\nassert op_dropzeros_allpos([2, 4, 6]) == True\nassert op_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_ages_beforezero", "entry_point": "op_ages_beforezero", "primitives": ["ages", "beforezero"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero.", "solution": "def op_ages_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_beforezero([]) == []\nassert op_ages_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_beforezero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dec_evens", "entry_point": "op_dec_evens", "primitives": ["dec", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers.", "solution": "def op_dec_evens(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dec_evens([1, 2, 3, 4]) == [0, 2]\nassert op_dec_evens([]) == []\nassert op_dec_evens([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_dec_evens([5, 5, 5]) == [4, 4, 4]\nassert op_dec_evens([3, 1, 2]) == [2, 0]\nassert op_dec_evens([10]) == []\nassert op_dec_evens([2, 4, 6]) == []\nassert op_dec_evens([-7, 12, -7]) == [-8, -8]"}
{"id": "op_uniqs_dropshort", "entry_point": "op_uniqs_dropshort", "primitives": ["uniqs", "dropshort"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop strings shorter than three characters.", "solution": "def op_uniqs_dropshort(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_uniqs_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_dropshort([]) == []\nassert op_uniqs_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_uniqs_dropshort(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_dropshort(['x']) == []\nassert op_uniqs_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_padto3_dec", "entry_point": "op_padto3_dec", "primitives": ["padto3", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each.", "solution": "def op_padto3_dec(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_padto3_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_padto3_dec([]) == [-1, -1, -1]\nassert op_padto3_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_padto3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_padto3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_padto3_dec([10]) == [9, -1, -1]\nassert op_padto3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_padto3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_nonempty_strip", "entry_point": "op_nonempty_strip", "primitives": ["nonempty", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then trim whitespace from each.", "solution": "def op_nonempty_strip(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_nonempty_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_strip([]) == []\nassert op_nonempty_strip(['  a ', '', 'BC', 'bc']) == ['a', 'BC', 'bc']\nassert op_nonempty_strip(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_nonempty_strip(['x']) == ['x']\nassert op_nonempty_strip(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_uniqs_lower", "entry_point": "op_uniqs_lower", "primitives": ["uniqs", "lower"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then lowercase each string.", "solution": "def op_uniqs_lower(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_uniqs_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_uniqs_lower([]) == []\nassert op_uniqs_lower(['  a ', '', 'BC', 'bc']) == ['  a ', '', 'bc', 'bc']\nassert op_uniqs_lower(['one', 'one', 'Two']) == ['one', 'two']\nassert op_uniqs_lower(['x']) == ['x']\nassert op_uniqs_lower(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_add10_len", "entry_point": "op_add10_len", "primitives": ["add10", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return how many remain.", "solution": "def op_add10_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_add10_len([1, 2, 3, 4]) == 4\nassert op_add10_len([]) == 0\nassert op_add10_len([-2, -1, 0, 1, 2]) == 5\nassert op_add10_len([5, 5, 5]) == 3\nassert op_add10_len([3, 1, 2]) == 3\nassert op_add10_len([10]) == 1\nassert op_add10_len([2, 4, 6]) == 3\nassert op_add10_len([-7, 12, -7]) == 3"}
{"id": "op_padto3_last3", "entry_point": "op_padto3_last3", "primitives": ["padto3", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_padto3_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_last3([]) == [0, 0, 0]\nassert op_padto3_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_last3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_last3([10]) == [10, 0, 0]\nassert op_padto3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_square_haszero", "entry_point": "op_square_haszero", "primitives": ["square", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return whether the list contains a zero.", "solution": "def op_square_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_square_haszero([1, 2, 3, 4]) == False\nassert op_square_haszero([]) == False\nassert op_square_haszero([-2, -1, 0, 1, 2]) == True\nassert op_square_haszero([5, 5, 5]) == False\nassert op_square_haszero([3, 1, 2]) == False\nassert op_square_haszero([10]) == False\nassert op_square_haszero([2, 4, 6]) == False\nassert op_square_haszero([-7, 12, -7]) == False"}
{"id": "op_square_sorta", "entry_point": "op_square_sorta", "primitives": ["square", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending.", "solution": "def op_square_sorta(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_square_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sorta([]) == []\nassert op_square_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_square_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_square_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_square_sorta([10]) == [100]\nassert op_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_square_sorta([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_double_div3", "entry_point": "op_double_div3", "primitives": ["double", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three.", "solution": "def op_double_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_div3([1, 2, 3, 4]) == [6]\nassert op_double_div3([]) == []\nassert op_double_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_div3([5, 5, 5]) == []\nassert op_double_div3([3, 1, 2]) == [6]\nassert op_double_div3([10]) == []\nassert op_double_div3([2, 4, 6]) == [12]\nassert op_double_div3([-7, 12, -7]) == [24]"}
{"id": "op_first3_sortd", "entry_point": "op_first3_sortd", "primitives": ["first3", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending.", "solution": "def op_first3_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_sortd([]) == []\nassert op_first3_sortd([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_first3_sortd([10]) == [10]\nassert op_first3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_first3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sorta_absval", "entry_point": "op_sorta_absval", "primitives": ["sorta", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each.", "solution": "def op_sorta_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_absval([]) == []\nassert op_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_absval([10]) == [10]\nassert op_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_absval_haszero", "entry_point": "op_absval_haszero", "primitives": ["absval", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_absval_haszero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_absval_haszero([1, 2, 3, 4]) == False\nassert op_absval_haszero([]) == False\nassert op_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_absval_haszero([5, 5, 5]) == False\nassert op_absval_haszero([3, 1, 2]) == False\nassert op_absval_haszero([10]) == False\nassert op_absval_haszero([2, 4, 6]) == False\nassert op_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_evens", "entry_point": "op_clamp10_evens", "primitives": ["clamp10", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers.", "solution": "def op_clamp10_evens(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_clamp10_evens([1, 2, 3, 4]) == [2, 4]\nassert op_clamp10_evens([]) == []\nassert op_clamp10_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_clamp10_evens([5, 5, 5]) == []\nassert op_clamp10_evens([3, 1, 2]) == [2]\nassert op_clamp10_evens([10]) == [10]\nassert op_clamp10_evens([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_evens([-7, 12, -7]) == [10]"}
{"id": "op_absval_gt5", "entry_point": "op_absval_gt5", "primitives": ["absval", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five.", "solution": "def op_absval_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_gt5([1, 2, 3, 4]) == []\nassert op_absval_gt5([]) == []\nassert op_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5([5, 5, 5]) == []\nassert op_absval_gt5([3, 1, 2]) == []\nassert op_absval_gt5([10]) == [10]\nassert op_absval_gt5([2, 4, 6]) == [6]\nassert op_absval_gt5([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_dropfirst_absval", "entry_point": "op_dropfirst_absval", "primitives": ["dropfirst", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each.", "solution": "def op_dropfirst_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_absval([]) == []\nassert op_dropfirst_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_dropfirst_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_absval([10]) == []\nassert op_dropfirst_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_uniq_double", "entry_point": "op_uniq_double", "primitives": ["uniq", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each.", "solution": "def op_uniq_double(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_uniq_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_double([]) == []\nassert op_uniq_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_uniq_double([5, 5, 5]) == [10]\nassert op_uniq_double([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_double([10]) == [20]\nassert op_uniq_double([2, 4, 6]) == [4, 8, 12]\nassert op_uniq_double([-7, 12, -7]) == [-14, 24]"}
{"id": "op_beforezero_last3", "entry_point": "op_beforezero_last3", "primitives": ["beforezero", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three.", "solution": "def op_beforezero_last3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_beforezero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_last3([]) == []\nassert op_beforezero_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_last3([10]) == [10]\nassert op_beforezero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_evens", "entry_point": "op_beforezero_evens", "primitives": ["beforezero", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers.", "solution": "def op_beforezero_evens(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_beforezero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_beforezero_evens([]) == []\nassert op_beforezero_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_evens([5, 5, 5]) == []\nassert op_beforezero_evens([3, 1, 2]) == [2]\nassert op_beforezero_evens([10]) == [10]\nassert op_beforezero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_evens([-7, 12, -7]) == [12]"}
{"id": "op_dec_allpos", "entry_point": "op_dec_allpos", "primitives": ["dec", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return whether all values are positive.", "solution": "def op_dec_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_allpos([1, 2, 3, 4]) == False\nassert op_dec_allpos([]) == True\nassert op_dec_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_allpos([5, 5, 5]) == True\nassert op_dec_allpos([3, 1, 2]) == False\nassert op_dec_allpos([10]) == True\nassert op_dec_allpos([2, 4, 6]) == True\nassert op_dec_allpos([-7, 12, -7]) == False"}
{"id": "op_beforezero_dropzeros", "entry_point": "op_beforezero_dropzeros", "primitives": ["beforezero", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros.", "solution": "def op_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_dropzeros([]) == []\nassert op_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_dropzeros([10]) == [10]\nassert op_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropwhileneg_allpos", "entry_point": "op_dropwhileneg_allpos", "primitives": ["dropwhileneg", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return whether all values are positive.", "solution": "def op_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_allpos([]) == True\nassert op_dropwhileneg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_allpos([10]) == True\nassert op_dropwhileneg_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_allpos([-7, 12, -7]) == False"}
{"id": "op_sortd_inc", "entry_point": "op_sortd_inc", "primitives": ["sortd", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each.", "solution": "def op_sortd_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_inc([]) == []\nassert op_sortd_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sortd_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_inc([10]) == [11]\nassert op_sortd_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_padto3_evens", "entry_point": "op_padto3_evens", "primitives": ["padto3", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers.", "solution": "def op_padto3_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_evens([]) == [0, 0, 0]\nassert op_padto3_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_padto3_evens([5, 5, 5]) == []\nassert op_padto3_evens([3, 1, 2]) == [2]\nassert op_padto3_evens([10]) == [10, 0, 0]\nassert op_padto3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_evens([-7, 12, -7]) == [12]"}
{"id": "op_padto3_sum", "entry_point": "op_padto3_sum", "primitives": ["padto3", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return their sum.", "solution": "def op_padto3_sum(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(r)", "tests": "assert op_padto3_sum([1, 2, 3, 4]) == 10\nassert op_padto3_sum([]) == 0\nassert op_padto3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_sum([5, 5, 5]) == 15\nassert op_padto3_sum([3, 1, 2]) == 6\nassert op_padto3_sum([10]) == 10\nassert op_padto3_sum([2, 4, 6]) == 12\nassert op_padto3_sum([-7, 12, -7]) == -2"}
{"id": "op_negate_inc", "entry_point": "op_negate_inc", "primitives": ["negate", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each.", "solution": "def op_negate_inc(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_negate_inc([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_negate_inc([]) == []\nassert op_negate_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_negate_inc([5, 5, 5]) == [-4, -4, -4]\nassert op_negate_inc([3, 1, 2]) == [-2, 0, -1]\nassert op_negate_inc([10]) == [-9]\nassert op_negate_inc([2, 4, 6]) == [-1, -3, -5]\nassert op_negate_inc([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_add10_prod", "entry_point": "op_add10_prod", "primitives": ["add10", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return their product.", "solution": "def op_add10_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_add10_prod([1, 2, 3, 4]) == 24024\nassert op_add10_prod([]) == 1\nassert op_add10_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_prod([5, 5, 5]) == 3375\nassert op_add10_prod([3, 1, 2]) == 1716\nassert op_add10_prod([10]) == 20\nassert op_add10_prod([2, 4, 6]) == 2688\nassert op_add10_prod([-7, 12, -7]) == 198"}
{"id": "op_beforezero_first3", "entry_point": "op_beforezero_first3", "primitives": ["beforezero", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three.", "solution": "def op_beforezero_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3([]) == []\nassert op_beforezero_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_first3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3([10]) == [10]\nassert op_beforezero_first3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_trimends_square", "entry_point": "op_trimends_square", "primitives": ["trimends", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each.", "solution": "def op_trimends_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_square([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_square([]) == []\nassert op_trimends_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_square([5, 5, 5]) == [25]\nassert op_trimends_square([3, 1, 2]) == [1]\nassert op_trimends_square([10]) == []\nassert op_trimends_square([2, 4, 6]) == [16]\nassert op_trimends_square([-7, 12, -7]) == [144]"}
{"id": "op_nonempty_dropshort", "entry_point": "op_nonempty_dropshort", "primitives": ["nonempty", "dropshort"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop strings shorter than three characters.", "solution": "def op_nonempty_dropshort(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_nonempty_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_dropshort([]) == []\nassert op_nonempty_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_nonempty_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_nonempty_dropshort(['x']) == []\nassert op_nonempty_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_gt5_inc", "entry_point": "op_gt5_inc", "primitives": ["gt5", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each.", "solution": "def op_gt5_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_gt5_inc([1, 2, 3, 4]) == []\nassert op_gt5_inc([]) == []\nassert op_gt5_inc([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc([5, 5, 5]) == []\nassert op_gt5_inc([3, 1, 2]) == []\nassert op_gt5_inc([10]) == [11]\nassert op_gt5_inc([2, 4, 6]) == [7]\nassert op_gt5_inc([-7, 12, -7]) == [13]"}
{"id": "op_odds_double", "entry_point": "op_odds_double", "primitives": ["odds", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each.", "solution": "def op_odds_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_double([1, 2, 3, 4]) == [2, 6]\nassert op_odds_double([]) == []\nassert op_odds_double([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_odds_double([5, 5, 5]) == [10, 10, 10]\nassert op_odds_double([3, 1, 2]) == [6, 2]\nassert op_odds_double([10]) == []\nassert op_odds_double([2, 4, 6]) == []\nassert op_odds_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_padto3_first3", "entry_point": "op_padto3_first3", "primitives": ["padto3", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three.", "solution": "def op_padto3_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return r", "tests": "assert op_padto3_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_first3([]) == [0, 0, 0]\nassert op_padto3_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_padto3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_first3([10]) == [10, 0, 0]\nassert op_padto3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_pos_counteven", "entry_point": "op_pos_counteven", "primitives": ["pos", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return how many values are even.", "solution": "def op_pos_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_counteven([1, 2, 3, 4]) == 2\nassert op_pos_counteven([]) == 0\nassert op_pos_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_pos_counteven([5, 5, 5]) == 0\nassert op_pos_counteven([3, 1, 2]) == 1\nassert op_pos_counteven([10]) == 1\nassert op_pos_counteven([2, 4, 6]) == 3\nassert op_pos_counteven([-7, 12, -7]) == 1"}
{"id": "op_evens_max", "entry_point": "op_evens_max", "primitives": ["evens", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_evens_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_evens_max([1, 2, 3, 4]) == 4\nassert op_evens_max([]) == 0\nassert op_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_max([5, 5, 5]) == 0\nassert op_evens_max([3, 1, 2]) == 2\nassert op_evens_max([10]) == 10\nassert op_evens_max([2, 4, 6]) == 6\nassert op_evens_max([-7, 12, -7]) == 12"}
{"id": "op_double_firsteven", "entry_point": "op_double_firsteven", "primitives": ["double", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return the first even value (0 if none).", "solution": "def op_double_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_firsteven([1, 2, 3, 4]) == 2\nassert op_double_firsteven([]) == 0\nassert op_double_firsteven([-2, -1, 0, 1, 2]) == -4\nassert op_double_firsteven([5, 5, 5]) == 10\nassert op_double_firsteven([3, 1, 2]) == 6\nassert op_double_firsteven([10]) == 20\nassert op_double_firsteven([2, 4, 6]) == 4\nassert op_double_firsteven([-7, 12, -7]) == -14"}
{"id": "op_sorta_trimends", "entry_point": "op_sorta_trimends", "primitives": ["sorta", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements.", "solution": "def op_sorta_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_trimends([]) == []\nassert op_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sorta_trimends([5, 5, 5]) == [5]\nassert op_sorta_trimends([3, 1, 2]) == [2]\nassert op_sorta_trimends([10]) == []\nassert op_sorta_trimends([2, 4, 6]) == [4]\nassert op_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_nonempty_prefixup", "entry_point": "op_nonempty_prefixup", "primitives": ["nonempty", "prefixup"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then prefix each with a hash.", "solution": "def op_nonempty_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_nonempty_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_nonempty_prefixup([]) == []\nassert op_nonempty_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_nonempty_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_nonempty_prefixup(['x']) == ['#x']\nassert op_nonempty_prefixup(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_firstchar_anyempty", "entry_point": "op_firstchar_anyempty", "primitives": ["firstchar", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then return whether any string is empty.", "solution": "def op_firstchar_anyempty(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return any(s == '' for s in r)", "tests": "assert op_firstchar_anyempty(['Hello', 'world']) == False\nassert op_firstchar_anyempty([]) == False\nassert op_firstchar_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_firstchar_anyempty(['one', 'one', 'Two']) == False\nassert op_firstchar_anyempty(['x']) == False\nassert op_firstchar_anyempty(['abc', 'de', '']) == False"}
{"id": "op_clamp10_div3", "entry_point": "op_clamp10_div3", "primitives": ["clamp10", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep multiples of three.", "solution": "def op_clamp10_div3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_clamp10_div3([1, 2, 3, 4]) == [3]\nassert op_clamp10_div3([]) == []\nassert op_clamp10_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_clamp10_div3([5, 5, 5]) == []\nassert op_clamp10_div3([3, 1, 2]) == [3]\nassert op_clamp10_div3([10]) == []\nassert op_clamp10_div3([2, 4, 6]) == [6]\nassert op_clamp10_div3([-7, 12, -7]) == []"}
{"id": "op_dropfirst_neg", "entry_point": "op_dropfirst_neg", "primitives": ["dropfirst", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers.", "solution": "def op_dropfirst_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_neg([]) == []\nassert op_dropfirst_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg([5, 5, 5]) == []\nassert op_dropfirst_neg([3, 1, 2]) == []\nassert op_dropfirst_neg([10]) == []\nassert op_dropfirst_neg([2, 4, 6]) == []\nassert op_dropfirst_neg([-7, 12, -7]) == [-7]"}
{"id": "op_gt5_anyeven", "entry_point": "op_gt5_anyeven", "primitives": ["gt5", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return whether any value is even.", "solution": "def op_gt5_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_anyeven([]) == False\nassert op_gt5_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_anyeven([5, 5, 5]) == False\nassert op_gt5_anyeven([3, 1, 2]) == False\nassert op_gt5_anyeven([10]) == True\nassert op_gt5_anyeven([2, 4, 6]) == True\nassert op_gt5_anyeven([-7, 12, -7]) == True"}
{"id": "op_names_sortalpha", "entry_point": "op_names_sortalpha", "primitives": ["names", "sortalpha"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort alphabetically.", "solution": "def op_names_sortalpha(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r)\n    return r", "tests": "assert op_names_sortalpha([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_sortalpha([]) == []\nassert op_names_sortalpha([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_sortalpha([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_pos_div3", "entry_point": "op_pos_div3", "primitives": ["pos", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three.", "solution": "def op_pos_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_pos_div3([1, 2, 3, 4]) == [3]\nassert op_pos_div3([]) == []\nassert op_pos_div3([-2, -1, 0, 1, 2]) == []\nassert op_pos_div3([5, 5, 5]) == []\nassert op_pos_div3([3, 1, 2]) == [3]\nassert op_pos_div3([10]) == []\nassert op_pos_div3([2, 4, 6]) == [6]\nassert op_pos_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_negate", "entry_point": "op_dropfirst_negate", "primitives": ["dropfirst", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each.", "solution": "def op_dropfirst_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropfirst_negate([]) == []\nassert op_dropfirst_negate([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_dropfirst_negate([10]) == []\nassert op_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_pos_anyeven", "entry_point": "op_pos_anyeven", "primitives": ["pos", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return whether any value is even.", "solution": "def op_pos_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_anyeven([1, 2, 3, 4]) == True\nassert op_pos_anyeven([]) == False\nassert op_pos_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_pos_anyeven([5, 5, 5]) == False\nassert op_pos_anyeven([3, 1, 2]) == True\nassert op_pos_anyeven([10]) == True\nassert op_pos_anyeven([2, 4, 6]) == True\nassert op_pos_anyeven([-7, 12, -7]) == True"}
{"id": "op_beforezero_square", "entry_point": "op_beforezero_square", "primitives": ["beforezero", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then square each.", "solution": "def op_beforezero_square(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_beforezero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_beforezero_square([]) == []\nassert op_beforezero_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_beforezero_square([5, 5, 5]) == [25, 25, 25]\nassert op_beforezero_square([3, 1, 2]) == [9, 1, 4]\nassert op_beforezero_square([10]) == [100]\nassert op_beforezero_square([2, 4, 6]) == [4, 16, 36]\nassert op_beforezero_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_uniq_allpos", "entry_point": "op_uniq_allpos", "primitives": ["uniq", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_uniq_allpos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_uniq_allpos([1, 2, 3, 4]) == True\nassert op_uniq_allpos([]) == True\nassert op_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_uniq_allpos([5, 5, 5]) == True\nassert op_uniq_allpos([3, 1, 2]) == True\nassert op_uniq_allpos([10]) == True\nassert op_uniq_allpos([2, 4, 6]) == True\nassert op_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_inc_sortd", "entry_point": "op_inc_sortd", "primitives": ["inc", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending.", "solution": "def op_inc_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_sortd([]) == []\nassert op_inc_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_inc_sortd([10]) == [11]\nassert op_inc_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_inc_sortd([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_oremptyzero_takewhilepos", "entry_point": "op_oremptyzero_takewhilepos", "primitives": ["oremptyzero", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take values while they are positive.", "solution": "def op_oremptyzero_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_takewhilepos([]) == []\nassert op_oremptyzero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_takewhilepos([10]) == [10]\nassert op_oremptyzero_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_square_min", "entry_point": "op_square_min", "primitives": ["square", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return the minimum (0 if empty).", "solution": "def op_square_min(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return min(r) if r else 0", "tests": "assert op_square_min([1, 2, 3, 4]) == 1\nassert op_square_min([]) == 0\nassert op_square_min([-2, -1, 0, 1, 2]) == 0\nassert op_square_min([5, 5, 5]) == 25\nassert op_square_min([3, 1, 2]) == 1\nassert op_square_min([10]) == 100\nassert op_square_min([2, 4, 6]) == 4\nassert op_square_min([-7, 12, -7]) == 49"}
{"id": "op_sortabs_last3", "entry_point": "op_sortabs_last3", "primitives": ["sortabs", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the last three.", "solution": "def op_sortabs_last3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_sortabs_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_last3([]) == []\nassert op_sortabs_last3([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_sortabs_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_last3([10]) == [10]\nassert op_sortabs_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_last3_first3", "entry_point": "op_last3_first3", "primitives": ["last3", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three.", "solution": "def op_last3_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_last3_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_first3([]) == []\nassert op_last3_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_last3_first3([10]) == [10]\nassert op_last3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_add10_inc", "entry_point": "op_add10_inc", "primitives": ["add10", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then add one to each.", "solution": "def op_add10_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_inc([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_add10_inc([]) == []\nassert op_add10_inc([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_add10_inc([5, 5, 5]) == [16, 16, 16]\nassert op_add10_inc([3, 1, 2]) == [14, 12, 13]\nassert op_add10_inc([10]) == [21]\nassert op_add10_inc([2, 4, 6]) == [13, 15, 17]\nassert op_add10_inc([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_sortabs_beforezero", "entry_point": "op_sortabs_beforezero", "primitives": ["sortabs", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero.", "solution": "def op_sortabs_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortabs_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_beforezero([]) == []\nassert op_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_beforezero([10]) == [10]\nassert op_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_square_takewhilepos", "entry_point": "op_square_takewhilepos", "primitives": ["square", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive.", "solution": "def op_square_takewhilepos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_square_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos([]) == []\nassert op_square_takewhilepos([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos([3, 1, 2]) == [9, 1, 4]\nassert op_square_takewhilepos([10]) == [100]\nassert op_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_oremptyzero_min", "entry_point": "op_oremptyzero_min", "primitives": ["oremptyzero", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_oremptyzero_min(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_oremptyzero_min([1, 2, 3, 4]) == 1\nassert op_oremptyzero_min([]) == 0\nassert op_oremptyzero_min([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_min([5, 5, 5]) == 5\nassert op_oremptyzero_min([3, 1, 2]) == 1\nassert op_oremptyzero_min([10]) == 10\nassert op_oremptyzero_min([2, 4, 6]) == 2\nassert op_oremptyzero_min([-7, 12, -7]) == -7"}
{"id": "op_div3_gt5", "entry_point": "op_div3_gt5", "primitives": ["div3", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five.", "solution": "def op_div3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_gt5([1, 2, 3, 4]) == []\nassert op_div3_gt5([]) == []\nassert op_div3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5([5, 5, 5]) == []\nassert op_div3_gt5([3, 1, 2]) == []\nassert op_div3_gt5([10]) == []\nassert op_div3_gt5([2, 4, 6]) == [6]\nassert op_div3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_nonempty_sortlen", "entry_point": "op_nonempty_sortlen", "primitives": ["nonempty", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort by length, shortest first.", "solution": "def op_nonempty_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_nonempty_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_sortlen([]) == []\nassert op_nonempty_sortlen(['  a ', '', 'BC', 'bc']) == ['BC', 'bc', '  a ']\nassert op_nonempty_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_nonempty_sortlen(['x']) == ['x']\nassert op_nonempty_sortlen(['abc', 'de', '']) == ['de', 'abc']"}
{"id": "op_neg_uniq", "entry_point": "op_neg_uniq", "primitives": ["neg", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_neg_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_neg_uniq([1, 2, 3, 4]) == []\nassert op_neg_uniq([]) == []\nassert op_neg_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_uniq([5, 5, 5]) == []\nassert op_neg_uniq([3, 1, 2]) == []\nassert op_neg_uniq([10]) == []\nassert op_neg_uniq([2, 4, 6]) == []\nassert op_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_beforezero_issorted", "entry_point": "op_beforezero_issorted", "primitives": ["beforezero", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return whether the list is sorted ascending.", "solution": "def op_beforezero_issorted(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r == sorted(r)", "tests": "assert op_beforezero_issorted([1, 2, 3, 4]) == True\nassert op_beforezero_issorted([]) == True\nassert op_beforezero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_issorted([5, 5, 5]) == True\nassert op_beforezero_issorted([3, 1, 2]) == False\nassert op_beforezero_issorted([10]) == True\nassert op_beforezero_issorted([2, 4, 6]) == True\nassert op_beforezero_issorted([-7, 12, -7]) == False"}
{"id": "op_sortd_alldistinct", "entry_point": "op_sortd_alldistinct", "primitives": ["sortd", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return whether all values are distinct.", "solution": "def op_sortd_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return len(r) == len(set(r))", "tests": "assert op_sortd_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_alldistinct([]) == True\nassert op_sortd_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_alldistinct([5, 5, 5]) == False\nassert op_sortd_alldistinct([3, 1, 2]) == True\nassert op_sortd_alldistinct([10]) == True\nassert op_sortd_alldistinct([2, 4, 6]) == True\nassert op_sortd_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sorta_min", "entry_point": "op_sorta_min", "primitives": ["sorta", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return the minimum (0 if empty).", "solution": "def op_sorta_min(xs):\n    r = list(xs)\n    r = sorted(r)\n    return min(r) if r else 0", "tests": "assert op_sorta_min([1, 2, 3, 4]) == 1\nassert op_sorta_min([]) == 0\nassert op_sorta_min([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_min([5, 5, 5]) == 5\nassert op_sorta_min([3, 1, 2]) == 1\nassert op_sorta_min([10]) == 10\nassert op_sorta_min([2, 4, 6]) == 2\nassert op_sorta_min([-7, 12, -7]) == -7"}
{"id": "op_add10_square", "entry_point": "op_add10_square", "primitives": ["add10", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each.", "solution": "def op_add10_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_square([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_square([]) == []\nassert op_add10_square([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_square([5, 5, 5]) == [225, 225, 225]\nassert op_add10_square([3, 1, 2]) == [169, 121, 144]\nassert op_add10_square([10]) == [400]\nassert op_add10_square([2, 4, 6]) == [144, 196, 256]\nassert op_add10_square([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_sorta_square", "entry_point": "op_sorta_square", "primitives": ["sorta", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each.", "solution": "def op_sorta_square(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sorta_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sorta_square([]) == []\nassert op_sorta_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sorta_square([5, 5, 5]) == [25, 25, 25]\nassert op_sorta_square([3, 1, 2]) == [1, 4, 9]\nassert op_sorta_square([10]) == [100]\nassert op_sorta_square([2, 4, 6]) == [4, 16, 36]\nassert op_sorta_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_clamp10_allpos", "entry_point": "op_clamp10_allpos", "primitives": ["clamp10", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return whether all values are positive.", "solution": "def op_clamp10_allpos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_clamp10_allpos([1, 2, 3, 4]) == True\nassert op_clamp10_allpos([]) == True\nassert op_clamp10_allpos([-2, -1, 0, 1, 2]) == False\nassert op_clamp10_allpos([5, 5, 5]) == True\nassert op_clamp10_allpos([3, 1, 2]) == True\nassert op_clamp10_allpos([10]) == True\nassert op_clamp10_allpos([2, 4, 6]) == True\nassert op_clamp10_allpos([-7, 12, -7]) == False"}
{"id": "op_uniq_pos", "entry_point": "op_uniq_pos", "primitives": ["uniq", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers.", "solution": "def op_uniq_pos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_uniq_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_pos([]) == []\nassert op_uniq_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_pos([5, 5, 5]) == [5]\nassert op_uniq_pos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_pos([10]) == [10]\nassert op_uniq_pos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_pos([-7, 12, -7]) == [12]"}
{"id": "op_double_uniq", "entry_point": "op_double_uniq", "primitives": ["double", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence.", "solution": "def op_double_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_uniq([]) == []\nassert op_double_uniq([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_uniq([5, 5, 5]) == [10]\nassert op_double_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_double_uniq([10]) == [20]\nassert op_double_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_double_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_last3_padto3", "entry_point": "op_last3_padto3", "primitives": ["last3", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_last3_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_padto3([]) == [0, 0, 0]\nassert op_last3_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_last3_padto3([10]) == [10, 0, 0]\nassert op_last3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_gt5_dropfirst", "entry_point": "op_gt5_dropfirst", "primitives": ["gt5", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element.", "solution": "def op_gt5_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst([]) == []\nassert op_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst([5, 5, 5]) == []\nassert op_gt5_dropfirst([3, 1, 2]) == []\nassert op_gt5_dropfirst([10]) == []\nassert op_gt5_dropfirst([2, 4, 6]) == []\nassert op_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_max", "entry_point": "op_add10_max", "primitives": ["add10", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return the maximum (0 if empty).", "solution": "def op_add10_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return max(r) if r else 0", "tests": "assert op_add10_max([1, 2, 3, 4]) == 14\nassert op_add10_max([]) == 0\nassert op_add10_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_max([5, 5, 5]) == 15\nassert op_add10_max([3, 1, 2]) == 13\nassert op_add10_max([10]) == 20\nassert op_add10_max([2, 4, 6]) == 16\nassert op_add10_max([-7, 12, -7]) == 22"}
{"id": "op_dropzeros_oremptyzero", "entry_point": "op_dropzeros_oremptyzero", "primitives": ["dropzeros", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero.", "solution": "def op_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_oremptyzero([]) == [0]\nassert op_dropzeros_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_oremptyzero([10]) == [10]\nassert op_dropzeros_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_first3_min", "entry_point": "op_first3_min", "primitives": ["first3", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return the minimum (0 if empty).", "solution": "def op_first3_min(xs):\n    r = list(xs)\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_first3_min([1, 2, 3, 4]) == 1\nassert op_first3_min([]) == 0\nassert op_first3_min([-2, -1, 0, 1, 2]) == -2\nassert op_first3_min([5, 5, 5]) == 5\nassert op_first3_min([3, 1, 2]) == 1\nassert op_first3_min([10]) == 10\nassert op_first3_min([2, 4, 6]) == 2\nassert op_first3_min([-7, 12, -7]) == -7"}
{"id": "op_trimends_max", "entry_point": "op_trimends_max", "primitives": ["trimends", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_trimends_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_trimends_max([1, 2, 3, 4]) == 3\nassert op_trimends_max([]) == 0\nassert op_trimends_max([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_max([5, 5, 5]) == 5\nassert op_trimends_max([3, 1, 2]) == 1\nassert op_trimends_max([10]) == 0\nassert op_trimends_max([2, 4, 6]) == 4\nassert op_trimends_max([-7, 12, -7]) == 12"}
{"id": "op_dec_dropfirst", "entry_point": "op_dec_dropfirst", "primitives": ["dec", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first element.", "solution": "def op_dec_dropfirst(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_dec_dropfirst([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropfirst([]) == []\nassert op_dec_dropfirst([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dec_dropfirst([5, 5, 5]) == [4, 4]\nassert op_dec_dropfirst([3, 1, 2]) == [0, 1]\nassert op_dec_dropfirst([10]) == []\nassert op_dec_dropfirst([2, 4, 6]) == [3, 5]\nassert op_dec_dropfirst([-7, 12, -7]) == [11, -8]"}
{"id": "op_last3_prod", "entry_point": "op_last3_prod", "primitives": ["last3", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return their product.", "solution": "def op_last3_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_last3_prod([1, 2, 3, 4]) == 24\nassert op_last3_prod([]) == 1\nassert op_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_last3_prod([5, 5, 5]) == 125\nassert op_last3_prod([3, 1, 2]) == 6\nassert op_last3_prod([10]) == 10\nassert op_last3_prod([2, 4, 6]) == 48\nassert op_last3_prod([-7, 12, -7]) == 588"}
{"id": "op_square_anyeven", "entry_point": "op_square_anyeven", "primitives": ["square", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return whether any value is even.", "solution": "def op_square_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_anyeven([1, 2, 3, 4]) == True\nassert op_square_anyeven([]) == False\nassert op_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_anyeven([5, 5, 5]) == False\nassert op_square_anyeven([3, 1, 2]) == True\nassert op_square_anyeven([10]) == True\nassert op_square_anyeven([2, 4, 6]) == True\nassert op_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_beforezero_inc", "entry_point": "op_beforezero_inc", "primitives": ["beforezero", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each.", "solution": "def op_beforezero_inc(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_beforezero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_beforezero_inc([]) == []\nassert op_beforezero_inc([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_beforezero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_beforezero_inc([10]) == [11]\nassert op_beforezero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_beforezero_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortabs_anyeven", "entry_point": "op_sortabs_anyeven", "primitives": ["sortabs", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return whether any value is even.", "solution": "def op_sortabs_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_anyeven([]) == False\nassert op_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_anyeven([5, 5, 5]) == False\nassert op_sortabs_anyeven([3, 1, 2]) == True\nassert op_sortabs_anyeven([10]) == True\nassert op_sortabs_anyeven([2, 4, 6]) == True\nassert op_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_sortabs", "entry_point": "op_last3_sortabs", "primitives": ["last3", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value.", "solution": "def op_last3_sortabs(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_last3_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortabs([]) == []\nassert op_last3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortabs([10]) == [10]\nassert op_last3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortalpha_joinc", "entry_point": "op_sortalpha_joinc", "primitives": ["sortalpha", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then join them with commas.", "solution": "def op_sortalpha_joinc(xs):\n    r = list(xs)\n    r = sorted(r)\n    return ','.join(r)", "tests": "assert op_sortalpha_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortalpha_joinc([]) == ''\nassert op_sortalpha_joinc(['  a ', '', 'BC', 'bc']) == ',  a ,BC,bc'\nassert op_sortalpha_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_sortalpha_joinc(['x']) == 'x'\nassert op_sortalpha_joinc(['abc', 'de', '']) == ',abc,de'"}
{"id": "op_odds_neg", "entry_point": "op_odds_neg", "primitives": ["odds", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers.", "solution": "def op_odds_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_neg([1, 2, 3, 4]) == []\nassert op_odds_neg([]) == []\nassert op_odds_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_neg([5, 5, 5]) == []\nassert op_odds_neg([3, 1, 2]) == []\nassert op_odds_neg([10]) == []\nassert op_odds_neg([2, 4, 6]) == []\nassert op_odds_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_beforezero", "entry_point": "op_padto3_beforezero", "primitives": ["padto3", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero.", "solution": "def op_padto3_beforezero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_padto3_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_beforezero([]) == []\nassert op_padto3_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_padto3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_beforezero([10]) == [10]\nassert op_padto3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_clamp10", "entry_point": "op_beforezero_clamp10", "primitives": ["beforezero", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10.", "solution": "def op_beforezero_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_clamp10([]) == []\nassert op_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_clamp10([10]) == [10]\nassert op_beforezero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_rev_double", "entry_point": "op_rev_double", "primitives": ["rev", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each.", "solution": "def op_rev_double(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double([]) == []\nassert op_rev_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double([10]) == [20]\nassert op_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_last3_sorta", "entry_point": "op_last3_sorta", "primitives": ["last3", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending.", "solution": "def op_last3_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sorta([]) == []\nassert op_last3_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sorta([10]) == [10]\nassert op_last3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_odds_dropwhileneg", "entry_point": "op_odds_dropwhileneg", "primitives": ["odds", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values.", "solution": "def op_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_odds_dropwhileneg([1, 2, 3, 4]) == [1, 3]\nassert op_odds_dropwhileneg([]) == []\nassert op_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_odds_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_odds_dropwhileneg([10]) == []\nassert op_odds_dropwhileneg([2, 4, 6]) == []\nassert op_odds_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_uniq_len", "entry_point": "op_uniq_len", "primitives": ["uniq", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_uniq_len(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_uniq_len([1, 2, 3, 4]) == 4\nassert op_uniq_len([]) == 0\nassert op_uniq_len([-2, -1, 0, 1, 2]) == 5\nassert op_uniq_len([5, 5, 5]) == 1\nassert op_uniq_len([3, 1, 2]) == 3\nassert op_uniq_len([10]) == 1\nassert op_uniq_len([2, 4, 6]) == 3\nassert op_uniq_len([-7, 12, -7]) == 2"}
{"id": "op_sortlen_anyempty", "entry_point": "op_sortlen_anyempty", "primitives": ["sortlen", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then return whether any string is empty.", "solution": "def op_sortlen_anyempty(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return any(s == '' for s in r)", "tests": "assert op_sortlen_anyempty(['Hello', 'world']) == False\nassert op_sortlen_anyempty([]) == False\nassert op_sortlen_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_sortlen_anyempty(['one', 'one', 'Two']) == False\nassert op_sortlen_anyempty(['x']) == False\nassert op_sortlen_anyempty(['abc', 'de', '']) == True"}
{"id": "op_rev_evens", "entry_point": "op_rev_evens", "primitives": ["rev", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers.", "solution": "def op_rev_evens(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_rev_evens([1, 2, 3, 4]) == [4, 2]\nassert op_rev_evens([]) == []\nassert op_rev_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_rev_evens([5, 5, 5]) == []\nassert op_rev_evens([3, 1, 2]) == [2]\nassert op_rev_evens([10]) == [10]\nassert op_rev_evens([2, 4, 6]) == [6, 4, 2]\nassert op_rev_evens([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_sortabs", "entry_point": "op_dropfirst_sortabs", "primitives": ["dropfirst", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value.", "solution": "def op_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropfirst_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sortabs([]) == []\nassert op_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, 2]\nassert op_dropfirst_sortabs([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortabs([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sortabs([10]) == []\nassert op_dropfirst_sortabs([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_beforezero_takewhilepos", "entry_point": "op_beforezero_takewhilepos", "primitives": ["beforezero", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive.", "solution": "def op_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_takewhilepos([]) == []\nassert op_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_takewhilepos([10]) == [10]\nassert op_beforezero_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_evens_dropzeros", "entry_point": "op_evens_dropzeros", "primitives": ["evens", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros.", "solution": "def op_evens_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_evens_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_evens_dropzeros([]) == []\nassert op_evens_dropzeros([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_evens_dropzeros([5, 5, 5]) == []\nassert op_evens_dropzeros([3, 1, 2]) == [2]\nassert op_evens_dropzeros([10]) == [10]\nassert op_evens_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_evens_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_square_div3", "entry_point": "op_square_div3", "primitives": ["square", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three.", "solution": "def op_square_div3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_square_div3([1, 2, 3, 4]) == [9]\nassert op_square_div3([]) == []\nassert op_square_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_square_div3([5, 5, 5]) == []\nassert op_square_div3([3, 1, 2]) == [9]\nassert op_square_div3([10]) == []\nassert op_square_div3([2, 4, 6]) == [36]\nassert op_square_div3([-7, 12, -7]) == [144]"}
{"id": "op_odds_first3", "entry_point": "op_odds_first3", "primitives": ["odds", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three.", "solution": "def op_odds_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    return r", "tests": "assert op_odds_first3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_first3([]) == []\nassert op_odds_first3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_first3([3, 1, 2]) == [3, 1]\nassert op_odds_first3([10]) == []\nassert op_odds_first3([2, 4, 6]) == []\nassert op_odds_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_add10_anyeven", "entry_point": "op_add10_anyeven", "primitives": ["add10", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return whether any value is even.", "solution": "def op_add10_anyeven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_add10_anyeven([1, 2, 3, 4]) == True\nassert op_add10_anyeven([]) == False\nassert op_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_add10_anyeven([5, 5, 5]) == False\nassert op_add10_anyeven([3, 1, 2]) == True\nassert op_add10_anyeven([10]) == True\nassert op_add10_anyeven([2, 4, 6]) == True\nassert op_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortlen_joinc", "entry_point": "op_sortlen_joinc", "primitives": ["sortlen", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then join them with commas.", "solution": "def op_sortlen_joinc(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return ','.join(r)", "tests": "assert op_sortlen_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortlen_joinc([]) == ''\nassert op_sortlen_joinc(['  a ', '', 'BC', 'bc']) == ',BC,bc,  a '\nassert op_sortlen_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_sortlen_joinc(['x']) == 'x'\nassert op_sortlen_joinc(['abc', 'de', '']) == ',de,abc'"}
{"id": "op_padto3_double", "entry_point": "op_padto3_double", "primitives": ["padto3", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each.", "solution": "def op_padto3_double(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_padto3_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_double([]) == [0, 0, 0]\nassert op_padto3_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_padto3_double([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_double([10]) == [20, 0, 0]\nassert op_padto3_double([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_sorta_dropfirst", "entry_point": "op_sorta_dropfirst", "primitives": ["sorta", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first element.", "solution": "def op_sorta_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:]\n    return r", "tests": "assert op_sorta_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_dropfirst([]) == []\nassert op_sorta_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_sorta_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sorta_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sorta_dropfirst([10]) == []\nassert op_sorta_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sorta_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sortabs_dropfirst", "entry_point": "op_sortabs_dropfirst", "primitives": ["sortabs", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element.", "solution": "def op_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_dropfirst([]) == []\nassert op_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortabs_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sortabs_dropfirst([10]) == []\nassert op_sortabs_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sortabs_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sortd_gt5", "entry_point": "op_sortd_gt5", "primitives": ["sortd", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five.", "solution": "def op_sortd_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_gt5([1, 2, 3, 4]) == []\nassert op_sortd_gt5([]) == []\nassert op_sortd_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortd_gt5([5, 5, 5]) == []\nassert op_sortd_gt5([3, 1, 2]) == []\nassert op_sortd_gt5([10]) == [10]\nassert op_sortd_gt5([2, 4, 6]) == [6]\nassert op_sortd_gt5([-7, 12, -7]) == [12]"}
{"id": "op_add10_rev", "entry_point": "op_add10_rev", "primitives": ["add10", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order.", "solution": "def op_add10_rev(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_add10_rev([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_rev([]) == []\nassert op_add10_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_rev([5, 5, 5]) == [15, 15, 15]\nassert op_add10_rev([3, 1, 2]) == [12, 11, 13]\nassert op_add10_rev([10]) == [20]\nassert op_add10_rev([2, 4, 6]) == [16, 14, 12]\nassert op_add10_rev([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_dropshort_lens", "entry_point": "op_dropshort_lens", "primitives": ["dropshort", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then return the total number of characters.", "solution": "def op_dropshort_lens(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return sum(len(s) for s in r)", "tests": "assert op_dropshort_lens(['Hello', 'world']) == 10\nassert op_dropshort_lens([]) == 0\nassert op_dropshort_lens(['  a ', '', 'BC', 'bc']) == 4\nassert op_dropshort_lens(['one', 'one', 'Two']) == 9\nassert op_dropshort_lens(['x']) == 0\nassert op_dropshort_lens(['abc', 'de', '']) == 3"}
{"id": "op_sortd_div3", "entry_point": "op_sortd_div3", "primitives": ["sortd", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep multiples of three.", "solution": "def op_sortd_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_div3([1, 2, 3, 4]) == [3]\nassert op_sortd_div3([]) == []\nassert op_sortd_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_div3([5, 5, 5]) == []\nassert op_sortd_div3([3, 1, 2]) == [3]\nassert op_sortd_div3([10]) == []\nassert op_sortd_div3([2, 4, 6]) == [6]\nassert op_sortd_div3([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_square", "entry_point": "op_sortabs_square", "primitives": ["sortabs", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each.", "solution": "def op_sortabs_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_square([]) == []\nassert op_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_square([10]) == [100]\nassert op_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_sortabs_sorta", "entry_point": "op_sortabs_sorta", "primitives": ["sortabs", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending.", "solution": "def op_sortabs_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_sorta([]) == []\nassert op_sortabs_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_sorta([10]) == [10]\nassert op_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_add10_oremptyzero", "entry_point": "op_add10_oremptyzero", "primitives": ["add10", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero.", "solution": "def op_add10_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_oremptyzero([]) == [0]\nassert op_add10_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_oremptyzero([10]) == [20]\nassert op_add10_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_oremptyzero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_oremptyzero_trimends", "entry_point": "op_oremptyzero_trimends", "primitives": ["oremptyzero", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements.", "solution": "def op_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_oremptyzero_trimends([]) == []\nassert op_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_oremptyzero_trimends([5, 5, 5]) == [5]\nassert op_oremptyzero_trimends([3, 1, 2]) == [1]\nassert op_oremptyzero_trimends([10]) == []\nassert op_oremptyzero_trimends([2, 4, 6]) == [4]\nassert op_oremptyzero_trimends([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_odds", "entry_point": "op_dropfirst_odds", "primitives": ["dropfirst", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers.", "solution": "def op_dropfirst_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_odds([1, 2, 3, 4]) == [3]\nassert op_dropfirst_odds([]) == []\nassert op_dropfirst_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_odds([5, 5, 5]) == [5, 5]\nassert op_dropfirst_odds([3, 1, 2]) == [1]\nassert op_dropfirst_odds([10]) == []\nassert op_dropfirst_odds([2, 4, 6]) == []\nassert op_dropfirst_odds([-7, 12, -7]) == [-7]"}
{"id": "op_lower_firstchar", "entry_point": "op_lower_firstchar", "primitives": ["lower", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then keep the first character of each (dropping empties).", "solution": "def op_lower_firstchar(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_lower_firstchar(['Hello', 'world']) == ['h', 'w']\nassert op_lower_firstchar([]) == []\nassert op_lower_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'b', 'b']\nassert op_lower_firstchar(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_lower_firstchar(['x']) == ['x']\nassert op_lower_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_neg_last3", "entry_point": "op_neg_last3", "primitives": ["neg", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three.", "solution": "def op_neg_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return r", "tests": "assert op_neg_last3([1, 2, 3, 4]) == []\nassert op_neg_last3([]) == []\nassert op_neg_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_last3([5, 5, 5]) == []\nassert op_neg_last3([3, 1, 2]) == []\nassert op_neg_last3([10]) == []\nassert op_neg_last3([2, 4, 6]) == []\nassert op_neg_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sorta_counteven", "entry_point": "op_sorta_counteven", "primitives": ["sorta", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return how many values are even.", "solution": "def op_sorta_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_counteven([]) == 0\nassert op_sorta_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_counteven([5, 5, 5]) == 0\nassert op_sorta_counteven([3, 1, 2]) == 1\nassert op_sorta_counteven([10]) == 1\nassert op_sorta_counteven([2, 4, 6]) == 3\nassert op_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_sorta", "entry_point": "op_rev_sorta", "primitives": ["rev", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending.", "solution": "def op_rev_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    return r", "tests": "assert op_rev_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_sorta([]) == []\nassert op_rev_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sorta([10]) == [10]\nassert op_rev_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_rev", "entry_point": "op_beforezero_rev", "primitives": ["beforezero", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order.", "solution": "def op_beforezero_rev(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_beforezero_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_rev([]) == []\nassert op_beforezero_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_rev([10]) == [10]\nassert op_beforezero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst_uniq", "entry_point": "op_dropfirst_uniq", "primitives": ["dropfirst", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_uniq([]) == []\nassert op_dropfirst_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_uniq([3, 1, 2]) == [1, 2]\nassert op_dropfirst_uniq([10]) == []\nassert op_dropfirst_uniq([2, 4, 6]) == [4, 6]\nassert op_dropfirst_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortlen_strip", "entry_point": "op_sortlen_strip", "primitives": ["sortlen", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then trim whitespace from each.", "solution": "def op_sortlen_strip(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_sortlen_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_strip([]) == []\nassert op_sortlen_strip(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', 'a']\nassert op_sortlen_strip(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_sortlen_strip(['x']) == ['x']\nassert op_sortlen_strip(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_ages_prod", "entry_point": "op_ages_prod", "primitives": ["ages", "prod"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return their product.", "solution": "def op_ages_prod(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return __import__('math').prod(r)", "tests": "assert op_ages_prod([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 432\nassert op_ages_prod([]) == 1\nassert op_ages_prod([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 19890\nassert op_ages_prod([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_ages_last3", "entry_point": "op_ages_last3", "primitives": ["ages", "last3"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three.", "solution": "def op_ages_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_last3([]) == []\nassert op_ages_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_last3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_clamp10_sortabs", "entry_point": "op_clamp10_sortabs", "primitives": ["clamp10", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value.", "solution": "def op_clamp10_sortabs(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_clamp10_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sortabs([]) == []\nassert op_clamp10_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_clamp10_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sortabs([10]) == [10]\nassert op_clamp10_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sortabs([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_dropzeros_counteven", "entry_point": "op_dropzeros_counteven", "primitives": ["dropzeros", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return how many values are even.", "solution": "def op_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_counteven([]) == 0\nassert op_dropzeros_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_counteven([5, 5, 5]) == 0\nassert op_dropzeros_counteven([3, 1, 2]) == 1\nassert op_dropzeros_counteven([10]) == 1\nassert op_dropzeros_counteven([2, 4, 6]) == 3\nassert op_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_strip_sortalpha", "entry_point": "op_strip_sortalpha", "primitives": ["strip", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort alphabetically.", "solution": "def op_strip_sortalpha(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_strip_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_sortalpha([]) == []\nassert op_strip_sortalpha(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'a', 'bc']\nassert op_strip_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_strip_sortalpha(['x']) == ['x']\nassert op_strip_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_dec_square", "entry_point": "op_dec_square", "primitives": ["dec", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each.", "solution": "def op_dec_square(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dec_square([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_dec_square([]) == []\nassert op_dec_square([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_dec_square([5, 5, 5]) == [16, 16, 16]\nassert op_dec_square([3, 1, 2]) == [4, 0, 1]\nassert op_dec_square([10]) == [81]\nassert op_dec_square([2, 4, 6]) == [1, 9, 25]\nassert op_dec_square([-7, 12, -7]) == [64, 121, 64]"}
{"id": "op_padto3_odds", "entry_point": "op_padto3_odds", "primitives": ["padto3", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_padto3_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_odds([]) == []\nassert op_padto3_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_padto3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_odds([10]) == []\nassert op_padto3_odds([2, 4, 6]) == []\nassert op_padto3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_add10_pos", "entry_point": "op_add10_pos", "primitives": ["add10", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers.", "solution": "def op_add10_pos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_add10_pos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_pos([]) == []\nassert op_add10_pos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_pos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_pos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_pos([10]) == [20]\nassert op_add10_pos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_pos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_rev_div3", "entry_point": "op_rev_div3", "primitives": ["rev", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three.", "solution": "def op_rev_div3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_rev_div3([1, 2, 3, 4]) == [3]\nassert op_rev_div3([]) == []\nassert op_rev_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_rev_div3([5, 5, 5]) == []\nassert op_rev_div3([3, 1, 2]) == [3]\nassert op_rev_div3([10]) == []\nassert op_rev_div3([2, 4, 6]) == [6]\nassert op_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_firstchar_sortalpha", "entry_point": "op_firstchar_sortalpha", "primitives": ["firstchar", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically.", "solution": "def op_firstchar_sortalpha(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    return r", "tests": "assert op_firstchar_sortalpha(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_sortalpha([]) == []\nassert op_firstchar_sortalpha(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_sortalpha(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_firstchar_sortalpha(['x']) == ['x']\nassert op_firstchar_sortalpha(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_uniq_gt5", "entry_point": "op_uniq_gt5", "primitives": ["uniq", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_uniq_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_gt5([1, 2, 3, 4]) == []\nassert op_uniq_gt5([]) == []\nassert op_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_gt5([5, 5, 5]) == []\nassert op_uniq_gt5([3, 1, 2]) == []\nassert op_uniq_gt5([10]) == [10]\nassert op_uniq_gt5([2, 4, 6]) == [6]\nassert op_uniq_gt5([-7, 12, -7]) == [12]"}
{"id": "op_square_clamp10", "entry_point": "op_square_clamp10", "primitives": ["square", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10.", "solution": "def op_square_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_clamp10([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_square_clamp10([]) == []\nassert op_square_clamp10([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_square_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_square_clamp10([10]) == [10]\nassert op_square_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_square_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_clamp10_odds", "entry_point": "op_clamp10_odds", "primitives": ["clamp10", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers.", "solution": "def op_clamp10_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_odds([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_odds([]) == []\nassert op_clamp10_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_odds([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_odds([3, 1, 2]) == [3, 1]\nassert op_clamp10_odds([10]) == []\nassert op_clamp10_odds([2, 4, 6]) == []\nassert op_clamp10_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_max", "entry_point": "op_neg_max", "primitives": ["neg", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_neg_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_neg_max([1, 2, 3, 4]) == 0\nassert op_neg_max([]) == 0\nassert op_neg_max([-2, -1, 0, 1, 2]) == -1\nassert op_neg_max([5, 5, 5]) == 0\nassert op_neg_max([3, 1, 2]) == 0\nassert op_neg_max([10]) == 0\nassert op_neg_max([2, 4, 6]) == 0\nassert op_neg_max([-7, 12, -7]) == -7"}
{"id": "op_dropzeros_uniq", "entry_point": "op_dropzeros_uniq", "primitives": ["dropzeros", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence.", "solution": "def op_dropzeros_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropzeros_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_uniq([]) == []\nassert op_dropzeros_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_uniq([5, 5, 5]) == [5]\nassert op_dropzeros_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_uniq([10]) == [10]\nassert op_dropzeros_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dec_rev", "entry_point": "op_dec_rev", "primitives": ["dec", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order.", "solution": "def op_dec_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_rev([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_rev([]) == []\nassert op_dec_rev([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_dec_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_rev([3, 1, 2]) == [1, 0, 2]\nassert op_dec_rev([10]) == [9]\nassert op_dec_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_trimends_dropzeros", "entry_point": "op_trimends_dropzeros", "primitives": ["trimends", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros.", "solution": "def op_trimends_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_dropzeros([]) == []\nassert op_trimends_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_dropzeros([5, 5, 5]) == [5]\nassert op_trimends_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_dropzeros([10]) == []\nassert op_trimends_dropzeros([2, 4, 6]) == [4]\nassert op_trimends_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_sorta", "entry_point": "op_dropzeros_sorta", "primitives": ["dropzeros", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending.", "solution": "def op_dropzeros_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sorta([]) == []\nassert op_dropzeros_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sorta([10]) == [10]\nassert op_dropzeros_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_odds_beforezero", "entry_point": "op_odds_beforezero", "primitives": ["odds", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero.", "solution": "def op_odds_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_odds_beforezero([1, 2, 3, 4]) == [1, 3]\nassert op_odds_beforezero([]) == []\nassert op_odds_beforezero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_odds_beforezero([3, 1, 2]) == [3, 1]\nassert op_odds_beforezero([10]) == []\nassert op_odds_beforezero([2, 4, 6]) == []\nassert op_odds_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_takewhilepos", "entry_point": "op_last3_takewhilepos", "primitives": ["last3", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive.", "solution": "def op_last3_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_takewhilepos([]) == []\nassert op_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_takewhilepos([10]) == [10]\nassert op_last3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_names_firstchar", "entry_point": "op_names_firstchar", "primitives": ["names", "firstchar"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then keep the first character of each (dropping empties).", "solution": "def op_names_firstchar(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_names_firstchar([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['A', 'B']\nassert op_names_firstchar([]) == []\nassert op_names_firstchar([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['C', 'D', 'E']\nassert op_names_firstchar([{'name': 'Fi', 'age': 41}]) == ['F']"}
{"id": "op_gt5_neg", "entry_point": "op_gt5_neg", "primitives": ["gt5", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers.", "solution": "def op_gt5_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_gt5_neg([1, 2, 3, 4]) == []\nassert op_gt5_neg([]) == []\nassert op_gt5_neg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg([5, 5, 5]) == []\nassert op_gt5_neg([3, 1, 2]) == []\nassert op_gt5_neg([10]) == []\nassert op_gt5_neg([2, 4, 6]) == []\nassert op_gt5_neg([-7, 12, -7]) == []"}
{"id": "op_neg_odds", "entry_point": "op_neg_odds", "primitives": ["neg", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers.", "solution": "def op_neg_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_neg_odds([1, 2, 3, 4]) == []\nassert op_neg_odds([]) == []\nassert op_neg_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_odds([5, 5, 5]) == []\nassert op_neg_odds([3, 1, 2]) == []\nassert op_neg_odds([10]) == []\nassert op_neg_odds([2, 4, 6]) == []\nassert op_neg_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_negate", "entry_point": "op_div3_negate", "primitives": ["div3", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each.", "solution": "def op_div3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_div3_negate([1, 2, 3, 4]) == [-3]\nassert op_div3_negate([]) == []\nassert op_div3_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_negate([5, 5, 5]) == []\nassert op_div3_negate([3, 1, 2]) == [-3]\nassert op_div3_negate([10]) == []\nassert op_div3_negate([2, 4, 6]) == [-6]\nassert op_div3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_strip_upper", "entry_point": "op_strip_upper", "primitives": ["strip", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then uppercase each string.", "solution": "def op_strip_upper(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_strip_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_strip_upper([]) == []\nassert op_strip_upper(['  a ', '', 'BC', 'bc']) == ['A', '', 'BC', 'BC']\nassert op_strip_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_strip_upper(['x']) == ['X']\nassert op_strip_upper(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_div3_pos", "entry_point": "op_div3_pos", "primitives": ["div3", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers.", "solution": "def op_div3_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_div3_pos([1, 2, 3, 4]) == [3]\nassert op_div3_pos([]) == []\nassert op_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_div3_pos([5, 5, 5]) == []\nassert op_div3_pos([3, 1, 2]) == [3]\nassert op_div3_pos([10]) == []\nassert op_div3_pos([2, 4, 6]) == [6]\nassert op_div3_pos([-7, 12, -7]) == [12]"}
{"id": "op_last3_alldistinct", "entry_point": "op_last3_alldistinct", "primitives": ["last3", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return whether all values are distinct.", "solution": "def op_last3_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_alldistinct([]) == True\nassert op_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_alldistinct([5, 5, 5]) == False\nassert op_last3_alldistinct([3, 1, 2]) == True\nassert op_last3_alldistinct([10]) == True\nassert op_last3_alldistinct([2, 4, 6]) == True\nassert op_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sortlen_sortalpha", "entry_point": "op_sortlen_sortalpha", "primitives": ["sortlen", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then sort alphabetically.", "solution": "def op_sortlen_sortalpha(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = sorted(r)\n    return r", "tests": "assert op_sortlen_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_sortalpha([]) == []\nassert op_sortlen_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'BC', 'bc']\nassert op_sortlen_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortlen_sortalpha(['x']) == ['x']\nassert op_sortlen_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_last3_double", "entry_point": "op_last3_double", "primitives": ["last3", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then double each.", "solution": "def op_last3_double(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_last3_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_double([]) == []\nassert op_last3_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_last3_double([5, 5, 5]) == [10, 10, 10]\nassert op_last3_double([3, 1, 2]) == [6, 2, 4]\nassert op_last3_double([10]) == [20]\nassert op_last3_double([2, 4, 6]) == [4, 8, 12]\nassert op_last3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_pos_negate", "entry_point": "op_pos_negate", "primitives": ["pos", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each.", "solution": "def op_pos_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_negate([]) == []\nassert op_pos_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_pos_negate([10]) == [-10]\nassert op_pos_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_negate([-7, 12, -7]) == [-12]"}
{"id": "op_dropzeros_issorted", "entry_point": "op_dropzeros_issorted", "primitives": ["dropzeros", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_dropzeros_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_issorted([]) == True\nassert op_dropzeros_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_issorted([5, 5, 5]) == True\nassert op_dropzeros_issorted([3, 1, 2]) == False\nassert op_dropzeros_issorted([10]) == True\nassert op_dropzeros_issorted([2, 4, 6]) == True\nassert op_dropzeros_issorted([-7, 12, -7]) == False"}
{"id": "op_dec_sorta", "entry_point": "op_dec_sorta", "primitives": ["dec", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending.", "solution": "def op_dec_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_sorta([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sorta([]) == []\nassert op_dec_sorta([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sorta([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sorta([10]) == [9]\nassert op_dec_sorta([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sorta([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_absval_pos", "entry_point": "op_absval_pos", "primitives": ["absval", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers.", "solution": "def op_absval_pos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_absval_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_pos([]) == []\nassert op_absval_pos([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_absval_pos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_pos([3, 1, 2]) == [3, 1, 2]\nassert op_absval_pos([10]) == [10]\nassert op_absval_pos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_pos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_trimends_padto3", "entry_point": "op_trimends_padto3", "primitives": ["trimends", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_trimends_padto3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_trimends_padto3([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_padto3([]) == [0, 0, 0]\nassert op_trimends_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_padto3([10]) == [0, 0, 0]\nassert op_trimends_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_pos_gt5", "entry_point": "op_pos_gt5", "primitives": ["pos", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep values greater than five.", "solution": "def op_pos_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_pos_gt5([1, 2, 3, 4]) == []\nassert op_pos_gt5([]) == []\nassert op_pos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_pos_gt5([5, 5, 5]) == []\nassert op_pos_gt5([3, 1, 2]) == []\nassert op_pos_gt5([10]) == [10]\nassert op_pos_gt5([2, 4, 6]) == [6]\nassert op_pos_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortlen_uniqs", "entry_point": "op_sortlen_uniqs", "primitives": ["sortlen", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop duplicate strings keeping the first.", "solution": "def op_sortlen_uniqs(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortlen_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_uniqs([]) == []\nassert op_sortlen_uniqs(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_sortlen_uniqs(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_sortlen_uniqs(['x']) == ['x']\nassert op_sortlen_uniqs(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_padto3_takewhilepos", "entry_point": "op_padto3_takewhilepos", "primitives": ["padto3", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_padto3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_takewhilepos([]) == []\nassert op_padto3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos([10]) == [10]\nassert op_padto3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_first3_issorted", "entry_point": "op_first3_issorted", "primitives": ["first3", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_first3_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_first3_issorted([1, 2, 3, 4]) == True\nassert op_first3_issorted([]) == True\nassert op_first3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_first3_issorted([5, 5, 5]) == True\nassert op_first3_issorted([3, 1, 2]) == False\nassert op_first3_issorted([10]) == True\nassert op_first3_issorted([2, 4, 6]) == True\nassert op_first3_issorted([-7, 12, -7]) == False"}
{"id": "op_uniq_min", "entry_point": "op_uniq_min", "primitives": ["uniq", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_uniq_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_uniq_min([1, 2, 3, 4]) == 1\nassert op_uniq_min([]) == 0\nassert op_uniq_min([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_min([5, 5, 5]) == 5\nassert op_uniq_min([3, 1, 2]) == 1\nassert op_uniq_min([10]) == 10\nassert op_uniq_min([2, 4, 6]) == 2\nassert op_uniq_min([-7, 12, -7]) == -7"}
{"id": "op_rev_dec", "entry_point": "op_rev_dec", "primitives": ["rev", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then subtract one from each.", "solution": "def op_rev_dec(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_rev_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_rev_dec([]) == []\nassert op_rev_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_rev_dec([5, 5, 5]) == [4, 4, 4]\nassert op_rev_dec([3, 1, 2]) == [1, 0, 2]\nassert op_rev_dec([10]) == [9]\nassert op_rev_dec([2, 4, 6]) == [5, 3, 1]\nassert op_rev_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_inc_last3", "entry_point": "op_inc_last3", "primitives": ["inc", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three.", "solution": "def op_inc_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_last3([]) == []\nassert op_inc_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_last3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_last3([10]) == [11]\nassert op_inc_last3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_last3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_oremptyzero_evens", "entry_point": "op_oremptyzero_evens", "primitives": ["oremptyzero", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers.", "solution": "def op_oremptyzero_evens(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_oremptyzero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_evens([]) == [0]\nassert op_oremptyzero_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_oremptyzero_evens([5, 5, 5]) == []\nassert op_oremptyzero_evens([3, 1, 2]) == [2]\nassert op_oremptyzero_evens([10]) == [10]\nassert op_oremptyzero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens([-7, 12, -7]) == [12]"}
{"id": "op_gt5_div3", "entry_point": "op_gt5_div3", "primitives": ["gt5", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three.", "solution": "def op_gt5_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_gt5_div3([1, 2, 3, 4]) == []\nassert op_gt5_div3([]) == []\nassert op_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_div3([5, 5, 5]) == []\nassert op_gt5_div3([3, 1, 2]) == []\nassert op_gt5_div3([10]) == []\nassert op_gt5_div3([2, 4, 6]) == [6]\nassert op_gt5_div3([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dropzeros", "entry_point": "op_oremptyzero_dropzeros", "primitives": ["oremptyzero", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros.", "solution": "def op_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_dropzeros([]) == []\nassert op_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_oremptyzero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_dropzeros([10]) == [10]\nassert op_oremptyzero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg_double", "entry_point": "op_neg_double", "primitives": ["neg", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then double each.", "solution": "def op_neg_double(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_neg_double([1, 2, 3, 4]) == []\nassert op_neg_double([]) == []\nassert op_neg_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_neg_double([5, 5, 5]) == []\nassert op_neg_double([3, 1, 2]) == []\nassert op_neg_double([10]) == []\nassert op_neg_double([2, 4, 6]) == []\nassert op_neg_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_evens_last3", "entry_point": "op_evens_last3", "primitives": ["evens", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three.", "solution": "def op_evens_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    return r", "tests": "assert op_evens_last3([1, 2, 3, 4]) == [2, 4]\nassert op_evens_last3([]) == []\nassert op_evens_last3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_last3([5, 5, 5]) == []\nassert op_evens_last3([3, 1, 2]) == [2]\nassert op_evens_last3([10]) == [10]\nassert op_evens_last3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_last3([-7, 12, -7]) == [12]"}
{"id": "op_dec_inc", "entry_point": "op_dec_inc", "primitives": ["dec", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each.", "solution": "def op_dec_inc(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dec_inc([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc([]) == []\nassert op_dec_inc([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_dec_inc([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc([10]) == [10]\nassert op_dec_inc([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_clamp10", "entry_point": "op_rev_clamp10", "primitives": ["rev", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10.", "solution": "def op_rev_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_clamp10([]) == []\nassert op_rev_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10([3, 1, 2]) == [2, 1, 3]\nassert op_rev_clamp10([10]) == [10]\nassert op_rev_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_rev_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_uniq_alldistinct", "entry_point": "op_uniq_alldistinct", "primitives": ["uniq", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_uniq_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_alldistinct([]) == True\nassert op_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_uniq_alldistinct([5, 5, 5]) == True\nassert op_uniq_alldistinct([3, 1, 2]) == True\nassert op_uniq_alldistinct([10]) == True\nassert op_uniq_alldistinct([2, 4, 6]) == True\nassert op_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_sortd", "entry_point": "op_takewhilepos_sortd", "primitives": ["takewhilepos", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort descending.", "solution": "def op_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_sortd([]) == []\nassert op_takewhilepos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_sortd([10]) == [10]\nassert op_takewhilepos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_sortd([-7, 12, -7]) == []"}
{"id": "op_sortd_beforezero", "entry_point": "op_sortd_beforezero", "primitives": ["sortd", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero.", "solution": "def op_sortd_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortd_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_beforezero([]) == []\nassert op_sortd_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_beforezero([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_beforezero([10]) == [10]\nassert op_sortd_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_beforezero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_pos_dropfirst", "entry_point": "op_pos_dropfirst", "primitives": ["pos", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first element.", "solution": "def op_pos_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_pos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_dropfirst([]) == []\nassert op_pos_dropfirst([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_pos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_pos_dropfirst([10]) == []\nassert op_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_clamp10_len", "entry_point": "op_clamp10_len", "primitives": ["clamp10", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return how many remain.", "solution": "def op_clamp10_len(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_clamp10_len([1, 2, 3, 4]) == 4\nassert op_clamp10_len([]) == 0\nassert op_clamp10_len([-2, -1, 0, 1, 2]) == 5\nassert op_clamp10_len([5, 5, 5]) == 3\nassert op_clamp10_len([3, 1, 2]) == 3\nassert op_clamp10_len([10]) == 1\nassert op_clamp10_len([2, 4, 6]) == 3\nassert op_clamp10_len([-7, 12, -7]) == 3"}
{"id": "op_rev_haszero", "entry_point": "op_rev_haszero", "primitives": ["rev", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return whether the list contains a zero.", "solution": "def op_rev_haszero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return 0 in r", "tests": "assert op_rev_haszero([1, 2, 3, 4]) == False\nassert op_rev_haszero([]) == False\nassert op_rev_haszero([-2, -1, 0, 1, 2]) == True\nassert op_rev_haszero([5, 5, 5]) == False\nassert op_rev_haszero([3, 1, 2]) == False\nassert op_rev_haszero([10]) == False\nassert op_rev_haszero([2, 4, 6]) == False\nassert op_rev_haszero([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_absval", "entry_point": "op_oremptyzero_absval", "primitives": ["oremptyzero", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take the absolute value of each.", "solution": "def op_oremptyzero_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_absval([]) == [0]\nassert op_oremptyzero_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_absval([10]) == [10]\nassert op_oremptyzero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_dropfirst_trimends", "entry_point": "op_dropfirst_trimends", "primitives": ["dropfirst", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements.", "solution": "def op_dropfirst_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends([]) == []\nassert op_dropfirst_trimends([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dropfirst_trimends([5, 5, 5]) == []\nassert op_dropfirst_trimends([3, 1, 2]) == []\nassert op_dropfirst_trimends([10]) == []\nassert op_dropfirst_trimends([2, 4, 6]) == []\nassert op_dropfirst_trimends([-7, 12, -7]) == []"}
{"id": "op_uniq_firsteven", "entry_point": "op_uniq_firsteven", "primitives": ["uniq", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_uniq_firsteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_uniq_firsteven([1, 2, 3, 4]) == 2\nassert op_uniq_firsteven([]) == 0\nassert op_uniq_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_firsteven([5, 5, 5]) == 0\nassert op_uniq_firsteven([3, 1, 2]) == 2\nassert op_uniq_firsteven([10]) == 10\nassert op_uniq_firsteven([2, 4, 6]) == 2\nassert op_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dec_dropwhileneg", "entry_point": "op_dec_dropwhileneg", "primitives": ["dec", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values.", "solution": "def op_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_dropwhileneg([]) == []\nassert op_dec_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dec_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_dec_dropwhileneg([10]) == [9]\nassert op_dec_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropwhileneg([-7, 12, -7]) == [11, -8]"}
{"id": "op_pos_prod", "entry_point": "op_pos_prod", "primitives": ["pos", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return their product.", "solution": "def op_pos_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_pos_prod([1, 2, 3, 4]) == 24\nassert op_pos_prod([]) == 1\nassert op_pos_prod([-2, -1, 0, 1, 2]) == 2\nassert op_pos_prod([5, 5, 5]) == 125\nassert op_pos_prod([3, 1, 2]) == 6\nassert op_pos_prod([10]) == 10\nassert op_pos_prod([2, 4, 6]) == 48\nassert op_pos_prod([-7, 12, -7]) == 12"}
{"id": "op_add10_padto3", "entry_point": "op_add10_padto3", "primitives": ["add10", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then pad with zeros to at least three elements.", "solution": "def op_add10_padto3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_add10_padto3([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_padto3([]) == [0, 0, 0]\nassert op_add10_padto3([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_padto3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_padto3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_padto3([10]) == [20, 0, 0]\nassert op_add10_padto3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_padto3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_names_longest", "entry_point": "op_names_longest", "primitives": ["names", "longest"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then return the longest string (empty if none).", "solution": "def op_names_longest(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_names_longest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada'\nassert op_names_longest([]) == ''\nassert op_names_longest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Dee'\nassert op_names_longest([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_sortlen_upper", "entry_point": "op_sortlen_upper", "primitives": ["sortlen", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then uppercase each string.", "solution": "def op_sortlen_upper(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_sortlen_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortlen_upper([]) == []\nassert op_sortlen_upper(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'BC', '  A ']\nassert op_sortlen_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_sortlen_upper(['x']) == ['X']\nassert op_sortlen_upper(['abc', 'de', '']) == ['', 'DE', 'ABC']"}
{"id": "op_dropfirst_firsteven", "entry_point": "op_dropfirst_firsteven", "primitives": ["dropfirst", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return the first even value (0 if none).", "solution": "def op_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_firsteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_firsteven([]) == 0\nassert op_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_firsteven([3, 1, 2]) == 2\nassert op_dropfirst_firsteven([10]) == 0\nassert op_dropfirst_firsteven([2, 4, 6]) == 4\nassert op_dropfirst_firsteven([-7, 12, -7]) == 12"}
{"id": "op_gt5_clamp10", "entry_point": "op_gt5_clamp10", "primitives": ["gt5", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10.", "solution": "def op_gt5_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_clamp10([1, 2, 3, 4]) == []\nassert op_gt5_clamp10([]) == []\nassert op_gt5_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_clamp10([5, 5, 5]) == []\nassert op_gt5_clamp10([3, 1, 2]) == []\nassert op_gt5_clamp10([10]) == [10]\nassert op_gt5_clamp10([2, 4, 6]) == [6]\nassert op_gt5_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_evens_pos", "entry_point": "op_evens_pos", "primitives": ["evens", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers.", "solution": "def op_evens_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_evens_pos([1, 2, 3, 4]) == [2, 4]\nassert op_evens_pos([]) == []\nassert op_evens_pos([-2, -1, 0, 1, 2]) == [2]\nassert op_evens_pos([5, 5, 5]) == []\nassert op_evens_pos([3, 1, 2]) == [2]\nassert op_evens_pos([10]) == [10]\nassert op_evens_pos([2, 4, 6]) == [2, 4, 6]\nassert op_evens_pos([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_uniq", "entry_point": "op_takewhilepos_uniq", "primitives": ["takewhilepos", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_uniq([]) == []\nassert op_takewhilepos_uniq([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_uniq([5, 5, 5]) == [5]\nassert op_takewhilepos_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_uniq([10]) == [10]\nassert op_takewhilepos_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_uniq([-7, 12, -7]) == []"}
{"id": "op_clamp10_last3", "entry_point": "op_clamp10_last3", "primitives": ["clamp10", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three.", "solution": "def op_clamp10_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_last3([]) == []\nassert op_clamp10_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_last3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_last3([10]) == [10]\nassert op_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_sortd_dropfirst", "entry_point": "op_sortd_dropfirst", "primitives": ["sortd", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element.", "solution": "def op_sortd_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return r", "tests": "assert op_sortd_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dropfirst([]) == []\nassert op_sortd_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_sortd_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortd_dropfirst([3, 1, 2]) == [2, 1]\nassert op_sortd_dropfirst([10]) == []\nassert op_sortd_dropfirst([2, 4, 6]) == [4, 2]\nassert op_sortd_dropfirst([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_absval", "entry_point": "op_pos_absval", "primitives": ["pos", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each.", "solution": "def op_pos_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_absval([]) == []\nassert op_pos_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_pos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_pos_absval([10]) == [10]\nassert op_pos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_pos_absval([-7, 12, -7]) == [12]"}
{"id": "op_sorta_allpos", "entry_point": "op_sorta_allpos", "primitives": ["sorta", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return whether all values are positive.", "solution": "def op_sorta_allpos(xs):\n    r = list(xs)\n    r = sorted(r)\n    return all(x > 0 for x in r)", "tests": "assert op_sorta_allpos([1, 2, 3, 4]) == True\nassert op_sorta_allpos([]) == True\nassert op_sorta_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sorta_allpos([5, 5, 5]) == True\nassert op_sorta_allpos([3, 1, 2]) == True\nassert op_sorta_allpos([10]) == True\nassert op_sorta_allpos([2, 4, 6]) == True\nassert op_sorta_allpos([-7, 12, -7]) == False"}
{"id": "op_clamp10_prod", "entry_point": "op_clamp10_prod", "primitives": ["clamp10", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return their product.", "solution": "def op_clamp10_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_prod([1, 2, 3, 4]) == 24\nassert op_clamp10_prod([]) == 1\nassert op_clamp10_prod([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_prod([5, 5, 5]) == 125\nassert op_clamp10_prod([3, 1, 2]) == 6\nassert op_clamp10_prod([10]) == 10\nassert op_clamp10_prod([2, 4, 6]) == 48\nassert op_clamp10_prod([-7, 12, -7]) == 490"}
{"id": "op_div3_first3", "entry_point": "op_div3_first3", "primitives": ["div3", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the first three.", "solution": "def op_div3_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_div3_first3([1, 2, 3, 4]) == [3]\nassert op_div3_first3([]) == []\nassert op_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_first3([5, 5, 5]) == []\nassert op_div3_first3([3, 1, 2]) == [3]\nassert op_div3_first3([10]) == []\nassert op_div3_first3([2, 4, 6]) == [6]\nassert op_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_uniq_clamp10", "entry_point": "op_uniq_clamp10", "primitives": ["uniq", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_uniq_clamp10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_uniq_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_clamp10([]) == []\nassert op_uniq_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_clamp10([5, 5, 5]) == [5]\nassert op_uniq_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_clamp10([10]) == [10]\nassert op_uniq_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_clamp10([-7, 12, -7]) == [-7, 10]"}
{"id": "op_dropzeros_padto3", "entry_point": "op_dropzeros_padto3", "primitives": ["dropzeros", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_padto3([]) == [0, 0, 0]\nassert op_dropzeros_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_padto3([10]) == [10, 0, 0]\nassert op_dropzeros_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_nonempty_counts", "entry_point": "op_nonempty_counts", "primitives": ["nonempty", "counts"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then return how many strings remain.", "solution": "def op_nonempty_counts(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return len(r)", "tests": "assert op_nonempty_counts(['Hello', 'world']) == 2\nassert op_nonempty_counts([]) == 0\nassert op_nonempty_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_nonempty_counts(['one', 'one', 'Two']) == 3\nassert op_nonempty_counts(['x']) == 1\nassert op_nonempty_counts(['abc', 'de', '']) == 2"}
{"id": "op_sortalpha_uniqs", "entry_point": "op_sortalpha_uniqs", "primitives": ["sortalpha", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first.", "solution": "def op_sortalpha_uniqs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortalpha_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_uniqs([]) == []\nassert op_sortalpha_uniqs(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'BC', 'bc']\nassert op_sortalpha_uniqs(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_sortalpha_uniqs(['x']) == ['x']\nassert op_sortalpha_uniqs(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_ages_uniq", "entry_point": "op_ages_uniq", "primitives": ["ages", "uniq"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence.", "solution": "def op_ages_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_uniq([]) == []\nassert op_ages_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_uniq([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropzeros_absval", "entry_point": "op_dropzeros_absval", "primitives": ["dropzeros", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each.", "solution": "def op_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_absval([]) == []\nassert op_dropzeros_absval([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_absval([10]) == [10]\nassert op_dropzeros_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sortalpha_nonempty", "entry_point": "op_sortalpha_nonempty", "primitives": ["sortalpha", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop empty strings.", "solution": "def op_sortalpha_nonempty(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_sortalpha_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_nonempty([]) == []\nassert op_sortalpha_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ', 'BC', 'bc']\nassert op_sortalpha_nonempty(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_nonempty(['x']) == ['x']\nassert op_sortalpha_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_clamp10_max", "entry_point": "op_clamp10_max", "primitives": ["clamp10", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_clamp10_max(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_clamp10_max([1, 2, 3, 4]) == 4\nassert op_clamp10_max([]) == 0\nassert op_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_clamp10_max([5, 5, 5]) == 5\nassert op_clamp10_max([3, 1, 2]) == 3\nassert op_clamp10_max([10]) == 10\nassert op_clamp10_max([2, 4, 6]) == 6\nassert op_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_padto3_sortabs", "entry_point": "op_padto3_sortabs", "primitives": ["padto3", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_padto3_sortabs(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_padto3_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sortabs([]) == [0, 0, 0]\nassert op_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_padto3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sortabs([10]) == [0, 0, 10]\nassert op_padto3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_oremptyzero_sorta", "entry_point": "op_oremptyzero_sorta", "primitives": ["oremptyzero", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending.", "solution": "def op_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sorta([]) == [0]\nassert op_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sorta([10]) == [10]\nassert op_oremptyzero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_neg_prod", "entry_point": "op_neg_prod", "primitives": ["neg", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return their product.", "solution": "def op_neg_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_neg_prod([1, 2, 3, 4]) == 1\nassert op_neg_prod([]) == 1\nassert op_neg_prod([-2, -1, 0, 1, 2]) == 2\nassert op_neg_prod([5, 5, 5]) == 1\nassert op_neg_prod([3, 1, 2]) == 1\nassert op_neg_prod([10]) == 1\nassert op_neg_prod([2, 4, 6]) == 1\nassert op_neg_prod([-7, 12, -7]) == 49"}
{"id": "op_dropfirst_div3", "entry_point": "op_dropfirst_div3", "primitives": ["dropfirst", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep multiples of three.", "solution": "def op_dropfirst_div3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_div3([]) == []\nassert op_dropfirst_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropfirst_div3([5, 5, 5]) == []\nassert op_dropfirst_div3([3, 1, 2]) == []\nassert op_dropfirst_div3([10]) == []\nassert op_dropfirst_div3([2, 4, 6]) == [6]\nassert op_dropfirst_div3([-7, 12, -7]) == [12]"}
{"id": "op_first3_sorta", "entry_point": "op_first3_sorta", "primitives": ["first3", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending.", "solution": "def op_first3_sorta(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_first3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta([]) == []\nassert op_first3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta([10]) == [10]\nassert op_first3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_haszero", "entry_point": "op_pos_haszero", "primitives": ["pos", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_pos_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_pos_haszero([1, 2, 3, 4]) == False\nassert op_pos_haszero([]) == False\nassert op_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_pos_haszero([5, 5, 5]) == False\nassert op_pos_haszero([3, 1, 2]) == False\nassert op_pos_haszero([10]) == False\nassert op_pos_haszero([2, 4, 6]) == False\nassert op_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_sorta", "entry_point": "op_dropwhileneg_sorta", "primitives": ["dropwhileneg", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort ascending.", "solution": "def op_dropwhileneg_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_sorta([]) == []\nassert op_dropwhileneg_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_sorta([10]) == [10]\nassert op_dropwhileneg_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_pos_padto3", "entry_point": "op_pos_padto3", "primitives": ["pos", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements.", "solution": "def op_pos_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_pos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_padto3([]) == [0, 0, 0]\nassert op_pos_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_padto3([10]) == [10, 0, 0]\nassert op_pos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_double_beforezero", "entry_point": "op_double_beforezero", "primitives": ["double", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero.", "solution": "def op_double_beforezero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_beforezero([]) == []\nassert op_double_beforezero([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_double_beforezero([10]) == [20]\nassert op_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_double_beforezero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_oremptyzero_beforezero", "entry_point": "op_oremptyzero_beforezero", "primitives": ["oremptyzero", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero.", "solution": "def op_oremptyzero_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_beforezero([]) == []\nassert op_oremptyzero_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_beforezero([10]) == [10]\nassert op_oremptyzero_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_gt5_counteven", "entry_point": "op_gt5_counteven", "primitives": ["gt5", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return how many values are even.", "solution": "def op_gt5_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_counteven([]) == 0\nassert op_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_counteven([5, 5, 5]) == 0\nassert op_gt5_counteven([3, 1, 2]) == 0\nassert op_gt5_counteven([10]) == 1\nassert op_gt5_counteven([2, 4, 6]) == 1\nassert op_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_neg", "entry_point": "op_dropzeros_neg", "primitives": ["dropzeros", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers.", "solution": "def op_dropzeros_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropzeros_neg([1, 2, 3, 4]) == []\nassert op_dropzeros_neg([]) == []\nassert op_dropzeros_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_dropzeros_neg([5, 5, 5]) == []\nassert op_dropzeros_neg([3, 1, 2]) == []\nassert op_dropzeros_neg([10]) == []\nassert op_dropzeros_neg([2, 4, 6]) == []\nassert op_dropzeros_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_pos", "entry_point": "op_beforezero_pos", "primitives": ["beforezero", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers.", "solution": "def op_beforezero_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_pos([]) == []\nassert op_beforezero_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_pos([10]) == [10]\nassert op_beforezero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_square_absval", "entry_point": "op_square_absval", "primitives": ["square", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each.", "solution": "def op_square_absval(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_square_absval([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_absval([]) == []\nassert op_square_absval([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_absval([5, 5, 5]) == [25, 25, 25]\nassert op_square_absval([3, 1, 2]) == [9, 1, 4]\nassert op_square_absval([10]) == [100]\nassert op_square_absval([2, 4, 6]) == [4, 16, 36]\nassert op_square_absval([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_prefixup_sortlen", "entry_point": "op_prefixup_sortlen", "primitives": ["prefixup", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort by length, shortest first.", "solution": "def op_prefixup_sortlen(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_prefixup_sortlen(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_sortlen([]) == []\nassert op_prefixup_sortlen(['  a ', '', 'BC', 'bc']) == ['#', '#BC', '#bc', '#  a ']\nassert op_prefixup_sortlen(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup_sortlen(['x']) == ['#x']\nassert op_prefixup_sortlen(['abc', 'de', '']) == ['#', '#de', '#abc']"}
{"id": "op_negate_absval", "entry_point": "op_negate_absval", "primitives": ["negate", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each.", "solution": "def op_negate_absval(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_negate_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval([]) == []\nassert op_negate_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_negate_absval([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval([10]) == [10]\nassert op_negate_absval([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_takewhilepos_double", "entry_point": "op_takewhilepos_double", "primitives": ["takewhilepos", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each.", "solution": "def op_takewhilepos_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_double([]) == []\nassert op_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_double([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_double([10]) == [20]\nassert op_takewhilepos_double([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_evens_absval", "entry_point": "op_evens_absval", "primitives": ["evens", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take the absolute value of each.", "solution": "def op_evens_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_evens_absval([1, 2, 3, 4]) == [2, 4]\nassert op_evens_absval([]) == []\nassert op_evens_absval([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_evens_absval([5, 5, 5]) == []\nassert op_evens_absval([3, 1, 2]) == [2]\nassert op_evens_absval([10]) == [10]\nassert op_evens_absval([2, 4, 6]) == [2, 4, 6]\nassert op_evens_absval([-7, 12, -7]) == [12]"}
{"id": "op_rev_min", "entry_point": "op_rev_min", "primitives": ["rev", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return the minimum (0 if empty).", "solution": "def op_rev_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_rev_min([1, 2, 3, 4]) == 1\nassert op_rev_min([]) == 0\nassert op_rev_min([-2, -1, 0, 1, 2]) == -2\nassert op_rev_min([5, 5, 5]) == 5\nassert op_rev_min([3, 1, 2]) == 1\nassert op_rev_min([10]) == 10\nassert op_rev_min([2, 4, 6]) == 2\nassert op_rev_min([-7, 12, -7]) == -7"}
{"id": "op_upper_prefixup", "entry_point": "op_upper_prefixup", "primitives": ["upper", "prefixup"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then prefix each with a hash.", "solution": "def op_upper_prefixup(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_upper_prefixup(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_upper_prefixup([]) == []\nassert op_upper_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ', '#', '#BC', '#BC']\nassert op_upper_prefixup(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_upper_prefixup(['x']) == ['#X']\nassert op_upper_prefixup(['abc', 'de', '']) == ['#ABC', '#DE', '#']"}
{"id": "op_odds_len", "entry_point": "op_odds_len", "primitives": ["odds", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return how many remain.", "solution": "def op_odds_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_odds_len([1, 2, 3, 4]) == 2\nassert op_odds_len([]) == 0\nassert op_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_len([5, 5, 5]) == 3\nassert op_odds_len([3, 1, 2]) == 2\nassert op_odds_len([10]) == 0\nassert op_odds_len([2, 4, 6]) == 0\nassert op_odds_len([-7, 12, -7]) == 2"}
{"id": "op_uniq_sortabs", "entry_point": "op_uniq_sortabs", "primitives": ["uniq", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value.", "solution": "def op_uniq_sortabs(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_uniq_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sortabs([]) == []\nassert op_uniq_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_uniq_sortabs([5, 5, 5]) == [5]\nassert op_uniq_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sortabs([10]) == [10]\nassert op_uniq_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_clamp10_firsteven", "entry_point": "op_clamp10_firsteven", "primitives": ["clamp10", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return the first even value (0 if none).", "solution": "def op_clamp10_firsteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_clamp10_firsteven([]) == 0\nassert op_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_clamp10_firsteven([5, 5, 5]) == 0\nassert op_clamp10_firsteven([3, 1, 2]) == 2\nassert op_clamp10_firsteven([10]) == 10\nassert op_clamp10_firsteven([2, 4, 6]) == 2\nassert op_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_sortalpha_firstchar", "entry_point": "op_sortalpha_firstchar", "primitives": ["sortalpha", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then keep the first character of each (dropping empties).", "solution": "def op_sortalpha_firstchar(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortalpha_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_sortalpha_firstchar([]) == []\nassert op_sortalpha_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_sortalpha_firstchar(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_sortalpha_firstchar(['x']) == ['x']\nassert op_sortalpha_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortabs_pos", "entry_point": "op_sortabs_pos", "primitives": ["sortabs", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers.", "solution": "def op_sortabs_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_pos([]) == []\nassert op_sortabs_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_pos([10]) == [10]\nassert op_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_pos([-7, 12, -7]) == [12]"}
{"id": "op_trimends_prod", "entry_point": "op_trimends_prod", "primitives": ["trimends", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return their product.", "solution": "def op_trimends_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return __import__('math').prod(r)", "tests": "assert op_trimends_prod([1, 2, 3, 4]) == 6\nassert op_trimends_prod([]) == 1\nassert op_trimends_prod([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_prod([5, 5, 5]) == 5\nassert op_trimends_prod([3, 1, 2]) == 1\nassert op_trimends_prod([10]) == 1\nassert op_trimends_prod([2, 4, 6]) == 4\nassert op_trimends_prod([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_first3", "entry_point": "op_takewhilepos_first3", "primitives": ["takewhilepos", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three.", "solution": "def op_takewhilepos_first3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_takewhilepos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_first3([]) == []\nassert op_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_first3([10]) == [10]\nassert op_takewhilepos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_firstchar_dropshort", "entry_point": "op_firstchar_dropshort", "primitives": ["firstchar", "dropshort"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then drop strings shorter than three characters.", "solution": "def op_firstchar_dropshort(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_firstchar_dropshort(['Hello', 'world']) == []\nassert op_firstchar_dropshort([]) == []\nassert op_firstchar_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_firstchar_dropshort(['one', 'one', 'Two']) == []\nassert op_firstchar_dropshort(['x']) == []\nassert op_firstchar_dropshort(['abc', 'de', '']) == []"}
{"id": "op_absval_neg", "entry_point": "op_absval_neg", "primitives": ["absval", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the negative numbers.", "solution": "def op_absval_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_neg([1, 2, 3, 4]) == []\nassert op_absval_neg([]) == []\nassert op_absval_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_neg([5, 5, 5]) == []\nassert op_absval_neg([3, 1, 2]) == []\nassert op_absval_neg([10]) == []\nassert op_absval_neg([2, 4, 6]) == []\nassert op_absval_neg([-7, 12, -7]) == []"}
{"id": "op_clamp10_sortd", "entry_point": "op_clamp10_sortd", "primitives": ["clamp10", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending.", "solution": "def op_clamp10_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_sortd([]) == []\nassert op_clamp10_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_sortd([10]) == [10]\nassert op_clamp10_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_sortd([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_dec_add10", "entry_point": "op_dec_add10", "primitives": ["dec", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each.", "solution": "def op_dec_add10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dec_add10([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_dec_add10([]) == []\nassert op_dec_add10([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_dec_add10([5, 5, 5]) == [14, 14, 14]\nassert op_dec_add10([3, 1, 2]) == [12, 10, 11]\nassert op_dec_add10([10]) == [19]\nassert op_dec_add10([2, 4, 6]) == [11, 13, 15]\nassert op_dec_add10([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_firstchar_prefixup", "entry_point": "op_firstchar_prefixup", "primitives": ["firstchar", "prefixup"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then prefix each with a hash.", "solution": "def op_firstchar_prefixup(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_firstchar_prefixup(['Hello', 'world']) == ['#H', '#w']\nassert op_firstchar_prefixup([]) == []\nassert op_firstchar_prefixup(['  a ', '', 'BC', 'bc']) == ['# ', '#B', '#b']\nassert op_firstchar_prefixup(['one', 'one', 'Two']) == ['#o', '#o', '#T']\nassert op_firstchar_prefixup(['x']) == ['#x']\nassert op_firstchar_prefixup(['abc', 'de', '']) == ['#a', '#d']"}
{"id": "op_dropfirst_square", "entry_point": "op_dropfirst_square", "primitives": ["dropfirst", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each.", "solution": "def op_dropfirst_square(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropfirst_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropfirst_square([]) == []\nassert op_dropfirst_square([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_dropfirst_square([5, 5, 5]) == [25, 25]\nassert op_dropfirst_square([3, 1, 2]) == [1, 4]\nassert op_dropfirst_square([10]) == []\nassert op_dropfirst_square([2, 4, 6]) == [16, 36]\nassert op_dropfirst_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_last3_sortd", "entry_point": "op_last3_sortd", "primitives": ["last3", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending.", "solution": "def op_last3_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_sortd([]) == []\nassert op_last3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_sortd([10]) == [10]\nassert op_last3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_rev_dropzeros", "entry_point": "op_rev_dropzeros", "primitives": ["rev", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros.", "solution": "def op_rev_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropzeros([]) == []\nassert op_rev_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_rev_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropzeros([10]) == [10]\nassert op_rev_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_ages_dec", "entry_point": "op_ages_dec", "primitives": ["ages", "dec"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each.", "solution": "def op_ages_dec(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_ages_dec([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11]\nassert op_ages_dec([]) == []\nassert op_ages_dec([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 64, 16]\nassert op_ages_dec([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_takewhilepos_counteven", "entry_point": "op_takewhilepos_counteven", "primitives": ["takewhilepos", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return how many values are even.", "solution": "def op_takewhilepos_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_counteven([]) == 0\nassert op_takewhilepos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_counteven([3, 1, 2]) == 1\nassert op_takewhilepos_counteven([10]) == 1\nassert op_takewhilepos_counteven([2, 4, 6]) == 3\nassert op_takewhilepos_counteven([-7, 12, -7]) == 0"}
{"id": "op_div3_double", "entry_point": "op_div3_double", "primitives": ["div3", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each.", "solution": "def op_div3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_double([1, 2, 3, 4]) == [6]\nassert op_div3_double([]) == []\nassert op_div3_double([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_double([5, 5, 5]) == []\nassert op_div3_double([3, 1, 2]) == [6]\nassert op_div3_double([10]) == []\nassert op_div3_double([2, 4, 6]) == [12]\nassert op_div3_double([-7, 12, -7]) == [24]"}
{"id": "op_lower_anyempty", "entry_point": "op_lower_anyempty", "primitives": ["lower", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then return whether any string is empty.", "solution": "def op_lower_anyempty(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_lower_anyempty(['Hello', 'world']) == False\nassert op_lower_anyempty([]) == False\nassert op_lower_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_lower_anyempty(['one', 'one', 'Two']) == False\nassert op_lower_anyempty(['x']) == False\nassert op_lower_anyempty(['abc', 'de', '']) == True"}
{"id": "op_sortalpha_longest", "entry_point": "op_sortalpha_longest", "primitives": ["sortalpha", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then return the longest string (empty if none).", "solution": "def op_sortalpha_longest(xs):\n    r = list(xs)\n    r = sorted(r)\n    return max(r, key=len) if r else ''", "tests": "assert op_sortalpha_longest(['Hello', 'world']) == 'Hello'\nassert op_sortalpha_longest([]) == ''\nassert op_sortalpha_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_sortalpha_longest(['one', 'one', 'Two']) == 'Two'\nassert op_sortalpha_longest(['x']) == 'x'\nassert op_sortalpha_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_beforezero_padto3", "entry_point": "op_beforezero_padto3", "primitives": ["beforezero", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements.", "solution": "def op_beforezero_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_padto3([]) == [0, 0, 0]\nassert op_beforezero_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_beforezero_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_padto3([10]) == [10, 0, 0]\nassert op_beforezero_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_neg", "entry_point": "op_rev_neg", "primitives": ["rev", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers.", "solution": "def op_rev_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_neg([1, 2, 3, 4]) == []\nassert op_rev_neg([]) == []\nassert op_rev_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_rev_neg([5, 5, 5]) == []\nassert op_rev_neg([3, 1, 2]) == []\nassert op_rev_neg([10]) == []\nassert op_rev_neg([2, 4, 6]) == []\nassert op_rev_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_sortabs", "entry_point": "op_evens_sortabs", "primitives": ["evens", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value.", "solution": "def op_evens_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_evens_sortabs([]) == []\nassert op_evens_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_evens_sortabs([5, 5, 5]) == []\nassert op_evens_sortabs([3, 1, 2]) == [2]\nassert op_evens_sortabs([10]) == [10]\nassert op_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_clamp10", "entry_point": "op_dropfirst_clamp10", "primitives": ["dropfirst", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10.", "solution": "def op_dropfirst_clamp10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropfirst_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_clamp10([]) == []\nassert op_dropfirst_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_clamp10([5, 5, 5]) == [5, 5]\nassert op_dropfirst_clamp10([3, 1, 2]) == [1, 2]\nassert op_dropfirst_clamp10([10]) == []\nassert op_dropfirst_clamp10([2, 4, 6]) == [4, 6]\nassert op_dropfirst_clamp10([-7, 12, -7]) == [10, -7]"}
{"id": "op_oremptyzero_negate", "entry_point": "op_oremptyzero_negate", "primitives": ["oremptyzero", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each.", "solution": "def op_oremptyzero_negate(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_oremptyzero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_oremptyzero_negate([]) == [0]\nassert op_oremptyzero_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_oremptyzero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_oremptyzero_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_oremptyzero_negate([10]) == [-10]\nassert op_oremptyzero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_oremptyzero_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_odds_negate", "entry_point": "op_odds_negate", "primitives": ["odds", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each.", "solution": "def op_odds_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_negate([]) == []\nassert op_odds_negate([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_negate([3, 1, 2]) == [-3, -1]\nassert op_odds_negate([10]) == []\nassert op_odds_negate([2, 4, 6]) == []\nassert op_odds_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_clamp10_counteven", "entry_point": "op_clamp10_counteven", "primitives": ["clamp10", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return how many values are even.", "solution": "def op_clamp10_counteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_clamp10_counteven([1, 2, 3, 4]) == 2\nassert op_clamp10_counteven([]) == 0\nassert op_clamp10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_clamp10_counteven([5, 5, 5]) == 0\nassert op_clamp10_counteven([3, 1, 2]) == 1\nassert op_clamp10_counteven([10]) == 1\nassert op_clamp10_counteven([2, 4, 6]) == 3\nassert op_clamp10_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_beforezero", "entry_point": "op_rev_beforezero", "primitives": ["rev", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero.", "solution": "def op_rev_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero([]) == []\nassert op_rev_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero([10]) == [10]\nassert op_rev_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_absval_sortabs", "entry_point": "op_absval_sortabs", "primitives": ["absval", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value.", "solution": "def op_absval_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_sortabs([]) == []\nassert op_absval_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_absval_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortabs([10]) == [10]\nassert op_absval_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_dec_min", "entry_point": "op_dec_min", "primitives": ["dec", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return the minimum (0 if empty).", "solution": "def op_dec_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dec_min([1, 2, 3, 4]) == 0\nassert op_dec_min([]) == 0\nassert op_dec_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_min([5, 5, 5]) == 4\nassert op_dec_min([3, 1, 2]) == 0\nassert op_dec_min([10]) == 9\nassert op_dec_min([2, 4, 6]) == 1\nassert op_dec_min([-7, 12, -7]) == -8"}
{"id": "op_takewhilepos_sorta", "entry_point": "op_takewhilepos_sorta", "primitives": ["takewhilepos", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending.", "solution": "def op_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_sorta([]) == []\nassert op_takewhilepos_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_sorta([10]) == [10]\nassert op_takewhilepos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_sorta([-7, 12, -7]) == []"}
{"id": "op_inc_pos", "entry_point": "op_inc_pos", "primitives": ["inc", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers.", "solution": "def op_inc_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_pos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_pos([]) == []\nassert op_inc_pos([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_pos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_pos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_pos([10]) == [11]\nassert op_inc_pos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_pos([-7, 12, -7]) == [13]"}
{"id": "op_inc_absval", "entry_point": "op_inc_absval", "primitives": ["inc", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each.", "solution": "def op_inc_absval(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_inc_absval([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_absval([]) == []\nassert op_inc_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2, 3]\nassert op_inc_absval([5, 5, 5]) == [6, 6, 6]\nassert op_inc_absval([3, 1, 2]) == [4, 2, 3]\nassert op_inc_absval([10]) == [11]\nassert op_inc_absval([2, 4, 6]) == [3, 5, 7]\nassert op_inc_absval([-7, 12, -7]) == [6, 13, 6]"}
{"id": "op_uniq_evens", "entry_point": "op_uniq_evens", "primitives": ["uniq", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_uniq_evens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_uniq_evens([1, 2, 3, 4]) == [2, 4]\nassert op_uniq_evens([]) == []\nassert op_uniq_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_uniq_evens([5, 5, 5]) == []\nassert op_uniq_evens([3, 1, 2]) == [2]\nassert op_uniq_evens([10]) == [10]\nassert op_uniq_evens([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_evens([-7, 12, -7]) == [12]"}
{"id": "op_negate_neg", "entry_point": "op_negate_neg", "primitives": ["negate", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers.", "solution": "def op_negate_neg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_negate_neg([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_neg([]) == []\nassert op_negate_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_negate_neg([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_neg([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_neg([10]) == [-10]\nassert op_negate_neg([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_neg([-7, 12, -7]) == [-12]"}
{"id": "op_square_dropwhileneg", "entry_point": "op_square_dropwhileneg", "primitives": ["square", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values.", "solution": "def op_square_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_dropwhileneg([]) == []\nassert op_square_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_square_dropwhileneg([10]) == [100]\nassert op_square_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_square_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_neg_absval", "entry_point": "op_neg_absval", "primitives": ["neg", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each.", "solution": "def op_neg_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_neg_absval([1, 2, 3, 4]) == []\nassert op_neg_absval([]) == []\nassert op_neg_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_absval([5, 5, 5]) == []\nassert op_neg_absval([3, 1, 2]) == []\nassert op_neg_absval([10]) == []\nassert op_neg_absval([2, 4, 6]) == []\nassert op_neg_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_neg_oremptyzero", "entry_point": "op_neg_oremptyzero", "primitives": ["neg", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero.", "solution": "def op_neg_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_neg_oremptyzero([]) == [0]\nassert op_neg_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_neg_oremptyzero([10]) == [0]\nassert op_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_neg_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_trimends", "entry_point": "op_beforezero_trimends", "primitives": ["beforezero", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements.", "solution": "def op_beforezero_trimends(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_beforezero_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_beforezero_trimends([]) == []\nassert op_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_trimends([5, 5, 5]) == [5]\nassert op_beforezero_trimends([3, 1, 2]) == [1]\nassert op_beforezero_trimends([10]) == []\nassert op_beforezero_trimends([2, 4, 6]) == [4]\nassert op_beforezero_trimends([-7, 12, -7]) == [12]"}
{"id": "op_double_evens", "entry_point": "op_double_evens", "primitives": ["double", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers.", "solution": "def op_double_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_evens([]) == []\nassert op_double_evens([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_evens([5, 5, 5]) == [10, 10, 10]\nassert op_double_evens([3, 1, 2]) == [6, 2, 4]\nassert op_double_evens([10]) == [20]\nassert op_double_evens([2, 4, 6]) == [4, 8, 12]\nassert op_double_evens([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dec_issorted", "entry_point": "op_dec_issorted", "primitives": ["dec", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return whether the list is sorted ascending.", "solution": "def op_dec_issorted(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_dec_issorted([1, 2, 3, 4]) == True\nassert op_dec_issorted([]) == True\nassert op_dec_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dec_issorted([5, 5, 5]) == True\nassert op_dec_issorted([3, 1, 2]) == False\nassert op_dec_issorted([10]) == True\nassert op_dec_issorted([2, 4, 6]) == True\nassert op_dec_issorted([-7, 12, -7]) == False"}
{"id": "op_ages_oremptyzero", "entry_point": "op_ages_oremptyzero", "primitives": ["ages", "oremptyzero"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero.", "solution": "def op_ages_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_oremptyzero([]) == [0]\nassert op_ages_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_uniq_dropzeros", "entry_point": "op_uniq_dropzeros", "primitives": ["uniq", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_uniq_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_dropzeros([]) == []\nassert op_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_uniq_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_dropzeros([10]) == [10]\nassert op_uniq_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_pos_add10", "entry_point": "op_pos_add10", "primitives": ["pos", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add ten to each.", "solution": "def op_pos_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_add10([]) == []\nassert op_pos_add10([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_add10([5, 5, 5]) == [15, 15, 15]\nassert op_pos_add10([3, 1, 2]) == [13, 11, 12]\nassert op_pos_add10([10]) == [20]\nassert op_pos_add10([2, 4, 6]) == [12, 14, 16]\nassert op_pos_add10([-7, 12, -7]) == [22]"}
{"id": "op_pos_neg", "entry_point": "op_pos_neg", "primitives": ["pos", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the negative numbers.", "solution": "def op_pos_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_pos_neg([1, 2, 3, 4]) == []\nassert op_pos_neg([]) == []\nassert op_pos_neg([-2, -1, 0, 1, 2]) == []\nassert op_pos_neg([5, 5, 5]) == []\nassert op_pos_neg([3, 1, 2]) == []\nassert op_pos_neg([10]) == []\nassert op_pos_neg([2, 4, 6]) == []\nassert op_pos_neg([-7, 12, -7]) == []"}
{"id": "op_dropfirst_dec", "entry_point": "op_dropfirst_dec", "primitives": ["dropfirst", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each.", "solution": "def op_dropfirst_dec(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropfirst_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_dec([]) == []\nassert op_dropfirst_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dropfirst_dec([5, 5, 5]) == [4, 4]\nassert op_dropfirst_dec([3, 1, 2]) == [0, 1]\nassert op_dropfirst_dec([10]) == []\nassert op_dropfirst_dec([2, 4, 6]) == [3, 5]\nassert op_dropfirst_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_double_dropwhileneg", "entry_point": "op_double_dropwhileneg", "primitives": ["double", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values.", "solution": "def op_double_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropwhileneg([]) == []\nassert op_double_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropwhileneg([3, 1, 2]) == [6, 2, 4]\nassert op_double_dropwhileneg([10]) == [20]\nassert op_double_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropwhileneg([-7, 12, -7]) == [24, -14]"}
{"id": "op_negate_dropfirst", "entry_point": "op_negate_dropfirst", "primitives": ["negate", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element.", "solution": "def op_negate_dropfirst(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_negate_dropfirst([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_dropfirst([]) == []\nassert op_negate_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_negate_dropfirst([5, 5, 5]) == [-5, -5]\nassert op_negate_dropfirst([3, 1, 2]) == [-1, -2]\nassert op_negate_dropfirst([10]) == []\nassert op_negate_dropfirst([2, 4, 6]) == [-4, -6]\nassert op_negate_dropfirst([-7, 12, -7]) == [-12, 7]"}
{"id": "op_clamp10_sorta", "entry_point": "op_clamp10_sorta", "primitives": ["clamp10", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending.", "solution": "def op_clamp10_sorta(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_clamp10_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sorta([]) == []\nassert op_clamp10_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sorta([10]) == [10]\nassert op_clamp10_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sorta([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_first3_inc", "entry_point": "op_first3_inc", "primitives": ["first3", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each.", "solution": "def op_first3_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_inc([1, 2, 3, 4]) == [2, 3, 4]\nassert op_first3_inc([]) == []\nassert op_first3_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_first3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_first3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_first3_inc([10]) == [11]\nassert op_first3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_first3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortabs_neg", "entry_point": "op_sortabs_neg", "primitives": ["sortabs", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers.", "solution": "def op_sortabs_neg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortabs_neg([1, 2, 3, 4]) == []\nassert op_sortabs_neg([]) == []\nassert op_sortabs_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_neg([5, 5, 5]) == []\nassert op_sortabs_neg([3, 1, 2]) == []\nassert op_sortabs_neg([10]) == []\nassert op_sortabs_neg([2, 4, 6]) == []\nassert op_sortabs_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropzeros_negate", "entry_point": "op_dropzeros_negate", "primitives": ["dropzeros", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each.", "solution": "def op_dropzeros_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropzeros_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropzeros_negate([]) == []\nassert op_dropzeros_negate([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_dropzeros_negate([10]) == [-10]\nassert op_dropzeros_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sortd_double", "entry_point": "op_sortd_double", "primitives": ["sortd", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each.", "solution": "def op_sortd_double(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortd_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_double([]) == []\nassert op_sortd_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_sortd_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_double([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_double([10]) == [20]\nassert op_sortd_double([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_double([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_negate_trimends", "entry_point": "op_negate_trimends", "primitives": ["negate", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first and last elements.", "solution": "def op_negate_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_negate_trimends([]) == []\nassert op_negate_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_negate_trimends([5, 5, 5]) == [-5]\nassert op_negate_trimends([3, 1, 2]) == [-1]\nassert op_negate_trimends([10]) == []\nassert op_negate_trimends([2, 4, 6]) == [-4]\nassert op_negate_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_absval_sorta", "entry_point": "op_absval_sorta", "primitives": ["absval", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending.", "solution": "def op_absval_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_sorta([]) == []\nassert op_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sorta([10]) == [10]\nassert op_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_square_first3", "entry_point": "op_square_first3", "primitives": ["square", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three.", "solution": "def op_square_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_square_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_square_first3([]) == []\nassert op_square_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_first3([5, 5, 5]) == [25, 25, 25]\nassert op_square_first3([3, 1, 2]) == [9, 1, 4]\nassert op_square_first3([10]) == [100]\nassert op_square_first3([2, 4, 6]) == [4, 16, 36]\nassert op_square_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_evens_dropwhileneg", "entry_point": "op_evens_dropwhileneg", "primitives": ["evens", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values.", "solution": "def op_evens_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_evens_dropwhileneg([1, 2, 3, 4]) == [2, 4]\nassert op_evens_dropwhileneg([]) == []\nassert op_evens_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropwhileneg([5, 5, 5]) == []\nassert op_evens_dropwhileneg([3, 1, 2]) == [2]\nassert op_evens_dropwhileneg([10]) == [10]\nassert op_evens_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_evens_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_gt5_sortabs", "entry_point": "op_gt5_sortabs", "primitives": ["gt5", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value.", "solution": "def op_gt5_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_sortabs([]) == []\nassert op_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs([5, 5, 5]) == []\nassert op_gt5_sortabs([3, 1, 2]) == []\nassert op_gt5_sortabs([10]) == [10]\nassert op_gt5_sortabs([2, 4, 6]) == [6]\nassert op_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_inc_gt5", "entry_point": "op_inc_gt5", "primitives": ["inc", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five.", "solution": "def op_inc_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_gt5([1, 2, 3, 4]) == []\nassert op_inc_gt5([]) == []\nassert op_inc_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_inc_gt5([3, 1, 2]) == []\nassert op_inc_gt5([10]) == [11]\nassert op_inc_gt5([2, 4, 6]) == [7]\nassert op_inc_gt5([-7, 12, -7]) == [13]"}
{"id": "op_strip_maxlen", "entry_point": "op_strip_maxlen", "primitives": ["strip", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then return the length of the longest string (0 if none).", "solution": "def op_strip_maxlen(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_strip_maxlen(['Hello', 'world']) == 5\nassert op_strip_maxlen([]) == 0\nassert op_strip_maxlen(['  a ', '', 'BC', 'bc']) == 2\nassert op_strip_maxlen(['one', 'one', 'Two']) == 3\nassert op_strip_maxlen(['x']) == 1\nassert op_strip_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_negate_anyeven", "entry_point": "op_negate_anyeven", "primitives": ["negate", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return whether any value is even.", "solution": "def op_negate_anyeven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_negate_anyeven([1, 2, 3, 4]) == True\nassert op_negate_anyeven([]) == False\nassert op_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_negate_anyeven([5, 5, 5]) == False\nassert op_negate_anyeven([3, 1, 2]) == True\nassert op_negate_anyeven([10]) == True\nassert op_negate_anyeven([2, 4, 6]) == True\nassert op_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortage_oldest", "entry_point": "op_sortage_oldest", "primitives": ["sortage", "oldest"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then return the name of the oldest person (empty if none).", "solution": "def op_sortage_oldest(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    return max(r, key=lambda d: d['age'])['name'] if r else ''", "tests": "assert op_sortage_oldest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada'\nassert op_sortage_oldest([]) == ''\nassert op_sortage_oldest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Dee'\nassert op_sortage_oldest([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_pos_issorted", "entry_point": "op_pos_issorted", "primitives": ["pos", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_pos_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_pos_issorted([1, 2, 3, 4]) == True\nassert op_pos_issorted([]) == True\nassert op_pos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_pos_issorted([5, 5, 5]) == True\nassert op_pos_issorted([3, 1, 2]) == False\nassert op_pos_issorted([10]) == True\nassert op_pos_issorted([2, 4, 6]) == True\nassert op_pos_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_gt5", "entry_point": "op_sorta_gt5", "primitives": ["sorta", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five.", "solution": "def op_sorta_gt5(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sorta_gt5([1, 2, 3, 4]) == []\nassert op_sorta_gt5([]) == []\nassert op_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sorta_gt5([5, 5, 5]) == []\nassert op_sorta_gt5([3, 1, 2]) == []\nassert op_sorta_gt5([10]) == [10]\nassert op_sorta_gt5([2, 4, 6]) == [6]\nassert op_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_square", "entry_point": "op_dropwhileneg_square", "primitives": ["dropwhileneg", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each.", "solution": "def op_dropwhileneg_square(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropwhileneg_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropwhileneg_square([]) == []\nassert op_dropwhileneg_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropwhileneg_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_square([10]) == [100]\nassert op_dropwhileneg_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_takewhilepos_add10", "entry_point": "op_takewhilepos_add10", "primitives": ["takewhilepos", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each.", "solution": "def op_takewhilepos_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_takewhilepos_add10([]) == []\nassert op_takewhilepos_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_add10([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_add10([3, 1, 2]) == [13, 11, 12]\nassert op_takewhilepos_add10([10]) == [20]\nassert op_takewhilepos_add10([2, 4, 6]) == [12, 14, 16]\nassert op_takewhilepos_add10([-7, 12, -7]) == []"}
{"id": "op_square_firsteven", "entry_point": "op_square_firsteven", "primitives": ["square", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then return the first even value (0 if none).", "solution": "def op_square_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_firsteven([1, 2, 3, 4]) == 4\nassert op_square_firsteven([]) == 0\nassert op_square_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_square_firsteven([5, 5, 5]) == 0\nassert op_square_firsteven([3, 1, 2]) == 4\nassert op_square_firsteven([10]) == 100\nassert op_square_firsteven([2, 4, 6]) == 4\nassert op_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_takewhilepos_gt5", "entry_point": "op_takewhilepos_gt5", "primitives": ["takewhilepos", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five.", "solution": "def op_takewhilepos_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5([]) == []\nassert op_takewhilepos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5([5, 5, 5]) == []\nassert op_takewhilepos_gt5([3, 1, 2]) == []\nassert op_takewhilepos_gt5([10]) == [10]\nassert op_takewhilepos_gt5([2, 4, 6]) == [6]\nassert op_takewhilepos_gt5([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_haszero", "entry_point": "op_oremptyzero_haszero", "primitives": ["oremptyzero", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_haszero([]) == True\nassert op_oremptyzero_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_haszero([5, 5, 5]) == False\nassert op_oremptyzero_haszero([3, 1, 2]) == False\nassert op_oremptyzero_haszero([10]) == False\nassert op_oremptyzero_haszero([2, 4, 6]) == False\nassert op_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_upper_dropshort", "entry_point": "op_upper_dropshort", "primitives": ["upper", "dropshort"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop strings shorter than three characters.", "solution": "def op_upper_dropshort(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_upper_dropshort(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_dropshort([]) == []\nassert op_upper_dropshort(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_upper_dropshort(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_dropshort(['x']) == []\nassert op_upper_dropshort(['abc', 'de', '']) == ['ABC']"}
{"id": "op_absval_max", "entry_point": "op_absval_max", "primitives": ["absval", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_absval_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_absval_max([1, 2, 3, 4]) == 4\nassert op_absval_max([]) == 0\nassert op_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_absval_max([5, 5, 5]) == 5\nassert op_absval_max([3, 1, 2]) == 3\nassert op_absval_max([10]) == 10\nassert op_absval_max([2, 4, 6]) == 6\nassert op_absval_max([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_square", "entry_point": "op_oremptyzero_square", "primitives": ["oremptyzero", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each.", "solution": "def op_oremptyzero_square(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_oremptyzero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_oremptyzero_square([]) == [0]\nassert op_oremptyzero_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_oremptyzero_square([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_square([3, 1, 2]) == [9, 1, 4]\nassert op_oremptyzero_square([10]) == [100]\nassert op_oremptyzero_square([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_evens_negate", "entry_point": "op_evens_negate", "primitives": ["evens", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then negate each.", "solution": "def op_evens_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_evens_negate([]) == []\nassert op_evens_negate([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_negate([5, 5, 5]) == []\nassert op_evens_negate([3, 1, 2]) == [-2]\nassert op_evens_negate([10]) == [-10]\nassert op_evens_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_evens_negate([-7, 12, -7]) == [-12]"}
{"id": "op_neg_dec", "entry_point": "op_neg_dec", "primitives": ["neg", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each.", "solution": "def op_neg_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_neg_dec([1, 2, 3, 4]) == []\nassert op_neg_dec([]) == []\nassert op_neg_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_neg_dec([5, 5, 5]) == []\nassert op_neg_dec([3, 1, 2]) == []\nassert op_neg_dec([10]) == []\nassert op_neg_dec([2, 4, 6]) == []\nassert op_neg_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_last3_rev", "entry_point": "op_last3_rev", "primitives": ["last3", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order.", "solution": "def op_last3_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_rev([]) == []\nassert op_last3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_rev([10]) == [10]\nassert op_last3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_clamp10_haszero", "entry_point": "op_clamp10_haszero", "primitives": ["clamp10", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return whether the list contains a zero.", "solution": "def op_clamp10_haszero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_clamp10_haszero([]) == False\nassert op_clamp10_haszero([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_haszero([5, 5, 5]) == False\nassert op_clamp10_haszero([3, 1, 2]) == False\nassert op_clamp10_haszero([10]) == False\nassert op_clamp10_haszero([2, 4, 6]) == False\nassert op_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_square_rev", "entry_point": "op_square_rev", "primitives": ["square", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then reverse the order.", "solution": "def op_square_rev(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_square_rev([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_rev([]) == []\nassert op_square_rev([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_rev([5, 5, 5]) == [25, 25, 25]\nassert op_square_rev([3, 1, 2]) == [4, 1, 9]\nassert op_square_rev([10]) == [100]\nassert op_square_rev([2, 4, 6]) == [36, 16, 4]\nassert op_square_rev([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_oremptyzero_clamp10", "entry_point": "op_oremptyzero_clamp10", "primitives": ["oremptyzero", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10.", "solution": "def op_oremptyzero_clamp10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_oremptyzero_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_clamp10([]) == [0]\nassert op_oremptyzero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_clamp10([10]) == [10]\nassert op_oremptyzero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_square_uniq", "entry_point": "op_square_uniq", "primitives": ["square", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence.", "solution": "def op_square_uniq(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_square_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_uniq([]) == []\nassert op_square_uniq([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_uniq([5, 5, 5]) == [25]\nassert op_square_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_square_uniq([10]) == [100]\nassert op_square_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_square_uniq([-7, 12, -7]) == [49, 144]"}
{"id": "op_neg_dropzeros", "entry_point": "op_neg_dropzeros", "primitives": ["neg", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros.", "solution": "def op_neg_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_neg_dropzeros([]) == []\nassert op_neg_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_dropzeros([5, 5, 5]) == []\nassert op_neg_dropzeros([3, 1, 2]) == []\nassert op_neg_dropzeros([10]) == []\nassert op_neg_dropzeros([2, 4, 6]) == []\nassert op_neg_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropfirst_rev", "entry_point": "op_dropfirst_rev", "primitives": ["dropfirst", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order.", "solution": "def op_dropfirst_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev([]) == []\nassert op_dropfirst_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_rev([5, 5, 5]) == [5, 5]\nassert op_dropfirst_rev([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev([10]) == []\nassert op_dropfirst_rev([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_prefixup_nonempty", "entry_point": "op_prefixup_nonempty", "primitives": ["prefixup", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop empty strings.", "solution": "def op_prefixup_nonempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_prefixup_nonempty(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_nonempty([]) == []\nassert op_prefixup_nonempty(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#BC', '#bc']\nassert op_prefixup_nonempty(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup_nonempty(['x']) == ['#x']\nassert op_prefixup_nonempty(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_absval_dropfirst", "entry_point": "op_absval_dropfirst", "primitives": ["absval", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first element.", "solution": "def op_absval_dropfirst(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_absval_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_dropfirst([]) == []\nassert op_absval_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_absval_dropfirst([5, 5, 5]) == [5, 5]\nassert op_absval_dropfirst([3, 1, 2]) == [1, 2]\nassert op_absval_dropfirst([10]) == []\nassert op_absval_dropfirst([2, 4, 6]) == [4, 6]\nassert op_absval_dropfirst([-7, 12, -7]) == [12, 7]"}
{"id": "op_prefixup_maxlen", "entry_point": "op_prefixup_maxlen", "primitives": ["prefixup", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then return the length of the longest string (0 if none).", "solution": "def op_prefixup_maxlen(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_prefixup_maxlen(['Hello', 'world']) == 6\nassert op_prefixup_maxlen([]) == 0\nassert op_prefixup_maxlen(['  a ', '', 'BC', 'bc']) == 5\nassert op_prefixup_maxlen(['one', 'one', 'Two']) == 4\nassert op_prefixup_maxlen(['x']) == 2\nassert op_prefixup_maxlen(['abc', 'de', '']) == 4"}
{"id": "op_evens_sorta", "entry_point": "op_evens_sorta", "primitives": ["evens", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending.", "solution": "def op_evens_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_evens_sorta([1, 2, 3, 4]) == [2, 4]\nassert op_evens_sorta([]) == []\nassert op_evens_sorta([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_sorta([5, 5, 5]) == []\nassert op_evens_sorta([3, 1, 2]) == [2]\nassert op_evens_sorta([10]) == [10]\nassert op_evens_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_evens_sorta([-7, 12, -7]) == [12]"}
{"id": "op_double_last3", "entry_point": "op_double_last3", "primitives": ["double", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three.", "solution": "def op_double_last3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_double_last3([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_last3([]) == []\nassert op_double_last3([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_last3([5, 5, 5]) == [10, 10, 10]\nassert op_double_last3([3, 1, 2]) == [6, 2, 4]\nassert op_double_last3([10]) == [20]\nassert op_double_last3([2, 4, 6]) == [4, 8, 12]\nassert op_double_last3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_negate_alldistinct", "entry_point": "op_negate_alldistinct", "primitives": ["negate", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return whether all values are distinct.", "solution": "def op_negate_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_negate_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_alldistinct([]) == True\nassert op_negate_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_alldistinct([5, 5, 5]) == False\nassert op_negate_alldistinct([3, 1, 2]) == True\nassert op_negate_alldistinct([10]) == True\nassert op_negate_alldistinct([2, 4, 6]) == True\nassert op_negate_alldistinct([-7, 12, -7]) == False"}
{"id": "op_negate_allpos", "entry_point": "op_negate_allpos", "primitives": ["negate", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return whether all values are positive.", "solution": "def op_negate_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_negate_allpos([1, 2, 3, 4]) == False\nassert op_negate_allpos([]) == True\nassert op_negate_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_allpos([5, 5, 5]) == False\nassert op_negate_allpos([3, 1, 2]) == False\nassert op_negate_allpos([10]) == False\nassert op_negate_allpos([2, 4, 6]) == False\nassert op_negate_allpos([-7, 12, -7]) == False"}
{"id": "op_uniqs_anyempty", "entry_point": "op_uniqs_anyempty", "primitives": ["uniqs", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_uniqs_anyempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_uniqs_anyempty(['Hello', 'world']) == False\nassert op_uniqs_anyempty([]) == False\nassert op_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_uniqs_anyempty(['x']) == False\nassert op_uniqs_anyempty(['abc', 'de', '']) == True"}
{"id": "op_upper_anyempty", "entry_point": "op_upper_anyempty", "primitives": ["upper", "anyempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then return whether any string is empty.", "solution": "def op_upper_anyempty(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_upper_anyempty(['Hello', 'world']) == False\nassert op_upper_anyempty([]) == False\nassert op_upper_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_upper_anyempty(['one', 'one', 'Two']) == False\nassert op_upper_anyempty(['x']) == False\nassert op_upper_anyempty(['abc', 'de', '']) == True"}
{"id": "op_takewhilepos_dropwhileneg", "entry_point": "op_takewhilepos_dropwhileneg", "primitives": ["takewhilepos", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values.", "solution": "def op_takewhilepos_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_dropwhileneg([]) == []\nassert op_takewhilepos_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropwhileneg([10]) == [10]\nassert op_takewhilepos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_div3_issorted", "entry_point": "op_div3_issorted", "primitives": ["div3", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_div3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_div3_issorted([1, 2, 3, 4]) == True\nassert op_div3_issorted([]) == True\nassert op_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_div3_issorted([5, 5, 5]) == True\nassert op_div3_issorted([3, 1, 2]) == True\nassert op_div3_issorted([10]) == True\nassert op_div3_issorted([2, 4, 6]) == True\nassert op_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_odds_anyeven", "entry_point": "op_odds_anyeven", "primitives": ["odds", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return whether any value is even.", "solution": "def op_odds_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_odds_anyeven([1, 2, 3, 4]) == False\nassert op_odds_anyeven([]) == False\nassert op_odds_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_odds_anyeven([5, 5, 5]) == False\nassert op_odds_anyeven([3, 1, 2]) == False\nassert op_odds_anyeven([10]) == False\nassert op_odds_anyeven([2, 4, 6]) == False\nassert op_odds_anyeven([-7, 12, -7]) == False"}
{"id": "op_absval_evens", "entry_point": "op_absval_evens", "primitives": ["absval", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers.", "solution": "def op_absval_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_evens([1, 2, 3, 4]) == [2, 4]\nassert op_absval_evens([]) == []\nassert op_absval_evens([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_absval_evens([5, 5, 5]) == []\nassert op_absval_evens([3, 1, 2]) == [2]\nassert op_absval_evens([10]) == [10]\nassert op_absval_evens([2, 4, 6]) == [2, 4, 6]\nassert op_absval_evens([-7, 12, -7]) == [12]"}
{"id": "op_padto3_add10", "entry_point": "op_padto3_add10", "primitives": ["padto3", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each.", "solution": "def op_padto3_add10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_padto3_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_padto3_add10([]) == [10, 10, 10]\nassert op_padto3_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_padto3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_padto3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_padto3_add10([10]) == [20, 10, 10]\nassert op_padto3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_padto3_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_inc_min", "entry_point": "op_inc_min", "primitives": ["inc", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then return the minimum (0 if empty).", "solution": "def op_inc_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_inc_min([1, 2, 3, 4]) == 2\nassert op_inc_min([]) == 0\nassert op_inc_min([-2, -1, 0, 1, 2]) == -1\nassert op_inc_min([5, 5, 5]) == 6\nassert op_inc_min([3, 1, 2]) == 2\nassert op_inc_min([10]) == 11\nassert op_inc_min([2, 4, 6]) == 3\nassert op_inc_min([-7, 12, -7]) == -6"}
{"id": "op_takewhilepos_prod", "entry_point": "op_takewhilepos_prod", "primitives": ["takewhilepos", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return their product.", "solution": "def op_takewhilepos_prod(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_takewhilepos_prod([1, 2, 3, 4]) == 24\nassert op_takewhilepos_prod([]) == 1\nassert op_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_takewhilepos_prod([5, 5, 5]) == 125\nassert op_takewhilepos_prod([3, 1, 2]) == 6\nassert op_takewhilepos_prod([10]) == 10\nassert op_takewhilepos_prod([2, 4, 6]) == 48\nassert op_takewhilepos_prod([-7, 12, -7]) == 1"}
{"id": "op_negate_uniq", "entry_point": "op_negate_uniq", "primitives": ["negate", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence.", "solution": "def op_negate_uniq(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_negate_uniq([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_uniq([]) == []\nassert op_negate_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_uniq([5, 5, 5]) == [-5]\nassert op_negate_uniq([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_uniq([10]) == [-10]\nassert op_negate_uniq([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_uniq([-7, 12, -7]) == [7, -12]"}
{"id": "op_sortd_dropwhileneg", "entry_point": "op_sortd_dropwhileneg", "primitives": ["sortd", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values.", "solution": "def op_sortd_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_dropwhileneg([]) == []\nassert op_sortd_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropwhileneg([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropwhileneg([10]) == [10]\nassert op_sortd_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropwhileneg([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_padto3_pos", "entry_point": "op_padto3_pos", "primitives": ["padto3", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers.", "solution": "def op_padto3_pos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_padto3_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_pos([]) == []\nassert op_padto3_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_pos([10]) == [10]\nassert op_padto3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_pos([-7, 12, -7]) == [12]"}
{"id": "op_last3_clamp10", "entry_point": "op_last3_clamp10", "primitives": ["last3", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10.", "solution": "def op_last3_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_clamp10([]) == []\nassert op_last3_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_last3_clamp10([10]) == [10]\nassert op_last3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_last3_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_upper_counts", "entry_point": "op_upper_counts", "primitives": ["upper", "counts"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then return how many strings remain.", "solution": "def op_upper_counts(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return len(r)", "tests": "assert op_upper_counts(['Hello', 'world']) == 2\nassert op_upper_counts([]) == 0\nassert op_upper_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_upper_counts(['one', 'one', 'Two']) == 3\nassert op_upper_counts(['x']) == 1\nassert op_upper_counts(['abc', 'de', '']) == 3"}
{"id": "op_sorta_odds", "entry_point": "op_sorta_odds", "primitives": ["sorta", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers.", "solution": "def op_sorta_odds(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sorta_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sorta_odds([]) == []\nassert op_sorta_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sorta_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_odds([3, 1, 2]) == [1, 3]\nassert op_sorta_odds([10]) == []\nassert op_sorta_odds([2, 4, 6]) == []\nassert op_sorta_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sorta_max", "entry_point": "op_sorta_max", "primitives": ["sorta", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return the maximum (0 if empty).", "solution": "def op_sorta_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_sorta_max([1, 2, 3, 4]) == 4\nassert op_sorta_max([]) == 0\nassert op_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_max([5, 5, 5]) == 5\nassert op_sorta_max([3, 1, 2]) == 3\nassert op_sorta_max([10]) == 10\nassert op_sorta_max([2, 4, 6]) == 6\nassert op_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_evens_padto3", "entry_point": "op_evens_padto3", "primitives": ["evens", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_evens_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_evens_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_evens_padto3([]) == [0, 0, 0]\nassert op_evens_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_evens_padto3([10]) == [10, 0, 0]\nassert op_evens_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_names_counts", "entry_point": "op_names_counts", "primitives": ["names", "counts"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then return how many strings remain.", "solution": "def op_names_counts(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return len(r)", "tests": "assert op_names_counts([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_names_counts([]) == 0\nassert op_names_counts([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_names_counts([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_add10_uniq", "entry_point": "op_add10_uniq", "primitives": ["add10", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_add10_uniq(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_add10_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_uniq([]) == []\nassert op_add10_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_uniq([5, 5, 5]) == [15]\nassert op_add10_uniq([3, 1, 2]) == [13, 11, 12]\nassert op_add10_uniq([10]) == [20]\nassert op_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_firstchar_longest", "entry_point": "op_firstchar_longest", "primitives": ["firstchar", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_firstchar_longest(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_firstchar_longest(['Hello', 'world']) == 'H'\nassert op_firstchar_longest([]) == ''\nassert op_firstchar_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_firstchar_longest(['one', 'one', 'Two']) == 'o'\nassert op_firstchar_longest(['x']) == 'x'\nassert op_firstchar_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_pos_sortabs", "entry_point": "op_pos_sortabs", "primitives": ["pos", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value.", "solution": "def op_pos_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_pos_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_sortabs([]) == []\nassert op_pos_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_pos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_pos_sortabs([10]) == [10]\nassert op_pos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_inc", "entry_point": "op_oremptyzero_inc", "primitives": ["oremptyzero", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each.", "solution": "def op_oremptyzero_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_oremptyzero_inc([]) == [1]\nassert op_oremptyzero_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_oremptyzero_inc([10]) == [11]\nassert op_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_oremptyzero_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_names_lower", "entry_point": "op_names_lower", "primitives": ["names", "lower"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then lowercase each string.", "solution": "def op_names_lower(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_names_lower([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['ada', 'bo']\nassert op_names_lower([]) == []\nassert op_names_lower([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['cy', 'dee', 'el']\nassert op_names_lower([{'name': 'Fi', 'age': 41}]) == ['fi']"}
{"id": "op_sortabs_takewhilepos", "entry_point": "op_sortabs_takewhilepos", "primitives": ["sortabs", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive.", "solution": "def op_sortabs_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortabs_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_takewhilepos([]) == []\nassert op_sortabs_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_takewhilepos([10]) == [10]\nassert op_sortabs_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_issorted", "entry_point": "op_oremptyzero_issorted", "primitives": ["oremptyzero", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return r == sorted(r)", "tests": "assert op_oremptyzero_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_issorted([]) == True\nassert op_oremptyzero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_issorted([5, 5, 5]) == True\nassert op_oremptyzero_issorted([3, 1, 2]) == False\nassert op_oremptyzero_issorted([10]) == True\nassert op_oremptyzero_issorted([2, 4, 6]) == True\nassert op_oremptyzero_issorted([-7, 12, -7]) == False"}
{"id": "op_rev_anyeven", "entry_point": "op_rev_anyeven", "primitives": ["rev", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return whether any value is even.", "solution": "def op_rev_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_anyeven([1, 2, 3, 4]) == True\nassert op_rev_anyeven([]) == False\nassert op_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_anyeven([5, 5, 5]) == False\nassert op_rev_anyeven([3, 1, 2]) == True\nassert op_rev_anyeven([10]) == True\nassert op_rev_anyeven([2, 4, 6]) == True\nassert op_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_first3_len", "entry_point": "op_first3_len", "primitives": ["first3", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return how many remain.", "solution": "def op_first3_len(xs):\n    r = list(xs)\n    r = r[:3]\n    return len(r)", "tests": "assert op_first3_len([1, 2, 3, 4]) == 3\nassert op_first3_len([]) == 0\nassert op_first3_len([-2, -1, 0, 1, 2]) == 3\nassert op_first3_len([5, 5, 5]) == 3\nassert op_first3_len([3, 1, 2]) == 3\nassert op_first3_len([10]) == 1\nassert op_first3_len([2, 4, 6]) == 3\nassert op_first3_len([-7, 12, -7]) == 3"}
{"id": "op_trimends_oremptyzero", "entry_point": "op_trimends_oremptyzero", "primitives": ["trimends", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero.", "solution": "def op_trimends_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_oremptyzero([]) == [0]\nassert op_trimends_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_oremptyzero([5, 5, 5]) == [5]\nassert op_trimends_oremptyzero([3, 1, 2]) == [1]\nassert op_trimends_oremptyzero([10]) == [0]\nassert op_trimends_oremptyzero([2, 4, 6]) == [4]\nassert op_trimends_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_neg_beforezero", "entry_point": "op_neg_beforezero", "primitives": ["neg", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero.", "solution": "def op_neg_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_beforezero([1, 2, 3, 4]) == []\nassert op_neg_beforezero([]) == []\nassert op_neg_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_beforezero([5, 5, 5]) == []\nassert op_neg_beforezero([3, 1, 2]) == []\nassert op_neg_beforezero([10]) == []\nassert op_neg_beforezero([2, 4, 6]) == []\nassert op_neg_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_alldistinct", "entry_point": "op_pos_alldistinct", "primitives": ["pos", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return whether all values are distinct.", "solution": "def op_pos_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_pos_alldistinct([]) == True\nassert op_pos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_pos_alldistinct([5, 5, 5]) == False\nassert op_pos_alldistinct([3, 1, 2]) == True\nassert op_pos_alldistinct([10]) == True\nassert op_pos_alldistinct([2, 4, 6]) == True\nassert op_pos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dec_anyeven", "entry_point": "op_dec_anyeven", "primitives": ["dec", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return whether any value is even.", "solution": "def op_dec_anyeven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dec_anyeven([1, 2, 3, 4]) == True\nassert op_dec_anyeven([]) == False\nassert op_dec_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dec_anyeven([5, 5, 5]) == True\nassert op_dec_anyeven([3, 1, 2]) == True\nassert op_dec_anyeven([10]) == False\nassert op_dec_anyeven([2, 4, 6]) == False\nassert op_dec_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_neg", "entry_point": "op_trimends_neg", "primitives": ["trimends", "neg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers.", "solution": "def op_trimends_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_neg([1, 2, 3, 4]) == []\nassert op_trimends_neg([]) == []\nassert op_trimends_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_neg([5, 5, 5]) == []\nassert op_trimends_neg([3, 1, 2]) == []\nassert op_trimends_neg([10]) == []\nassert op_trimends_neg([2, 4, 6]) == []\nassert op_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_rev_oremptyzero", "entry_point": "op_rev_oremptyzero", "primitives": ["rev", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero.", "solution": "def op_rev_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero([]) == [0]\nassert op_rev_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero([10]) == [10]\nassert op_rev_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_uniq_sum", "entry_point": "op_uniq_sum", "primitives": ["uniq", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_uniq_sum(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_uniq_sum([1, 2, 3, 4]) == 10\nassert op_uniq_sum([]) == 0\nassert op_uniq_sum([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_sum([5, 5, 5]) == 5\nassert op_uniq_sum([3, 1, 2]) == 6\nassert op_uniq_sum([10]) == 10\nassert op_uniq_sum([2, 4, 6]) == 12\nassert op_uniq_sum([-7, 12, -7]) == 5"}
{"id": "op_last3_absval", "entry_point": "op_last3_absval", "primitives": ["last3", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each.", "solution": "def op_last3_absval(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_absval([]) == []\nassert op_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_last3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_last3_absval([10]) == [10]\nassert op_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_last3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_gt5_pos", "entry_point": "op_gt5_pos", "primitives": ["gt5", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers.", "solution": "def op_gt5_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_pos([1, 2, 3, 4]) == []\nassert op_gt5_pos([]) == []\nassert op_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos([5, 5, 5]) == []\nassert op_gt5_pos([3, 1, 2]) == []\nassert op_gt5_pos([10]) == [10]\nassert op_gt5_pos([2, 4, 6]) == [6]\nassert op_gt5_pos([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_pos", "entry_point": "op_clamp10_pos", "primitives": ["clamp10", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the positive numbers.", "solution": "def op_clamp10_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_pos([]) == []\nassert op_clamp10_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_pos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_pos([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_pos([10]) == [10]\nassert op_clamp10_pos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_pos([-7, 12, -7]) == [10]"}
{"id": "op_ages_negate", "entry_point": "op_ages_negate", "primitives": ["ages", "negate"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each.", "solution": "def op_ages_negate(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_ages_negate([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_negate([]) == []\nassert op_ages_negate([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_negate([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_dropzeros_len", "entry_point": "op_dropzeros_len", "primitives": ["dropzeros", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return how many remain.", "solution": "def op_dropzeros_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_dropzeros_len([1, 2, 3, 4]) == 4\nassert op_dropzeros_len([]) == 0\nassert op_dropzeros_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_len([5, 5, 5]) == 3\nassert op_dropzeros_len([3, 1, 2]) == 3\nassert op_dropzeros_len([10]) == 1\nassert op_dropzeros_len([2, 4, 6]) == 3\nassert op_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_square_sortabs", "entry_point": "op_square_sortabs", "primitives": ["square", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value.", "solution": "def op_square_sortabs(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_square_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sortabs([]) == []\nassert op_square_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_square_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_square_sortabs([10]) == [100]\nassert op_square_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_square_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_first3_add10", "entry_point": "op_first3_add10", "primitives": ["first3", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each.", "solution": "def op_first3_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_add10([1, 2, 3, 4]) == [11, 12, 13]\nassert op_first3_add10([]) == []\nassert op_first3_add10([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_first3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_first3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_first3_add10([10]) == [20]\nassert op_first3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_first3_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_first3_last3", "entry_point": "op_first3_last3", "primitives": ["first3", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three.", "solution": "def op_first3_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_last3([]) == []\nassert op_first3_last3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_last3([10]) == [10]\nassert op_first3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropwhileneg_negate", "entry_point": "op_dropwhileneg_negate", "primitives": ["dropwhileneg", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each.", "solution": "def op_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropwhileneg_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropwhileneg_negate([]) == []\nassert op_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_dropwhileneg_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_dropwhileneg_negate([10]) == [-10]\nassert op_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_padto3_div3", "entry_point": "op_padto3_div3", "primitives": ["padto3", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep multiples of three.", "solution": "def op_padto3_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_div3([]) == [0, 0, 0]\nassert op_padto3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_div3([5, 5, 5]) == []\nassert op_padto3_div3([3, 1, 2]) == [3]\nassert op_padto3_div3([10]) == [0, 0]\nassert op_padto3_div3([2, 4, 6]) == [6]\nassert op_padto3_div3([-7, 12, -7]) == [12]"}
{"id": "op_padto3_square", "entry_point": "op_padto3_square", "primitives": ["padto3", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each.", "solution": "def op_padto3_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_padto3_square([]) == [0, 0, 0]\nassert op_padto3_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_padto3_square([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_square([3, 1, 2]) == [9, 1, 4]\nassert op_padto3_square([10]) == [100, 0, 0]\nassert op_padto3_square([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_inc_sortabs", "entry_point": "op_inc_sortabs", "primitives": ["inc", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value.", "solution": "def op_inc_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_sortabs([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sortabs([]) == []\nassert op_inc_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, 2, 3]\nassert op_inc_sortabs([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortabs([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sortabs([10]) == [11]\nassert op_inc_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sortabs([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_prefixup_counts", "entry_point": "op_prefixup_counts", "primitives": ["prefixup", "counts"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then return how many strings remain.", "solution": "def op_prefixup_counts(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return len(r)", "tests": "assert op_prefixup_counts(['Hello', 'world']) == 2\nassert op_prefixup_counts([]) == 0\nassert op_prefixup_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_prefixup_counts(['one', 'one', 'Two']) == 3\nassert op_prefixup_counts(['x']) == 1\nassert op_prefixup_counts(['abc', 'de', '']) == 3"}
{"id": "op_beforezero_sortd", "entry_point": "op_beforezero_sortd", "primitives": ["beforezero", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort descending.", "solution": "def op_beforezero_sortd(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_beforezero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_sortd([]) == []\nassert op_beforezero_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_beforezero_sortd([10]) == [10]\nassert op_beforezero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_odds_inc", "entry_point": "op_odds_inc", "primitives": ["odds", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each.", "solution": "def op_odds_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_odds_inc([1, 2, 3, 4]) == [2, 4]\nassert op_odds_inc([]) == []\nassert op_odds_inc([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_odds_inc([5, 5, 5]) == [6, 6, 6]\nassert op_odds_inc([3, 1, 2]) == [4, 2]\nassert op_odds_inc([10]) == []\nassert op_odds_inc([2, 4, 6]) == []\nassert op_odds_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_ages_dropfirst", "entry_point": "op_ages_dropfirst", "primitives": ["ages", "dropfirst"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element.", "solution": "def op_ages_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    return r", "tests": "assert op_ages_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst([]) == []\nassert op_ages_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sortabs_rev", "entry_point": "op_sortabs_rev", "primitives": ["sortabs", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order.", "solution": "def op_sortabs_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_rev([]) == []\nassert op_sortabs_rev([-2, -1, 0, 1, 2]) == [2, -2, 1, -1, 0]\nassert op_sortabs_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_rev([10]) == [10]\nassert op_sortabs_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_names_uniqs", "entry_point": "op_names_uniqs", "primitives": ["names", "uniqs"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop duplicate strings keeping the first.", "solution": "def op_names_uniqs(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_names_uniqs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_uniqs([]) == []\nassert op_names_uniqs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_uniqs([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_sorta_dropzeros", "entry_point": "op_sorta_dropzeros", "primitives": ["sorta", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros.", "solution": "def op_sorta_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropzeros([]) == []\nassert op_sorta_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_sorta_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropzeros([10]) == [10]\nassert op_sorta_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_double_issorted", "entry_point": "op_double_issorted", "primitives": ["double", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return whether the list is sorted ascending.", "solution": "def op_double_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_double_issorted([1, 2, 3, 4]) == True\nassert op_double_issorted([]) == True\nassert op_double_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_issorted([5, 5, 5]) == True\nassert op_double_issorted([3, 1, 2]) == False\nassert op_double_issorted([10]) == True\nassert op_double_issorted([2, 4, 6]) == True\nassert op_double_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_double", "entry_point": "op_dropzeros_double", "primitives": ["dropzeros", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each.", "solution": "def op_dropzeros_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double([]) == []\nassert op_dropzeros_double([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_double([10]) == [20]\nassert op_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_gt5_dec", "entry_point": "op_gt5_dec", "primitives": ["gt5", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each.", "solution": "def op_gt5_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_gt5_dec([1, 2, 3, 4]) == []\nassert op_gt5_dec([]) == []\nassert op_gt5_dec([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dec([5, 5, 5]) == []\nassert op_gt5_dec([3, 1, 2]) == []\nassert op_gt5_dec([10]) == [9]\nassert op_gt5_dec([2, 4, 6]) == [5]\nassert op_gt5_dec([-7, 12, -7]) == [11]"}
{"id": "op_sorta_clamp10", "entry_point": "op_sorta_clamp10", "primitives": ["sorta", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10.", "solution": "def op_sorta_clamp10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sorta_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10([]) == []\nassert op_sorta_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10([10]) == [10]\nassert op_sorta_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_rev_odds", "entry_point": "op_rev_odds", "primitives": ["rev", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers.", "solution": "def op_rev_odds(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_rev_odds([1, 2, 3, 4]) == [3, 1]\nassert op_rev_odds([]) == []\nassert op_rev_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_rev_odds([5, 5, 5]) == [5, 5, 5]\nassert op_rev_odds([3, 1, 2]) == [1, 3]\nassert op_rev_odds([10]) == []\nassert op_rev_odds([2, 4, 6]) == []\nassert op_rev_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_dropfirst", "entry_point": "op_div3_dropfirst", "primitives": ["div3", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element.", "solution": "def op_div3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_div3_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_dropfirst([]) == []\nassert op_div3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst([5, 5, 5]) == []\nassert op_div3_dropfirst([3, 1, 2]) == []\nassert op_div3_dropfirst([10]) == []\nassert op_div3_dropfirst([2, 4, 6]) == []\nassert op_div3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_evens_counteven", "entry_point": "op_evens_counteven", "primitives": ["evens", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return how many values are even.", "solution": "def op_evens_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_counteven([1, 2, 3, 4]) == 2\nassert op_evens_counteven([]) == 0\nassert op_evens_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_counteven([5, 5, 5]) == 0\nassert op_evens_counteven([3, 1, 2]) == 1\nassert op_evens_counteven([10]) == 1\nassert op_evens_counteven([2, 4, 6]) == 3\nassert op_evens_counteven([-7, 12, -7]) == 1"}
{"id": "op_double_allpos", "entry_point": "op_double_allpos", "primitives": ["double", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return whether all values are positive.", "solution": "def op_double_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_double_allpos([1, 2, 3, 4]) == True\nassert op_double_allpos([]) == True\nassert op_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_double_allpos([5, 5, 5]) == True\nassert op_double_allpos([3, 1, 2]) == True\nassert op_double_allpos([10]) == True\nassert op_double_allpos([2, 4, 6]) == True\nassert op_double_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_min", "entry_point": "op_div3_min", "primitives": ["div3", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_div3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_div3_min([1, 2, 3, 4]) == 3\nassert op_div3_min([]) == 0\nassert op_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_div3_min([5, 5, 5]) == 0\nassert op_div3_min([3, 1, 2]) == 3\nassert op_div3_min([10]) == 0\nassert op_div3_min([2, 4, 6]) == 6\nassert op_div3_min([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_gt5", "entry_point": "op_dropwhileneg_gt5", "primitives": ["dropwhileneg", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five.", "solution": "def op_dropwhileneg_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_gt5([]) == []\nassert op_dropwhileneg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_gt5([10]) == [10]\nassert op_dropwhileneg_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_gt5([-7, 12, -7]) == [12]"}
{"id": "op_neg_square", "entry_point": "op_neg_square", "primitives": ["neg", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each.", "solution": "def op_neg_square(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_neg_square([1, 2, 3, 4]) == []\nassert op_neg_square([]) == []\nassert op_neg_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_neg_square([5, 5, 5]) == []\nassert op_neg_square([3, 1, 2]) == []\nassert op_neg_square([10]) == []\nassert op_neg_square([2, 4, 6]) == []\nassert op_neg_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_upper_nonempty", "entry_point": "op_upper_nonempty", "primitives": ["upper", "nonempty"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop empty strings.", "solution": "def op_upper_nonempty(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_upper_nonempty(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_nonempty([]) == []\nassert op_upper_nonempty(['  a ', '', 'BC', 'bc']) == ['  A ', 'BC', 'BC']\nassert op_upper_nonempty(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_nonempty(['x']) == ['X']\nassert op_upper_nonempty(['abc', 'de', '']) == ['ABC', 'DE']"}
{"id": "op_uniqs_joinc", "entry_point": "op_uniqs_joinc", "primitives": ["uniqs", "joinc"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then join them with commas.", "solution": "def op_uniqs_joinc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return ','.join(r)", "tests": "assert op_uniqs_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_uniqs_joinc([]) == ''\nassert op_uniqs_joinc(['  a ', '', 'BC', 'bc']) == '  a ,,BC,bc'\nassert op_uniqs_joinc(['one', 'one', 'Two']) == 'one,Two'\nassert op_uniqs_joinc(['x']) == 'x'\nassert op_uniqs_joinc(['abc', 'de', '']) == 'abc,de,'"}
{"id": "op_dec_div3", "entry_point": "op_dec_div3", "primitives": ["dec", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three.", "solution": "def op_dec_div3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dec_div3([1, 2, 3, 4]) == [0, 3]\nassert op_dec_div3([]) == []\nassert op_dec_div3([-2, -1, 0, 1, 2]) == [-3, 0]\nassert op_dec_div3([5, 5, 5]) == []\nassert op_dec_div3([3, 1, 2]) == [0]\nassert op_dec_div3([10]) == [9]\nassert op_dec_div3([2, 4, 6]) == [3]\nassert op_dec_div3([-7, 12, -7]) == []"}
{"id": "op_div3_allpos", "entry_point": "op_div3_allpos", "primitives": ["div3", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return whether all values are positive.", "solution": "def op_div3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_div3_allpos([1, 2, 3, 4]) == True\nassert op_div3_allpos([]) == True\nassert op_div3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_div3_allpos([5, 5, 5]) == True\nassert op_div3_allpos([3, 1, 2]) == True\nassert op_div3_allpos([10]) == True\nassert op_div3_allpos([2, 4, 6]) == True\nassert op_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_absval_alldistinct", "entry_point": "op_absval_alldistinct", "primitives": ["absval", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return whether all values are distinct.", "solution": "def op_absval_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_alldistinct([]) == True\nassert op_absval_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_absval_alldistinct([5, 5, 5]) == False\nassert op_absval_alldistinct([3, 1, 2]) == True\nassert op_absval_alldistinct([10]) == True\nassert op_absval_alldistinct([2, 4, 6]) == True\nassert op_absval_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_add10", "entry_point": "op_last3_add10", "primitives": ["last3", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each.", "solution": "def op_last3_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10([]) == []\nassert op_last3_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_last3_add10([10]) == [20]\nassert op_last3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_div3_last3", "entry_point": "op_div3_last3", "primitives": ["div3", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three.", "solution": "def op_div3_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_last3([1, 2, 3, 4]) == [3]\nassert op_div3_last3([]) == []\nassert op_div3_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_last3([5, 5, 5]) == []\nassert op_div3_last3([3, 1, 2]) == [3]\nassert op_div3_last3([10]) == []\nassert op_div3_last3([2, 4, 6]) == [6]\nassert op_div3_last3([-7, 12, -7]) == [12]"}
{"id": "op_add10_counteven", "entry_point": "op_add10_counteven", "primitives": ["add10", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return how many values are even.", "solution": "def op_add10_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_counteven([1, 2, 3, 4]) == 2\nassert op_add10_counteven([]) == 0\nassert op_add10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_counteven([5, 5, 5]) == 0\nassert op_add10_counteven([3, 1, 2]) == 1\nassert op_add10_counteven([10]) == 1\nassert op_add10_counteven([2, 4, 6]) == 3\nassert op_add10_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_alldistinct", "entry_point": "op_dropfirst_alldistinct", "primitives": ["dropfirst", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return whether all values are distinct.", "solution": "def op_dropfirst_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_alldistinct([]) == True\nassert op_dropfirst_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_alldistinct([5, 5, 5]) == False\nassert op_dropfirst_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_alldistinct([10]) == True\nassert op_dropfirst_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_alldistinct([-7, 12, -7]) == True"}
{"id": "op_nonempty_firstchar", "entry_point": "op_nonempty_firstchar", "primitives": ["nonempty", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_nonempty_firstchar([]) == []\nassert op_nonempty_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_nonempty_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_nonempty_firstchar(['x']) == ['x']\nassert op_nonempty_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_upper_sortlen", "entry_point": "op_upper_sortlen", "primitives": ["upper", "sortlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort by length, shortest first.", "solution": "def op_upper_sortlen(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_upper_sortlen(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_sortlen([]) == []\nassert op_upper_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'BC', '  A ']\nassert op_upper_sortlen(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_sortlen(['x']) == ['X']\nassert op_upper_sortlen(['abc', 'de', '']) == ['', 'DE', 'ABC']"}
{"id": "op_dropshort_maxlen", "entry_point": "op_dropshort_maxlen", "primitives": ["dropshort", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then return the length of the longest string (0 if none).", "solution": "def op_dropshort_maxlen(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_dropshort_maxlen(['Hello', 'world']) == 5\nassert op_dropshort_maxlen([]) == 0\nassert op_dropshort_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_dropshort_maxlen(['one', 'one', 'Two']) == 3\nassert op_dropshort_maxlen(['x']) == 0\nassert op_dropshort_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_clamp10_dropzeros", "entry_point": "op_clamp10_dropzeros", "primitives": ["clamp10", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros.", "solution": "def op_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_clamp10_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropzeros([]) == []\nassert op_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_clamp10_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropzeros([10]) == [10]\nassert op_clamp10_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropzeros([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_negate_add10", "entry_point": "op_negate_add10", "primitives": ["negate", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each.", "solution": "def op_negate_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_add10([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_add10([]) == []\nassert op_negate_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_negate_add10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_add10([3, 1, 2]) == [7, 9, 8]\nassert op_negate_add10([10]) == [0]\nassert op_negate_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_add10([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_oremptyzero_double", "entry_point": "op_oremptyzero_double", "primitives": ["oremptyzero", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each.", "solution": "def op_oremptyzero_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_oremptyzero_double([]) == [0]\nassert op_oremptyzero_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_oremptyzero_double([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_double([3, 1, 2]) == [6, 2, 4]\nassert op_oremptyzero_double([10]) == [20]\nassert op_oremptyzero_double([2, 4, 6]) == [4, 8, 12]\nassert op_oremptyzero_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dropfirst_beforezero", "entry_point": "op_dropfirst_beforezero", "primitives": ["dropfirst", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero.", "solution": "def op_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_beforezero([]) == []\nassert op_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_beforezero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_beforezero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_beforezero([10]) == []\nassert op_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_sorta_firsteven", "entry_point": "op_sorta_firsteven", "primitives": ["sorta", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return the first even value (0 if none).", "solution": "def op_sorta_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_firsteven([]) == 0\nassert op_sorta_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_firsteven([5, 5, 5]) == 0\nassert op_sorta_firsteven([3, 1, 2]) == 2\nassert op_sorta_firsteven([10]) == 10\nassert op_sorta_firsteven([2, 4, 6]) == 2\nassert op_sorta_firsteven([-7, 12, -7]) == 12"}
{"id": "op_padto3_anyeven", "entry_point": "op_padto3_anyeven", "primitives": ["padto3", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_padto3_anyeven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_padto3_anyeven([]) == True\nassert op_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_padto3_anyeven([5, 5, 5]) == False\nassert op_padto3_anyeven([3, 1, 2]) == True\nassert op_padto3_anyeven([10]) == True\nassert op_padto3_anyeven([2, 4, 6]) == True\nassert op_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_add10_min", "entry_point": "op_add10_min", "primitives": ["add10", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return the minimum (0 if empty).", "solution": "def op_add10_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_add10_min([1, 2, 3, 4]) == 11\nassert op_add10_min([]) == 0\nassert op_add10_min([-2, -1, 0, 1, 2]) == 8\nassert op_add10_min([5, 5, 5]) == 15\nassert op_add10_min([3, 1, 2]) == 11\nassert op_add10_min([10]) == 20\nassert op_add10_min([2, 4, 6]) == 12\nassert op_add10_min([-7, 12, -7]) == 3"}
{"id": "op_odds_sortabs", "entry_point": "op_odds_sortabs", "primitives": ["odds", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value.", "solution": "def op_odds_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sortabs([]) == []\nassert op_odds_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortabs([3, 1, 2]) == [1, 3]\nassert op_odds_sortabs([10]) == []\nassert op_odds_sortabs([2, 4, 6]) == []\nassert op_odds_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_allpos", "entry_point": "op_pos_allpos", "primitives": ["pos", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return whether all values are positive.", "solution": "def op_pos_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_pos_allpos([1, 2, 3, 4]) == True\nassert op_pos_allpos([]) == True\nassert op_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_pos_allpos([5, 5, 5]) == True\nassert op_pos_allpos([3, 1, 2]) == True\nassert op_pos_allpos([10]) == True\nassert op_pos_allpos([2, 4, 6]) == True\nassert op_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_sortd_last3", "entry_point": "op_sortd_last3", "primitives": ["sortd", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three.", "solution": "def op_sortd_last3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return r", "tests": "assert op_sortd_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_last3([]) == []\nassert op_sortd_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_sortd_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_last3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_last3([10]) == [10]\nassert op_sortd_last3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_last3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortabs_alldistinct", "entry_point": "op_sortabs_alldistinct", "primitives": ["sortabs", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return whether all values are distinct.", "solution": "def op_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_alldistinct([]) == True\nassert op_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_alldistinct([5, 5, 5]) == False\nassert op_sortabs_alldistinct([3, 1, 2]) == True\nassert op_sortabs_alldistinct([10]) == True\nassert op_sortabs_alldistinct([2, 4, 6]) == True\nassert op_sortabs_alldistinct([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_firsteven", "entry_point": "op_oremptyzero_firsteven", "primitives": ["oremptyzero", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return the first even value (0 if none).", "solution": "def op_oremptyzero_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_firsteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_firsteven([]) == 0\nassert op_oremptyzero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_firsteven([10]) == 10\nassert op_oremptyzero_firsteven([2, 4, 6]) == 2\nassert op_oremptyzero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_gt5", "entry_point": "op_oremptyzero_gt5", "primitives": ["oremptyzero", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five.", "solution": "def op_oremptyzero_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_gt5([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5([]) == []\nassert op_oremptyzero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5([5, 5, 5]) == []\nassert op_oremptyzero_gt5([3, 1, 2]) == []\nassert op_oremptyzero_gt5([10]) == [10]\nassert op_oremptyzero_gt5([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_last3_beforezero", "entry_point": "op_last3_beforezero", "primitives": ["last3", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero.", "solution": "def op_last3_beforezero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_last3_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_beforezero([]) == []\nassert op_last3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_last3_beforezero([10]) == [10]\nassert op_last3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_last3_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_double_counteven", "entry_point": "op_double_counteven", "primitives": ["double", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then return how many values are even.", "solution": "def op_double_counteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_double_counteven([1, 2, 3, 4]) == 4\nassert op_double_counteven([]) == 0\nassert op_double_counteven([-2, -1, 0, 1, 2]) == 5\nassert op_double_counteven([5, 5, 5]) == 3\nassert op_double_counteven([3, 1, 2]) == 3\nassert op_double_counteven([10]) == 1\nassert op_double_counteven([2, 4, 6]) == 3\nassert op_double_counteven([-7, 12, -7]) == 3"}
{"id": "op_negate_haszero", "entry_point": "op_negate_haszero", "primitives": ["negate", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then return whether the list contains a zero.", "solution": "def op_negate_haszero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return 0 in r", "tests": "assert op_negate_haszero([1, 2, 3, 4]) == False\nassert op_negate_haszero([]) == False\nassert op_negate_haszero([-2, -1, 0, 1, 2]) == True\nassert op_negate_haszero([5, 5, 5]) == False\nassert op_negate_haszero([3, 1, 2]) == False\nassert op_negate_haszero([10]) == False\nassert op_negate_haszero([2, 4, 6]) == False\nassert op_negate_haszero([-7, 12, -7]) == False"}
{"id": "op_ages_odds", "entry_point": "op_ages_odds", "primitives": ["ages", "odds"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers.", "solution": "def op_ages_odds(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_ages_odds([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_odds([]) == []\nassert op_ages_odds([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_odds([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropwhileneg_counteven", "entry_point": "op_dropwhileneg_counteven", "primitives": ["dropwhileneg", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return how many values are even.", "solution": "def op_dropwhileneg_counteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropwhileneg_counteven([1, 2, 3, 4]) == 2\nassert op_dropwhileneg_counteven([]) == 0\nassert op_dropwhileneg_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_counteven([5, 5, 5]) == 0\nassert op_dropwhileneg_counteven([3, 1, 2]) == 1\nassert op_dropwhileneg_counteven([10]) == 1\nassert op_dropwhileneg_counteven([2, 4, 6]) == 3\nassert op_dropwhileneg_counteven([-7, 12, -7]) == 1"}
{"id": "op_strip_lens", "entry_point": "op_strip_lens", "primitives": ["strip", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then return the total number of characters.", "solution": "def op_strip_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_strip_lens(['Hello', 'world']) == 10\nassert op_strip_lens([]) == 0\nassert op_strip_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_strip_lens(['one', 'one', 'Two']) == 9\nassert op_strip_lens(['x']) == 1\nassert op_strip_lens(['abc', 'de', '']) == 5"}
{"id": "op_pos_takewhilepos", "entry_point": "op_pos_takewhilepos", "primitives": ["pos", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive.", "solution": "def op_pos_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_pos_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_takewhilepos([]) == []\nassert op_pos_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_pos_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_pos_takewhilepos([10]) == [10]\nassert op_pos_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_pos_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_padto3_uniq", "entry_point": "op_padto3_uniq", "primitives": ["padto3", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_padto3_uniq(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_padto3_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_uniq([]) == [0]\nassert op_padto3_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_uniq([5, 5, 5]) == [5]\nassert op_padto3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_uniq([10]) == [10, 0]\nassert op_padto3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_clamp10_square", "entry_point": "op_clamp10_square", "primitives": ["clamp10", "square"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each.", "solution": "def op_clamp10_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_square([]) == []\nassert op_clamp10_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_clamp10_square([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_square([10]) == [100]\nassert op_clamp10_square([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_square([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_neg_clamp10", "entry_point": "op_neg_clamp10", "primitives": ["neg", "clamp10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10.", "solution": "def op_neg_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_neg_clamp10([1, 2, 3, 4]) == []\nassert op_neg_clamp10([]) == []\nassert op_neg_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_clamp10([5, 5, 5]) == []\nassert op_neg_clamp10([3, 1, 2]) == []\nassert op_neg_clamp10([10]) == []\nassert op_neg_clamp10([2, 4, 6]) == []\nassert op_neg_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropfirst_anyeven", "entry_point": "op_dropfirst_anyeven", "primitives": ["dropfirst", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return whether any value is even.", "solution": "def op_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_anyeven([]) == False\nassert op_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_anyeven([5, 5, 5]) == False\nassert op_dropfirst_anyeven([3, 1, 2]) == True\nassert op_dropfirst_anyeven([10]) == False\nassert op_dropfirst_anyeven([2, 4, 6]) == True\nassert op_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_last3", "entry_point": "op_trimends_last3", "primitives": ["trimends", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three.", "solution": "def op_trimends_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_last3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_last3([]) == []\nassert op_trimends_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_last3([5, 5, 5]) == [5]\nassert op_trimends_last3([3, 1, 2]) == [1]\nassert op_trimends_last3([10]) == []\nassert op_trimends_last3([2, 4, 6]) == [4]\nassert op_trimends_last3([-7, 12, -7]) == [12]"}
{"id": "op_prefixup_lens", "entry_point": "op_prefixup_lens", "primitives": ["prefixup", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then return the total number of characters.", "solution": "def op_prefixup_lens(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_prefixup_lens(['Hello', 'world']) == 12\nassert op_prefixup_lens([]) == 0\nassert op_prefixup_lens(['  a ', '', 'BC', 'bc']) == 12\nassert op_prefixup_lens(['one', 'one', 'Two']) == 12\nassert op_prefixup_lens(['x']) == 2\nassert op_prefixup_lens(['abc', 'de', '']) == 8"}
{"id": "op_trimends_rev", "entry_point": "op_trimends_rev", "primitives": ["trimends", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order.", "solution": "def op_trimends_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_rev([]) == []\nassert op_trimends_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_rev([5, 5, 5]) == [5]\nassert op_trimends_rev([3, 1, 2]) == [1]\nassert op_trimends_rev([10]) == []\nassert op_trimends_rev([2, 4, 6]) == [4]\nassert op_trimends_rev([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_rev", "entry_point": "op_takewhilepos_rev", "primitives": ["takewhilepos", "rev"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then reverse the order.", "solution": "def op_takewhilepos_rev(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_takewhilepos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_rev([]) == []\nassert op_takewhilepos_rev([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_takewhilepos_rev([10]) == [10]\nassert op_takewhilepos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_rev([-7, 12, -7]) == []"}
{"id": "op_div3_sorta", "entry_point": "op_div3_sorta", "primitives": ["div3", "sorta"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending.", "solution": "def op_div3_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_sorta([1, 2, 3, 4]) == [3]\nassert op_div3_sorta([]) == []\nassert op_div3_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_sorta([5, 5, 5]) == []\nassert op_div3_sorta([3, 1, 2]) == [3]\nassert op_div3_sorta([10]) == []\nassert op_div3_sorta([2, 4, 6]) == [6]\nassert op_div3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_ages_sortd", "entry_point": "op_ages_sortd", "primitives": ["ages", "sortd"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending.", "solution": "def op_ages_sortd(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_ages_sortd([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_sortd([]) == []\nassert op_ages_sortd([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 18, 17]\nassert op_ages_sortd([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_pos_trimends", "entry_point": "op_pos_trimends", "primitives": ["pos", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements.", "solution": "def op_pos_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_pos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_pos_trimends([]) == []\nassert op_pos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends([5, 5, 5]) == [5]\nassert op_pos_trimends([3, 1, 2]) == [1]\nassert op_pos_trimends([10]) == []\nassert op_pos_trimends([2, 4, 6]) == [4]\nassert op_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_odds_absval", "entry_point": "op_odds_absval", "primitives": ["odds", "absval"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each.", "solution": "def op_odds_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_absval([1, 2, 3, 4]) == [1, 3]\nassert op_odds_absval([]) == []\nassert op_odds_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_absval([5, 5, 5]) == [5, 5, 5]\nassert op_odds_absval([3, 1, 2]) == [3, 1]\nassert op_odds_absval([10]) == []\nassert op_odds_absval([2, 4, 6]) == []\nassert op_odds_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_sorta_beforezero", "entry_point": "op_sorta_beforezero", "primitives": ["sorta", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero.", "solution": "def op_sorta_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_beforezero([]) == []\nassert op_sorta_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_beforezero([10]) == [10]\nassert op_sorta_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_absval_issorted", "entry_point": "op_absval_issorted", "primitives": ["absval", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_absval_issorted(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_absval_issorted([1, 2, 3, 4]) == True\nassert op_absval_issorted([]) == True\nassert op_absval_issorted([-2, -1, 0, 1, 2]) == False\nassert op_absval_issorted([5, 5, 5]) == True\nassert op_absval_issorted([3, 1, 2]) == False\nassert op_absval_issorted([10]) == True\nassert op_absval_issorted([2, 4, 6]) == True\nassert op_absval_issorted([-7, 12, -7]) == False"}
{"id": "op_sorta_prod", "entry_point": "op_sorta_prod", "primitives": ["sorta", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return their product.", "solution": "def op_sorta_prod(xs):\n    r = list(xs)\n    r = sorted(r)\n    return __import__('math').prod(r)", "tests": "assert op_sorta_prod([1, 2, 3, 4]) == 24\nassert op_sorta_prod([]) == 1\nassert op_sorta_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_prod([5, 5, 5]) == 125\nassert op_sorta_prod([3, 1, 2]) == 6\nassert op_sorta_prod([10]) == 10\nassert op_sorta_prod([2, 4, 6]) == 48\nassert op_sorta_prod([-7, 12, -7]) == 588"}
{"id": "op_dropfirst_dropzeros", "entry_point": "op_dropfirst_dropzeros", "primitives": ["dropfirst", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros.", "solution": "def op_dropfirst_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropzeros([]) == []\nassert op_dropfirst_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropfirst_dropzeros([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dropzeros([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dropzeros([10]) == []\nassert op_dropfirst_dropzeros([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropzeros_last3", "entry_point": "op_dropzeros_last3", "primitives": ["dropzeros", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three.", "solution": "def op_dropzeros_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_last3([]) == []\nassert op_dropzeros_last3([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_last3([10]) == [10]\nassert op_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropwhileneg_add10", "entry_point": "op_dropwhileneg_add10", "primitives": ["dropwhileneg", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each.", "solution": "def op_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_add10([]) == []\nassert op_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_add10([10]) == [20]\nassert op_dropwhileneg_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_absval_odds", "entry_point": "op_absval_odds", "primitives": ["absval", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers.", "solution": "def op_absval_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_odds([]) == []\nassert op_absval_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_odds([3, 1, 2]) == [3, 1]\nassert op_absval_odds([10]) == []\nassert op_absval_odds([2, 4, 6]) == []\nassert op_absval_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_add10_double", "entry_point": "op_add10_double", "primitives": ["add10", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then double each.", "solution": "def op_add10_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_add10_double([]) == []\nassert op_add10_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_add10_double([3, 1, 2]) == [26, 22, 24]\nassert op_add10_double([10]) == [40]\nassert op_add10_double([2, 4, 6]) == [24, 28, 32]\nassert op_add10_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_neg_issorted", "entry_point": "op_neg_issorted", "primitives": ["neg", "issorted"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_neg_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_neg_issorted([1, 2, 3, 4]) == True\nassert op_neg_issorted([]) == True\nassert op_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_neg_issorted([5, 5, 5]) == True\nassert op_neg_issorted([3, 1, 2]) == True\nassert op_neg_issorted([10]) == True\nassert op_neg_issorted([2, 4, 6]) == True\nassert op_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_strip_firstchar", "entry_point": "op_strip_firstchar", "primitives": ["strip", "firstchar"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then keep the first character of each (dropping empties).", "solution": "def op_strip_firstchar(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_strip_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_strip_firstchar([]) == []\nassert op_strip_firstchar(['  a ', '', 'BC', 'bc']) == ['a', 'B', 'b']\nassert op_strip_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_strip_firstchar(['x']) == ['x']\nassert op_strip_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_lower_longest", "entry_point": "op_lower_longest", "primitives": ["lower", "longest"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then return the longest string (empty if none).", "solution": "def op_lower_longest(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_lower_longest(['Hello', 'world']) == 'hello'\nassert op_lower_longest([]) == ''\nassert op_lower_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_lower_longest(['one', 'one', 'Two']) == 'one'\nassert op_lower_longest(['x']) == 'x'\nassert op_lower_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_dropwhileneg_dropzeros", "entry_point": "op_dropwhileneg_dropzeros", "primitives": ["dropwhileneg", "dropzeros"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros.", "solution": "def op_dropwhileneg_dropzeros(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropwhileneg_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_dropzeros([]) == []\nassert op_dropwhileneg_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_dropzeros([10]) == [10]\nassert op_dropwhileneg_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropzeros_div3", "entry_point": "op_dropzeros_div3", "primitives": ["dropzeros", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three.", "solution": "def op_dropzeros_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropzeros_div3([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3([]) == []\nassert op_dropzeros_div3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3([5, 5, 5]) == []\nassert op_dropzeros_div3([3, 1, 2]) == [3]\nassert op_dropzeros_div3([10]) == []\nassert op_dropzeros_div3([2, 4, 6]) == [6]\nassert op_dropzeros_div3([-7, 12, -7]) == [12]"}
{"id": "op_padto3_allpos", "entry_point": "op_padto3_allpos", "primitives": ["padto3", "allpos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return whether all values are positive.", "solution": "def op_padto3_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_allpos([1, 2, 3, 4]) == True\nassert op_padto3_allpos([]) == False\nassert op_padto3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_allpos([5, 5, 5]) == True\nassert op_padto3_allpos([3, 1, 2]) == True\nassert op_padto3_allpos([10]) == False\nassert op_padto3_allpos([2, 4, 6]) == True\nassert op_padto3_allpos([-7, 12, -7]) == False"}
{"id": "op_sortd_trimends", "entry_point": "op_sortd_trimends", "primitives": ["sortd", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements.", "solution": "def op_sortd_trimends(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_sortd_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_sortd_trimends([]) == []\nassert op_sortd_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortd_trimends([5, 5, 5]) == [5]\nassert op_sortd_trimends([3, 1, 2]) == [2]\nassert op_sortd_trimends([10]) == []\nassert op_sortd_trimends([2, 4, 6]) == [4]\nassert op_sortd_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_neg_gt5", "entry_point": "op_neg_gt5", "primitives": ["neg", "gt5"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep values greater than five.", "solution": "def op_neg_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_gt5([1, 2, 3, 4]) == []\nassert op_neg_gt5([]) == []\nassert op_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_gt5([5, 5, 5]) == []\nassert op_neg_gt5([3, 1, 2]) == []\nassert op_neg_gt5([10]) == []\nassert op_neg_gt5([2, 4, 6]) == []\nassert op_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_trimends_beforezero", "entry_point": "op_trimends_beforezero", "primitives": ["trimends", "beforezero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero.", "solution": "def op_trimends_beforezero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_trimends_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_beforezero([]) == []\nassert op_trimends_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero([5, 5, 5]) == [5]\nassert op_trimends_beforezero([3, 1, 2]) == [1]\nassert op_trimends_beforezero([10]) == []\nassert op_trimends_beforezero([2, 4, 6]) == [4]\nassert op_trimends_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sortd_uniq", "entry_point": "op_sortd_uniq", "primitives": ["sortd", "uniq"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence.", "solution": "def op_sortd_uniq(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortd_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_uniq([]) == []\nassert op_sortd_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_uniq([5, 5, 5]) == [5]\nassert op_sortd_uniq([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_uniq([10]) == [10]\nassert op_sortd_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_add10_dec", "entry_point": "op_add10_dec", "primitives": ["add10", "dec"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each.", "solution": "def op_add10_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_dec([]) == []\nassert op_add10_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_dec([5, 5, 5]) == [14, 14, 14]\nassert op_add10_dec([3, 1, 2]) == [12, 10, 11]\nassert op_add10_dec([10]) == [19]\nassert op_add10_dec([2, 4, 6]) == [11, 13, 15]\nassert op_add10_dec([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_dropzeros_max", "entry_point": "op_dropzeros_max", "primitives": ["dropzeros", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return the maximum (0 if empty).", "solution": "def op_dropzeros_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_max([1, 2, 3, 4]) == 4\nassert op_dropzeros_max([]) == 0\nassert op_dropzeros_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_max([5, 5, 5]) == 5\nassert op_dropzeros_max([3, 1, 2]) == 3\nassert op_dropzeros_max([10]) == 10\nassert op_dropzeros_max([2, 4, 6]) == 6\nassert op_dropzeros_max([-7, 12, -7]) == 12"}
{"id": "op_negate_last3", "entry_point": "op_negate_last3", "primitives": ["negate", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three.", "solution": "def op_negate_last3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_last3([]) == []\nassert op_negate_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_last3([10]) == [-10]\nassert op_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_takewhilepos_div3", "entry_point": "op_takewhilepos_div3", "primitives": ["takewhilepos", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three.", "solution": "def op_takewhilepos_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_div3([]) == []\nassert op_takewhilepos_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_div3([5, 5, 5]) == []\nassert op_takewhilepos_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_div3([10]) == []\nassert op_takewhilepos_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_div3([-7, 12, -7]) == []"}
{"id": "op_sortlen_lens", "entry_point": "op_sortlen_lens", "primitives": ["sortlen", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then return the total number of characters.", "solution": "def op_sortlen_lens(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return sum(len(s) for s in r)", "tests": "assert op_sortlen_lens(['Hello', 'world']) == 10\nassert op_sortlen_lens([]) == 0\nassert op_sortlen_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_sortlen_lens(['one', 'one', 'Two']) == 9\nassert op_sortlen_lens(['x']) == 1\nassert op_sortlen_lens(['abc', 'de', '']) == 5"}
{"id": "op_dec_first3", "entry_point": "op_dec_first3", "primitives": ["dec", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three.", "solution": "def op_dec_first3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dec_first3([1, 2, 3, 4]) == [0, 1, 2]\nassert op_dec_first3([]) == []\nassert op_dec_first3([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_first3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_first3([10]) == [9]\nassert op_dec_first3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_inc_double", "entry_point": "op_inc_double", "primitives": ["inc", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each.", "solution": "def op_inc_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_double([]) == []\nassert op_inc_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4, 6]\nassert op_inc_double([5, 5, 5]) == [12, 12, 12]\nassert op_inc_double([3, 1, 2]) == [8, 4, 6]\nassert op_inc_double([10]) == [22]\nassert op_inc_double([2, 4, 6]) == [6, 10, 14]\nassert op_inc_double([-7, 12, -7]) == [-12, 26, -12]"}
{"id": "op_dropzeros_min", "entry_point": "op_dropzeros_min", "primitives": ["dropzeros", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then return the minimum (0 if empty).", "solution": "def op_dropzeros_min(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_dropzeros_min([1, 2, 3, 4]) == 1\nassert op_dropzeros_min([]) == 0\nassert op_dropzeros_min([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_min([5, 5, 5]) == 5\nassert op_dropzeros_min([3, 1, 2]) == 1\nassert op_dropzeros_min([10]) == 10\nassert op_dropzeros_min([2, 4, 6]) == 2\nassert op_dropzeros_min([-7, 12, -7]) == -7"}
{"id": "op_clamp10_sum", "entry_point": "op_clamp10_sum", "primitives": ["clamp10", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return their sum.", "solution": "def op_clamp10_sum(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_clamp10_sum([1, 2, 3, 4]) == 10\nassert op_clamp10_sum([]) == 0\nassert op_clamp10_sum([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_sum([5, 5, 5]) == 15\nassert op_clamp10_sum([3, 1, 2]) == 6\nassert op_clamp10_sum([10]) == 10\nassert op_clamp10_sum([2, 4, 6]) == 12\nassert op_clamp10_sum([-7, 12, -7]) == -4"}
{"id": "op_double_negate", "entry_point": "op_double_negate", "primitives": ["double", "negate"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each.", "solution": "def op_double_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_negate([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_negate([]) == []\nassert op_double_negate([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_double_negate([3, 1, 2]) == [-6, -2, -4]\nassert op_double_negate([10]) == [-20]\nassert op_double_negate([2, 4, 6]) == [-4, -8, -12]\nassert op_double_negate([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_odds_trimends", "entry_point": "op_odds_trimends", "primitives": ["odds", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first and last elements.", "solution": "def op_odds_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_trimends([1, 2, 3, 4]) == []\nassert op_odds_trimends([]) == []\nassert op_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_trimends([5, 5, 5]) == [5]\nassert op_odds_trimends([3, 1, 2]) == []\nassert op_odds_trimends([10]) == []\nassert op_odds_trimends([2, 4, 6]) == []\nassert op_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_absval_anyeven", "entry_point": "op_absval_anyeven", "primitives": ["absval", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return whether any value is even.", "solution": "def op_absval_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_anyeven([1, 2, 3, 4]) == True\nassert op_absval_anyeven([]) == False\nassert op_absval_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_anyeven([5, 5, 5]) == False\nassert op_absval_anyeven([3, 1, 2]) == True\nassert op_absval_anyeven([10]) == True\nassert op_absval_anyeven([2, 4, 6]) == True\nassert op_absval_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortabs_double", "entry_point": "op_sortabs_double", "primitives": ["sortabs", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each.", "solution": "def op_sortabs_double(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortabs_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_double([]) == []\nassert op_sortabs_double([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_sortabs_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_double([10]) == [20]\nassert op_sortabs_double([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropzeros_sortabs", "entry_point": "op_dropzeros_sortabs", "primitives": ["dropzeros", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value.", "solution": "def op_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sortabs([]) == []\nassert op_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_dropzeros_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sortabs([10]) == [10]\nassert op_dropzeros_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_rev_max", "entry_point": "op_rev_max", "primitives": ["rev", "max"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return the maximum (0 if empty).", "solution": "def op_rev_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return max(r) if r else 0", "tests": "assert op_rev_max([1, 2, 3, 4]) == 4\nassert op_rev_max([]) == 0\nassert op_rev_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_max([5, 5, 5]) == 5\nassert op_rev_max([3, 1, 2]) == 3\nassert op_rev_max([10]) == 10\nassert op_rev_max([2, 4, 6]) == 6\nassert op_rev_max([-7, 12, -7]) == 12"}
{"id": "op_div3_inc", "entry_point": "op_div3_inc", "primitives": ["div3", "inc"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each.", "solution": "def op_div3_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_div3_inc([1, 2, 3, 4]) == [4]\nassert op_div3_inc([]) == []\nassert op_div3_inc([-2, -1, 0, 1, 2]) == [1]\nassert op_div3_inc([5, 5, 5]) == []\nassert op_div3_inc([3, 1, 2]) == [4]\nassert op_div3_inc([10]) == []\nassert op_div3_inc([2, 4, 6]) == [7]\nassert op_div3_inc([-7, 12, -7]) == [13]"}
{"id": "op_dec_oremptyzero", "entry_point": "op_dec_oremptyzero", "primitives": ["dec", "oremptyzero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero.", "solution": "def op_dec_oremptyzero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dec_oremptyzero([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_oremptyzero([]) == [0]\nassert op_dec_oremptyzero([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_oremptyzero([5, 5, 5]) == [4, 4, 4]\nassert op_dec_oremptyzero([3, 1, 2]) == [2, 0, 1]\nassert op_dec_oremptyzero([10]) == [9]\nassert op_dec_oremptyzero([2, 4, 6]) == [1, 3, 5]\nassert op_dec_oremptyzero([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_sortabs_min", "entry_point": "op_sortabs_min", "primitives": ["sortabs", "min"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_sortabs_min(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_sortabs_min([1, 2, 3, 4]) == 1\nassert op_sortabs_min([]) == 0\nassert op_sortabs_min([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_min([5, 5, 5]) == 5\nassert op_sortabs_min([3, 1, 2]) == 1\nassert op_sortabs_min([10]) == 10\nassert op_sortabs_min([2, 4, 6]) == 2\nassert op_sortabs_min([-7, 12, -7]) == -7"}
{"id": "op_inc_dropwhileneg", "entry_point": "op_inc_dropwhileneg", "primitives": ["inc", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the leading negative values.", "solution": "def op_inc_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_inc_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_dropwhileneg([]) == []\nassert op_inc_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_inc_dropwhileneg([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropwhileneg([3, 1, 2]) == [4, 2, 3]\nassert op_inc_dropwhileneg([10]) == [11]\nassert op_inc_dropwhileneg([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropwhileneg([-7, 12, -7]) == [13, -6]"}
{"id": "op_last3_dropfirst", "entry_point": "op_last3_dropfirst", "primitives": ["last3", "dropfirst"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element.", "solution": "def op_last3_dropfirst(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_last3_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_last3_dropfirst([]) == []\nassert op_last3_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_last3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_last3_dropfirst([10]) == []\nassert op_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_last3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortd_add10", "entry_point": "op_sortd_add10", "primitives": ["sortd", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each.", "solution": "def op_sortd_add10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortd_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sortd_add10([]) == []\nassert op_sortd_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sortd_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sortd_add10([3, 1, 2]) == [13, 12, 11]\nassert op_sortd_add10([10]) == [20]\nassert op_sortd_add10([2, 4, 6]) == [16, 14, 12]\nassert op_sortd_add10([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_gt5_trimends", "entry_point": "op_gt5_trimends", "primitives": ["gt5", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements.", "solution": "def op_gt5_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_trimends([1, 2, 3, 4]) == []\nassert op_gt5_trimends([]) == []\nassert op_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends([5, 5, 5]) == []\nassert op_gt5_trimends([3, 1, 2]) == []\nassert op_gt5_trimends([10]) == []\nassert op_gt5_trimends([2, 4, 6]) == []\nassert op_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_negate_div3", "entry_point": "op_negate_div3", "primitives": ["negate", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three.", "solution": "def op_negate_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_div3([]) == []\nassert op_negate_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_div3([5, 5, 5]) == []\nassert op_negate_div3([3, 1, 2]) == [-3]\nassert op_negate_div3([10]) == []\nassert op_negate_div3([2, 4, 6]) == [-6]\nassert op_negate_div3([-7, 12, -7]) == [-12]"}
{"id": "op_inc_div3", "entry_point": "op_inc_div3", "primitives": ["inc", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three.", "solution": "def op_inc_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_div3([1, 2, 3, 4]) == [3]\nassert op_inc_div3([]) == []\nassert op_inc_div3([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_inc_div3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_div3([3, 1, 2]) == [3]\nassert op_inc_div3([10]) == []\nassert op_inc_div3([2, 4, 6]) == [3]\nassert op_inc_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_first3_trimends", "entry_point": "op_first3_trimends", "primitives": ["first3", "trimends"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements.", "solution": "def op_first3_trimends(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_first3_trimends([1, 2, 3, 4]) == [2]\nassert op_first3_trimends([]) == []\nassert op_first3_trimends([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_trimends([5, 5, 5]) == [5]\nassert op_first3_trimends([3, 1, 2]) == [1]\nassert op_first3_trimends([10]) == []\nassert op_first3_trimends([2, 4, 6]) == [4]\nassert op_first3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_sortd_counteven", "entry_point": "op_sortd_counteven", "primitives": ["sortd", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return how many values are even.", "solution": "def op_sortd_counteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortd_counteven([1, 2, 3, 4]) == 2\nassert op_sortd_counteven([]) == 0\nassert op_sortd_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sortd_counteven([5, 5, 5]) == 0\nassert op_sortd_counteven([3, 1, 2]) == 1\nassert op_sortd_counteven([10]) == 1\nassert op_sortd_counteven([2, 4, 6]) == 3\nassert op_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_pos", "entry_point": "op_dropzeros_pos", "primitives": ["dropzeros", "pos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the positive numbers.", "solution": "def op_dropzeros_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_pos([]) == []\nassert op_dropzeros_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_pos([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_pos([10]) == [10]\nassert op_dropzeros_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_pos([-7, 12, -7]) == [12]"}
{"id": "op_names_maxlen", "entry_point": "op_names_maxlen", "primitives": ["names", "maxlen"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then return the length of the longest string (0 if none).", "solution": "def op_names_maxlen(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_names_maxlen([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 3\nassert op_names_maxlen([]) == 0\nassert op_names_maxlen([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_names_maxlen([{'name': 'Fi', 'age': 41}]) == 2"}
{"id": "op_sortalpha_prefixup", "entry_point": "op_sortalpha_prefixup", "primitives": ["sortalpha", "prefixup"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then prefix each with a hash.", "solution": "def op_sortalpha_prefixup(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_sortalpha_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortalpha_prefixup([]) == []\nassert op_sortalpha_prefixup(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_sortalpha_prefixup(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_sortalpha_prefixup(['x']) == ['#x']\nassert op_sortalpha_prefixup(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_beforezero_anyeven", "entry_point": "op_beforezero_anyeven", "primitives": ["beforezero", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return whether any value is even.", "solution": "def op_beforezero_anyeven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_beforezero_anyeven([1, 2, 3, 4]) == True\nassert op_beforezero_anyeven([]) == False\nassert op_beforezero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_anyeven([5, 5, 5]) == False\nassert op_beforezero_anyeven([3, 1, 2]) == True\nassert op_beforezero_anyeven([10]) == True\nassert op_beforezero_anyeven([2, 4, 6]) == True\nassert op_beforezero_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_odds", "entry_point": "op_trimends_odds", "primitives": ["trimends", "odds"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the odd numbers.", "solution": "def op_trimends_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_odds([1, 2, 3, 4]) == [3]\nassert op_trimends_odds([]) == []\nassert op_trimends_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_odds([5, 5, 5]) == [5]\nassert op_trimends_odds([3, 1, 2]) == [1]\nassert op_trimends_odds([10]) == []\nassert op_trimends_odds([2, 4, 6]) == []\nassert op_trimends_odds([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_last3", "entry_point": "op_takewhilepos_last3", "primitives": ["takewhilepos", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three.", "solution": "def op_takewhilepos_last3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return r", "tests": "assert op_takewhilepos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_last3([]) == []\nassert op_takewhilepos_last3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_last3([10]) == [10]\nassert op_takewhilepos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_last3([-7, 12, -7]) == []"}
{"id": "op_evens_div3", "entry_point": "op_evens_div3", "primitives": ["evens", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three.", "solution": "def op_evens_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_div3([1, 2, 3, 4]) == []\nassert op_evens_div3([]) == []\nassert op_evens_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_div3([5, 5, 5]) == []\nassert op_evens_div3([3, 1, 2]) == []\nassert op_evens_div3([10]) == []\nassert op_evens_div3([2, 4, 6]) == [6]\nassert op_evens_div3([-7, 12, -7]) == [12]"}
{"id": "op_div3_anyeven", "entry_point": "op_div3_anyeven", "primitives": ["div3", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return whether any value is even.", "solution": "def op_div3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_anyeven([1, 2, 3, 4]) == False\nassert op_div3_anyeven([]) == False\nassert op_div3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_div3_anyeven([5, 5, 5]) == False\nassert op_div3_anyeven([3, 1, 2]) == False\nassert op_div3_anyeven([10]) == False\nassert op_div3_anyeven([2, 4, 6]) == True\nassert op_div3_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_len", "entry_point": "op_last3_len", "primitives": ["last3", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return how many remain.", "solution": "def op_last3_len(xs):\n    r = list(xs)\n    r = r[-3:]\n    return len(r)", "tests": "assert op_last3_len([1, 2, 3, 4]) == 3\nassert op_last3_len([]) == 0\nassert op_last3_len([-2, -1, 0, 1, 2]) == 3\nassert op_last3_len([5, 5, 5]) == 3\nassert op_last3_len([3, 1, 2]) == 3\nassert op_last3_len([10]) == 1\nassert op_last3_len([2, 4, 6]) == 3\nassert op_last3_len([-7, 12, -7]) == 3"}
{"id": "op_padto3_counteven", "entry_point": "op_padto3_counteven", "primitives": ["padto3", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_padto3_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_counteven([1, 2, 3, 4]) == 2\nassert op_padto3_counteven([]) == 3\nassert op_padto3_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_padto3_counteven([5, 5, 5]) == 0\nassert op_padto3_counteven([3, 1, 2]) == 1\nassert op_padto3_counteven([10]) == 3\nassert op_padto3_counteven([2, 4, 6]) == 3\nassert op_padto3_counteven([-7, 12, -7]) == 1"}
{"id": "op_prefixup_uniqs", "entry_point": "op_prefixup_uniqs", "primitives": ["prefixup", "uniqs"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop duplicate strings keeping the first.", "solution": "def op_prefixup_uniqs(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_prefixup_uniqs(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_uniqs([]) == []\nassert op_prefixup_uniqs(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#BC', '#bc']\nassert op_prefixup_uniqs(['one', 'one', 'Two']) == ['#one', '#Two']\nassert op_prefixup_uniqs(['x']) == ['#x']\nassert op_prefixup_uniqs(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_takewhilepos_haszero", "entry_point": "op_takewhilepos_haszero", "primitives": ["takewhilepos", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return whether the list contains a zero.", "solution": "def op_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_haszero([]) == False\nassert op_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_haszero([5, 5, 5]) == False\nassert op_takewhilepos_haszero([3, 1, 2]) == False\nassert op_takewhilepos_haszero([10]) == False\nassert op_takewhilepos_haszero([2, 4, 6]) == False\nassert op_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_last3", "entry_point": "op_dropfirst_last3", "primitives": ["dropfirst", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three.", "solution": "def op_dropfirst_last3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_dropfirst_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_last3([]) == []\nassert op_dropfirst_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_last3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_last3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_last3([10]) == []\nassert op_dropfirst_last3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_prod", "entry_point": "op_absval_prod", "primitives": ["absval", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return their product.", "solution": "def op_absval_prod(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_absval_prod([1, 2, 3, 4]) == 24\nassert op_absval_prod([]) == 1\nassert op_absval_prod([-2, -1, 0, 1, 2]) == 0\nassert op_absval_prod([5, 5, 5]) == 125\nassert op_absval_prod([3, 1, 2]) == 6\nassert op_absval_prod([10]) == 10\nassert op_absval_prod([2, 4, 6]) == 48\nassert op_absval_prod([-7, 12, -7]) == 588"}
{"id": "op_div3_add10", "entry_point": "op_div3_add10", "primitives": ["div3", "add10"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each.", "solution": "def op_div3_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_div3_add10([1, 2, 3, 4]) == [13]\nassert op_div3_add10([]) == []\nassert op_div3_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_div3_add10([5, 5, 5]) == []\nassert op_div3_add10([3, 1, 2]) == [13]\nassert op_div3_add10([10]) == []\nassert op_div3_add10([2, 4, 6]) == [16]\nassert op_div3_add10([-7, 12, -7]) == [22]"}
{"id": "op_last3_evens", "entry_point": "op_last3_evens", "primitives": ["last3", "evens"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers.", "solution": "def op_last3_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_last3_evens([]) == []\nassert op_last3_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_last3_evens([5, 5, 5]) == []\nassert op_last3_evens([3, 1, 2]) == [2]\nassert op_last3_evens([10]) == [10]\nassert op_last3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_last3_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortd_first3", "entry_point": "op_sortd_first3", "primitives": ["sortd", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the first three.", "solution": "def op_sortd_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_sortd_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortd_first3([]) == []\nassert op_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_sortd_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_first3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_first3([10]) == [10]\nassert op_sortd_first3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortabs_len", "entry_point": "op_sortabs_len", "primitives": ["sortabs", "len"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return how many remain.", "solution": "def op_sortabs_len(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_sortabs_len([1, 2, 3, 4]) == 4\nassert op_sortabs_len([]) == 0\nassert op_sortabs_len([-2, -1, 0, 1, 2]) == 5\nassert op_sortabs_len([5, 5, 5]) == 3\nassert op_sortabs_len([3, 1, 2]) == 3\nassert op_sortabs_len([10]) == 1\nassert op_sortabs_len([2, 4, 6]) == 3\nassert op_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_rev_takewhilepos", "entry_point": "op_rev_takewhilepos", "primitives": ["rev", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take values while they are positive.", "solution": "def op_rev_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_takewhilepos([]) == []\nassert op_rev_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_takewhilepos([10]) == [10]\nassert op_rev_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sortabs", "entry_point": "op_takewhilepos_sortabs", "primitives": ["takewhilepos", "sortabs"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value.", "solution": "def op_takewhilepos_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_sortabs([]) == []\nassert op_takewhilepos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_sortabs([10]) == [10]\nassert op_takewhilepos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_sortabs([-7, 12, -7]) == []"}
{"id": "op_gt5_double", "entry_point": "op_gt5_double", "primitives": ["gt5", "double"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each.", "solution": "def op_gt5_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_gt5_double([1, 2, 3, 4]) == []\nassert op_gt5_double([]) == []\nassert op_gt5_double([-2, -1, 0, 1, 2]) == []\nassert op_gt5_double([5, 5, 5]) == []\nassert op_gt5_double([3, 1, 2]) == []\nassert op_gt5_double([10]) == [20]\nassert op_gt5_double([2, 4, 6]) == [12]\nassert op_gt5_double([-7, 12, -7]) == [24]"}
{"id": "op_uniq_dropwhileneg", "entry_point": "op_uniq_dropwhileneg", "primitives": ["uniq", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_uniq_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_dropwhileneg([]) == []\nassert op_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_dropwhileneg([5, 5, 5]) == [5]\nassert op_uniq_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_dropwhileneg([10]) == [10]\nassert op_uniq_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_dec_sum", "entry_point": "op_dec_sum", "primitives": ["dec", "sum"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return their sum.", "solution": "def op_dec_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return sum(r)", "tests": "assert op_dec_sum([1, 2, 3, 4]) == 6\nassert op_dec_sum([]) == 0\nassert op_dec_sum([-2, -1, 0, 1, 2]) == -5\nassert op_dec_sum([5, 5, 5]) == 12\nassert op_dec_sum([3, 1, 2]) == 3\nassert op_dec_sum([10]) == 9\nassert op_dec_sum([2, 4, 6]) == 9\nassert op_dec_sum([-7, 12, -7]) == -5"}
{"id": "op_square_sortd", "entry_point": "op_square_sortd", "primitives": ["square", "sortd"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending.", "solution": "def op_square_sortd(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_sortd([]) == []\nassert op_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_square_sortd([10]) == [100]\nassert op_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_square_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_firstchar_strip", "entry_point": "op_firstchar_strip", "primitives": ["firstchar", "strip"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then trim whitespace from each.", "solution": "def op_firstchar_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_strip(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_strip([]) == []\nassert op_firstchar_strip(['  a ', '', 'BC', 'bc']) == ['', 'B', 'b']\nassert op_firstchar_strip(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_firstchar_strip(['x']) == ['x']\nassert op_firstchar_strip(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_dropwhileneg_firsteven", "entry_point": "op_dropwhileneg_firsteven", "primitives": ["dropwhileneg", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropwhileneg_firsteven([1, 2, 3, 4]) == 2\nassert op_dropwhileneg_firsteven([]) == 0\nassert op_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_dropwhileneg_firsteven([3, 1, 2]) == 2\nassert op_dropwhileneg_firsteven([10]) == 10\nassert op_dropwhileneg_firsteven([2, 4, 6]) == 2\nassert op_dropwhileneg_firsteven([-7, 12, -7]) == 12"}
{"id": "op_rev_alldistinct", "entry_point": "op_rev_alldistinct", "primitives": ["rev", "alldistinct"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return whether all values are distinct.", "solution": "def op_rev_alldistinct(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_rev_alldistinct([]) == True\nassert op_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_rev_alldistinct([5, 5, 5]) == False\nassert op_rev_alldistinct([3, 1, 2]) == True\nassert op_rev_alldistinct([10]) == True\nassert op_rev_alldistinct([2, 4, 6]) == True\nassert op_rev_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropshort_upper", "entry_point": "op_dropshort_upper", "primitives": ["dropshort", "upper"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string.", "solution": "def op_dropshort_upper(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_dropshort_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_dropshort_upper([]) == []\nassert op_dropshort_upper(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_dropshort_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_dropshort_upper(['x']) == []\nassert op_dropshort_upper(['abc', 'de', '']) == ['ABC']"}
{"id": "op_odds_firsteven", "entry_point": "op_odds_firsteven", "primitives": ["odds", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_odds_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_odds_firsteven([]) == 0\nassert op_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_firsteven([5, 5, 5]) == 0\nassert op_odds_firsteven([3, 1, 2]) == 0\nassert op_odds_firsteven([10]) == 0\nassert op_odds_firsteven([2, 4, 6]) == 0\nassert op_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_first3", "entry_point": "op_dropfirst_first3", "primitives": ["dropfirst", "first3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three.", "solution": "def op_dropfirst_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_first3([]) == []\nassert op_dropfirst_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dropfirst_first3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_first3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_first3([10]) == []\nassert op_dropfirst_first3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_firstchar_lens", "entry_point": "op_firstchar_lens", "primitives": ["firstchar", "lens"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then return the total number of characters.", "solution": "def op_firstchar_lens(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return sum(len(s) for s in r)", "tests": "assert op_firstchar_lens(['Hello', 'world']) == 2\nassert op_firstchar_lens([]) == 0\nassert op_firstchar_lens(['  a ', '', 'BC', 'bc']) == 3\nassert op_firstchar_lens(['one', 'one', 'Two']) == 3\nassert op_firstchar_lens(['x']) == 1\nassert op_firstchar_lens(['abc', 'de', '']) == 2"}
{"id": "op_beforezero_firsteven", "entry_point": "op_beforezero_firsteven", "primitives": ["beforezero", "firsteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_beforezero_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_firsteven([]) == 0\nassert op_beforezero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_firsteven([5, 5, 5]) == 0\nassert op_beforezero_firsteven([3, 1, 2]) == 2\nassert op_beforezero_firsteven([10]) == 10\nassert op_beforezero_firsteven([2, 4, 6]) == 2\nassert op_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_div3_counteven", "entry_point": "op_div3_counteven", "primitives": ["div3", "counteven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return how many values are even.", "solution": "def op_div3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_div3_counteven([1, 2, 3, 4]) == 0\nassert op_div3_counteven([]) == 0\nassert op_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_div3_counteven([5, 5, 5]) == 0\nassert op_div3_counteven([3, 1, 2]) == 0\nassert op_div3_counteven([10]) == 0\nassert op_div3_counteven([2, 4, 6]) == 1\nassert op_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_div3_dropwhileneg", "entry_point": "op_div3_dropwhileneg", "primitives": ["div3", "dropwhileneg"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the leading negative values.", "solution": "def op_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_div3_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_div3_dropwhileneg([]) == []\nassert op_div3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_dropwhileneg([5, 5, 5]) == []\nassert op_div3_dropwhileneg([3, 1, 2]) == [3]\nassert op_div3_dropwhileneg([10]) == []\nassert op_div3_dropwhileneg([2, 4, 6]) == [6]\nassert op_div3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_lower_maxlen", "entry_point": "op_lower_maxlen", "primitives": ["lower", "maxlen"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then return the length of the longest string (0 if none).", "solution": "def op_lower_maxlen(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_lower_maxlen(['Hello', 'world']) == 5\nassert op_lower_maxlen([]) == 0\nassert op_lower_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_lower_maxlen(['one', 'one', 'Two']) == 3\nassert op_lower_maxlen(['x']) == 1\nassert op_lower_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_prefixup_sortalpha", "entry_point": "op_prefixup_sortalpha", "primitives": ["prefixup", "sortalpha"], "difficulty": 1, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort alphabetically.", "solution": "def op_prefixup_sortalpha(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_prefixup_sortalpha(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_sortalpha([]) == []\nassert op_prefixup_sortalpha(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_prefixup_sortalpha(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_prefixup_sortalpha(['x']) == ['#x']\nassert op_prefixup_sortalpha(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_first3_takewhilepos", "entry_point": "op_first3_takewhilepos", "primitives": ["first3", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive.", "solution": "def op_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_first3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_takewhilepos([]) == []\nassert op_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_first3_takewhilepos([10]) == [10]\nassert op_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_first3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_evens_haszero", "entry_point": "op_evens_haszero", "primitives": ["evens", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return whether the list contains a zero.", "solution": "def op_evens_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return 0 in r", "tests": "assert op_evens_haszero([1, 2, 3, 4]) == False\nassert op_evens_haszero([]) == False\nassert op_evens_haszero([-2, -1, 0, 1, 2]) == True\nassert op_evens_haszero([5, 5, 5]) == False\nassert op_evens_haszero([3, 1, 2]) == False\nassert op_evens_haszero([10]) == False\nassert op_evens_haszero([2, 4, 6]) == False\nassert op_evens_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_haszero", "entry_point": "op_sortd_haszero", "primitives": ["sortd", "haszero"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return whether the list contains a zero.", "solution": "def op_sortd_haszero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_sortd_haszero([1, 2, 3, 4]) == False\nassert op_sortd_haszero([]) == False\nassert op_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortd_haszero([5, 5, 5]) == False\nassert op_sortd_haszero([3, 1, 2]) == False\nassert op_sortd_haszero([10]) == False\nassert op_sortd_haszero([2, 4, 6]) == False\nassert op_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_last3", "entry_point": "op_uniq_last3", "primitives": ["uniq", "last3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three.", "solution": "def op_uniq_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_last3([]) == []\nassert op_uniq_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_last3([5, 5, 5]) == [5]\nassert op_uniq_last3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_last3([10]) == [10]\nassert op_uniq_last3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_last3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_ages_inc", "entry_point": "op_ages_inc", "primitives": ["ages", "inc"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add one to each.", "solution": "def op_ages_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [37, 13]\nassert op_ages_inc([]) == []\nassert op_ages_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [19, 66, 18]\nassert op_ages_inc([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_absval_padto3", "entry_point": "op_absval_padto3", "primitives": ["absval", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_absval_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_padto3([]) == [0, 0, 0]\nassert op_absval_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_padto3([10]) == [10, 0, 0]\nassert op_absval_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_padto3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sortd_prod", "entry_point": "op_sortd_prod", "primitives": ["sortd", "prod"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then return their product.", "solution": "def op_sortd_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return __import__('math').prod(r)", "tests": "assert op_sortd_prod([1, 2, 3, 4]) == 24\nassert op_sortd_prod([]) == 1\nassert op_sortd_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_prod([5, 5, 5]) == 125\nassert op_sortd_prod([3, 1, 2]) == 6\nassert op_sortd_prod([10]) == 10\nassert op_sortd_prod([2, 4, 6]) == 48\nassert op_sortd_prod([-7, 12, -7]) == 588"}
{"id": "op_absval_div3", "entry_point": "op_absval_div3", "primitives": ["absval", "div3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three.", "solution": "def op_absval_div3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_absval_div3([1, 2, 3, 4]) == [3]\nassert op_absval_div3([]) == []\nassert op_absval_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_absval_div3([5, 5, 5]) == []\nassert op_absval_div3([3, 1, 2]) == [3]\nassert op_absval_div3([10]) == []\nassert op_absval_div3([2, 4, 6]) == [6]\nassert op_absval_div3([-7, 12, -7]) == [12]"}
{"id": "op_sorta_padto3", "entry_point": "op_sorta_padto3", "primitives": ["sorta", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements.", "solution": "def op_sorta_padto3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sorta_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_padto3([]) == [0, 0, 0]\nassert op_sorta_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_padto3([10]) == [10, 0, 0]\nassert op_sorta_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_clamp10_padto3", "entry_point": "op_clamp10_padto3", "primitives": ["clamp10", "padto3"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_clamp10_padto3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_clamp10_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_padto3([]) == [0, 0, 0]\nassert op_clamp10_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3([10]) == [10, 0, 0]\nassert op_clamp10_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_gt5_takewhilepos", "entry_point": "op_gt5_takewhilepos", "primitives": ["gt5", "takewhilepos"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive.", "solution": "def op_gt5_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos([]) == []\nassert op_gt5_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos([5, 5, 5]) == []\nassert op_gt5_takewhilepos([3, 1, 2]) == []\nassert op_gt5_takewhilepos([10]) == [10]\nassert op_gt5_takewhilepos([2, 4, 6]) == [6]\nassert op_gt5_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_neg_anyeven", "entry_point": "op_neg_anyeven", "primitives": ["neg", "anyeven"], "difficulty": 1, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return whether any value is even.", "solution": "def op_neg_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_neg_anyeven([1, 2, 3, 4]) == False\nassert op_neg_anyeven([]) == False\nassert op_neg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_neg_anyeven([5, 5, 5]) == False\nassert op_neg_anyeven([3, 1, 2]) == False\nassert op_neg_anyeven([10]) == False\nassert op_neg_anyeven([2, 4, 6]) == False\nassert op_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_ages_trimends", "entry_point": "op_ages_trimends", "primitives": ["ages", "trimends"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements.", "solution": "def op_ages_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends([]) == []\nassert op_ages_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_ages_max", "entry_point": "op_ages_max", "primitives": ["ages", "max"], "difficulty": 1, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return the maximum (0 if empty).", "solution": "def op_ages_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return max(r) if r else 0", "tests": "assert op_ages_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_max([]) == 0\nassert op_ages_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_last3_sum", "entry_point": "op_last3_sum", "primitives": ["last3", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return their sum.", "solution": "def op_last3_sum(xs):\n    r = list(xs)\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_last3_sum([1, 2, 3, 4]) == 9\nassert op_last3_sum([]) == 0\nassert op_last3_sum([-2, -1, 0, 1, 2]) == 3\nassert op_last3_sum([5, 5, 5]) == 15\nassert op_last3_sum([3, 1, 2]) == 6\nassert op_last3_sum([10]) == 10\nassert op_last3_sum([2, 4, 6]) == 12\nassert op_last3_sum([-7, 12, -7]) == -2"}
{"id": "op_negate_min", "entry_point": "op_negate_min", "primitives": ["negate", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then return the minimum (0 if empty).", "solution": "def op_negate_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return min(r) if r else 0", "tests": "assert op_negate_min([1, 2, 3, 4]) == -4\nassert op_negate_min([]) == 0\nassert op_negate_min([-2, -1, 0, 1, 2]) == -2\nassert op_negate_min([5, 5, 5]) == -5\nassert op_negate_min([3, 1, 2]) == -3\nassert op_negate_min([10]) == -10\nassert op_negate_min([2, 4, 6]) == -6\nassert op_negate_min([-7, 12, -7]) == -12"}
{"id": "op_sorta_len", "entry_point": "op_sorta_len", "primitives": ["sorta", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return how many remain.", "solution": "def op_sorta_len(xs):\n    r = list(xs)\n    r = sorted(r)\n    return len(r)", "tests": "assert op_sorta_len([1, 2, 3, 4]) == 4\nassert op_sorta_len([]) == 0\nassert op_sorta_len([-2, -1, 0, 1, 2]) == 5\nassert op_sorta_len([5, 5, 5]) == 3\nassert op_sorta_len([3, 1, 2]) == 3\nassert op_sorta_len([10]) == 1\nassert op_sorta_len([2, 4, 6]) == 3\nassert op_sorta_len([-7, 12, -7]) == 3"}
{"id": "op_sortabs_counteven", "entry_point": "op_sortabs_counteven", "primitives": ["sortabs", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return how many values are even.", "solution": "def op_sortabs_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortabs_counteven([1, 2, 3, 4]) == 2\nassert op_sortabs_counteven([]) == 0\nassert op_sortabs_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sortabs_counteven([5, 5, 5]) == 0\nassert op_sortabs_counteven([3, 1, 2]) == 1\nassert op_sortabs_counteven([10]) == 1\nassert op_sortabs_counteven([2, 4, 6]) == 3\nassert op_sortabs_counteven([-7, 12, -7]) == 1"}
{"id": "op_firstchar_counts", "entry_point": "op_firstchar_counts", "primitives": ["firstchar", "counts"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then return how many strings remain.", "solution": "def op_firstchar_counts(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    return len(r)", "tests": "assert op_firstchar_counts(['Hello', 'world']) == 2\nassert op_firstchar_counts([]) == 0\nassert op_firstchar_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_firstchar_counts(['one', 'one', 'Two']) == 3\nassert op_firstchar_counts(['x']) == 1\nassert op_firstchar_counts(['abc', 'de', '']) == 2"}
{"id": "op_evens_clamp10", "entry_point": "op_evens_clamp10", "primitives": ["evens", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10.", "solution": "def op_evens_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_clamp10([1, 2, 3, 4]) == [2, 4]\nassert op_evens_clamp10([]) == []\nassert op_evens_clamp10([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_clamp10([5, 5, 5]) == []\nassert op_evens_clamp10([3, 1, 2]) == [2]\nassert op_evens_clamp10([10]) == [10]\nassert op_evens_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_evens_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_dec_takewhilepos", "entry_point": "op_dec_takewhilepos", "primitives": ["dec", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive.", "solution": "def op_dec_takewhilepos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dec_takewhilepos([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos([]) == []\nassert op_dec_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos([5, 5, 5]) == [4, 4, 4]\nassert op_dec_takewhilepos([3, 1, 2]) == [2]\nassert op_dec_takewhilepos([10]) == [9]\nassert op_dec_takewhilepos([2, 4, 6]) == [1, 3, 5]\nassert op_dec_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_odds_pos", "entry_point": "op_odds_pos", "primitives": ["odds", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers.", "solution": "def op_odds_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_odds_pos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_pos([]) == []\nassert op_odds_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos([5, 5, 5]) == [5, 5, 5]\nassert op_odds_pos([3, 1, 2]) == [3, 1]\nassert op_odds_pos([10]) == []\nassert op_odds_pos([2, 4, 6]) == []\nassert op_odds_pos([-7, 12, -7]) == []"}
{"id": "op_neg_first3", "entry_point": "op_neg_first3", "primitives": ["neg", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three.", "solution": "def op_neg_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_neg_first3([1, 2, 3, 4]) == []\nassert op_neg_first3([]) == []\nassert op_neg_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_first3([5, 5, 5]) == []\nassert op_neg_first3([3, 1, 2]) == []\nassert op_neg_first3([10]) == []\nassert op_neg_first3([2, 4, 6]) == []\nassert op_neg_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_oremptyzero", "entry_point": "op_square_oremptyzero", "primitives": ["square", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then if empty, use a single zero.", "solution": "def op_square_oremptyzero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_square_oremptyzero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_oremptyzero([]) == [0]\nassert op_square_oremptyzero([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_oremptyzero([5, 5, 5]) == [25, 25, 25]\nassert op_square_oremptyzero([3, 1, 2]) == [9, 1, 4]\nassert op_square_oremptyzero([10]) == [100]\nassert op_square_oremptyzero([2, 4, 6]) == [4, 16, 36]\nassert op_square_oremptyzero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_gt5_padto3", "entry_point": "op_gt5_padto3", "primitives": ["gt5", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements.", "solution": "def op_gt5_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_gt5_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_padto3([]) == [0, 0, 0]\nassert op_gt5_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3([10]) == [10, 0, 0]\nassert op_gt5_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_gt5_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_odds_evens", "entry_point": "op_odds_evens", "primitives": ["odds", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers.", "solution": "def op_odds_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_odds_evens([1, 2, 3, 4]) == []\nassert op_odds_evens([]) == []\nassert op_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens([5, 5, 5]) == []\nassert op_odds_evens([3, 1, 2]) == []\nassert op_odds_evens([10]) == []\nassert op_odds_evens([2, 4, 6]) == []\nassert op_odds_evens([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_allpos", "entry_point": "op_oremptyzero_allpos", "primitives": ["oremptyzero", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return whether all values are positive.", "solution": "def op_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_oremptyzero_allpos([]) == False\nassert op_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_allpos([5, 5, 5]) == True\nassert op_oremptyzero_allpos([3, 1, 2]) == True\nassert op_oremptyzero_allpos([10]) == True\nassert op_oremptyzero_allpos([2, 4, 6]) == True\nassert op_oremptyzero_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_gt5", "entry_point": "op_last3_gt5", "primitives": ["last3", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep values greater than five.", "solution": "def op_last3_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_gt5([1, 2, 3, 4]) == []\nassert op_last3_gt5([]) == []\nassert op_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_gt5([5, 5, 5]) == []\nassert op_last3_gt5([3, 1, 2]) == []\nassert op_last3_gt5([10]) == [10]\nassert op_last3_gt5([2, 4, 6]) == [6]\nassert op_last3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_uniq_negate", "entry_point": "op_uniq_negate", "primitives": ["uniq", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each.", "solution": "def op_uniq_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_negate([]) == []\nassert op_uniq_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_negate([5, 5, 5]) == [-5]\nassert op_uniq_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_negate([10]) == [-10]\nassert op_uniq_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_negate([-7, 12, -7]) == [7, -12]"}
{"id": "op_dropzeros_rev", "entry_point": "op_dropzeros_rev", "primitives": ["dropzeros", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order.", "solution": "def op_dropzeros_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropzeros_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_rev([]) == []\nassert op_dropzeros_rev([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropzeros_rev([10]) == [10]\nassert op_dropzeros_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_div3_haszero", "entry_point": "op_div3_haszero", "primitives": ["div3", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return whether the list contains a zero.", "solution": "def op_div3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return 0 in r", "tests": "assert op_div3_haszero([1, 2, 3, 4]) == False\nassert op_div3_haszero([]) == False\nassert op_div3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_haszero([5, 5, 5]) == False\nassert op_div3_haszero([3, 1, 2]) == False\nassert op_div3_haszero([10]) == False\nassert op_div3_haszero([2, 4, 6]) == False\nassert op_div3_haszero([-7, 12, -7]) == False"}
{"id": "op_ages_dropzeros", "entry_point": "op_ages_dropzeros", "primitives": ["ages", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros.", "solution": "def op_ages_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropzeros([]) == []\nassert op_ages_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropzeros([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortd_odds", "entry_point": "op_sortd_odds", "primitives": ["sortd", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers.", "solution": "def op_sortd_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_odds([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_odds([]) == []\nassert op_sortd_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_odds([3, 1, 2]) == [3, 1]\nassert op_sortd_odds([10]) == []\nassert op_sortd_odds([2, 4, 6]) == []\nassert op_sortd_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_odds", "entry_point": "op_sortabs_odds", "primitives": ["sortabs", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the odd numbers.", "solution": "def op_sortabs_odds(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortabs_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sortabs_odds([]) == []\nassert op_sortabs_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sortabs_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_odds([3, 1, 2]) == [1, 3]\nassert op_sortabs_odds([10]) == []\nassert op_sortabs_odds([2, 4, 6]) == []\nassert op_sortabs_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_strip_anyempty", "entry_point": "op_strip_anyempty", "primitives": ["strip", "anyempty"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then return whether any string is empty.", "solution": "def op_strip_anyempty(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_strip_anyempty(['Hello', 'world']) == False\nassert op_strip_anyempty([]) == False\nassert op_strip_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_strip_anyempty(['one', 'one', 'Two']) == False\nassert op_strip_anyempty(['x']) == False\nassert op_strip_anyempty(['abc', 'de', '']) == True"}
{"id": "op_ages_rev", "entry_point": "op_ages_rev", "primitives": ["ages", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order.", "solution": "def op_ages_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_rev([]) == []\nassert op_ages_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dec_sortabs", "entry_point": "op_dec_sortabs", "primitives": ["dec", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value.", "solution": "def op_dec_sortabs(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dec_sortabs([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sortabs([]) == []\nassert op_dec_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, -3]\nassert op_dec_sortabs([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortabs([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sortabs([10]) == [9]\nassert op_dec_sortabs([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sortabs([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_dropwhileneg_uniq", "entry_point": "op_dropwhileneg_uniq", "primitives": ["dropwhileneg", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropwhileneg_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_uniq([]) == []\nassert op_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_uniq([5, 5, 5]) == [5]\nassert op_dropwhileneg_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_uniq([10]) == [10]\nassert op_dropwhileneg_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_dropwhileneg", "entry_point": "op_absval_dropwhileneg", "primitives": ["absval", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values.", "solution": "def op_absval_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_dropwhileneg([]) == []\nassert op_absval_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_absval_dropwhileneg([10]) == [10]\nassert op_absval_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_absval_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sortabs_prod", "entry_point": "op_sortabs_prod", "primitives": ["sortabs", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return their product.", "solution": "def op_sortabs_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_prod([1, 2, 3, 4]) == 24\nassert op_sortabs_prod([]) == 1\nassert op_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_prod([5, 5, 5]) == 125\nassert op_sortabs_prod([3, 1, 2]) == 6\nassert op_sortabs_prod([10]) == 10\nassert op_sortabs_prod([2, 4, 6]) == 48\nassert op_sortabs_prod([-7, 12, -7]) == 588"}
{"id": "op_neg_counteven", "entry_point": "op_neg_counteven", "primitives": ["neg", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then return how many values are even.", "solution": "def op_neg_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_counteven([1, 2, 3, 4]) == 0\nassert op_neg_counteven([]) == 0\nassert op_neg_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_counteven([5, 5, 5]) == 0\nassert op_neg_counteven([3, 1, 2]) == 0\nassert op_neg_counteven([10]) == 0\nassert op_neg_counteven([2, 4, 6]) == 0\nassert op_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_div3_sum", "entry_point": "op_div3_sum", "primitives": ["div3", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return their sum.", "solution": "def op_div3_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return sum(r)", "tests": "assert op_div3_sum([1, 2, 3, 4]) == 3\nassert op_div3_sum([]) == 0\nassert op_div3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_div3_sum([5, 5, 5]) == 0\nassert op_div3_sum([3, 1, 2]) == 3\nassert op_div3_sum([10]) == 0\nassert op_div3_sum([2, 4, 6]) == 6\nassert op_div3_sum([-7, 12, -7]) == 12"}
{"id": "op_names_joinc", "entry_point": "op_names_joinc", "primitives": ["names", "joinc"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then join them with commas.", "solution": "def op_names_joinc(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return ','.join(r)", "tests": "assert op_names_joinc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada,Bo'\nassert op_names_joinc([]) == ''\nassert op_names_joinc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Cy,Dee,El'\nassert op_names_joinc([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_inc_trimends", "entry_point": "op_inc_trimends", "primitives": ["inc", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements.", "solution": "def op_inc_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends([]) == []\nassert op_inc_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends([5, 5, 5]) == [6]\nassert op_inc_trimends([3, 1, 2]) == [2]\nassert op_inc_trimends([10]) == []\nassert op_inc_trimends([2, 4, 6]) == [5]\nassert op_inc_trimends([-7, 12, -7]) == [13]"}
{"id": "op_add10_sortabs", "entry_point": "op_add10_sortabs", "primitives": ["add10", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value.", "solution": "def op_add10_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_sortabs([]) == []\nassert op_add10_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_add10_sortabs([10]) == [20]\nassert op_add10_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_dropshort_firstchar", "entry_point": "op_dropshort_firstchar", "primitives": ["dropshort", "firstchar"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then keep the first character of each (dropping empties).", "solution": "def op_dropshort_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_dropshort_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_dropshort_firstchar([]) == []\nassert op_dropshort_firstchar(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_dropshort_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_dropshort_firstchar(['x']) == []\nassert op_dropshort_firstchar(['abc', 'de', '']) == ['a']"}
{"id": "op_uniq_max", "entry_point": "op_uniq_max", "primitives": ["uniq", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_uniq_max(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_uniq_max([1, 2, 3, 4]) == 4\nassert op_uniq_max([]) == 0\nassert op_uniq_max([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_max([5, 5, 5]) == 5\nassert op_uniq_max([3, 1, 2]) == 3\nassert op_uniq_max([10]) == 10\nassert op_uniq_max([2, 4, 6]) == 6\nassert op_uniq_max([-7, 12, -7]) == 12"}
{"id": "op_evens_alldistinct", "entry_point": "op_evens_alldistinct", "primitives": ["evens", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return whether all values are distinct.", "solution": "def op_evens_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_evens_alldistinct([]) == True\nassert op_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_evens_alldistinct([5, 5, 5]) == True\nassert op_evens_alldistinct([3, 1, 2]) == True\nassert op_evens_alldistinct([10]) == True\nassert op_evens_alldistinct([2, 4, 6]) == True\nassert op_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_negate_rev", "entry_point": "op_negate_rev", "primitives": ["negate", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then reverse the order.", "solution": "def op_negate_rev(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_negate_rev([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_negate_rev([]) == []\nassert op_negate_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_negate_rev([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_rev([3, 1, 2]) == [-2, -1, -3]\nassert op_negate_rev([10]) == [-10]\nassert op_negate_rev([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_rev([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sortabs_sortd", "entry_point": "op_sortabs_sortd", "primitives": ["sortabs", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort descending.", "solution": "def op_sortabs_sortd(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_sortd([]) == []\nassert op_sortabs_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortabs_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_sortd([10]) == [10]\nassert op_sortabs_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_negate_square", "entry_point": "op_negate_square", "primitives": ["negate", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then square each.", "solution": "def op_negate_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_square([]) == []\nassert op_negate_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_square([5, 5, 5]) == [25, 25, 25]\nassert op_negate_square([3, 1, 2]) == [9, 1, 4]\nassert op_negate_square([10]) == [100]\nassert op_negate_square([2, 4, 6]) == [4, 16, 36]\nassert op_negate_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_trimends_dropfirst", "entry_point": "op_trimends_dropfirst", "primitives": ["trimends", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the first element.", "solution": "def op_trimends_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_dropfirst([1, 2, 3, 4]) == [3]\nassert op_trimends_dropfirst([]) == []\nassert op_trimends_dropfirst([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_dropfirst([5, 5, 5]) == []\nassert op_trimends_dropfirst([3, 1, 2]) == []\nassert op_trimends_dropfirst([10]) == []\nassert op_trimends_dropfirst([2, 4, 6]) == []\nassert op_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_uniqs_longest", "entry_point": "op_uniqs_longest", "primitives": ["uniqs", "longest"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then return the longest string (empty if none).", "solution": "def op_uniqs_longest(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return max(r, key=len) if r else ''", "tests": "assert op_uniqs_longest(['Hello', 'world']) == 'Hello'\nassert op_uniqs_longest([]) == ''\nassert op_uniqs_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_uniqs_longest(['one', 'one', 'Two']) == 'one'\nassert op_uniqs_longest(['x']) == 'x'\nassert op_uniqs_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_takewhilepos_max", "entry_point": "op_takewhilepos_max", "primitives": ["takewhilepos", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_takewhilepos_max([]) == 0\nassert op_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_max([5, 5, 5]) == 5\nassert op_takewhilepos_max([3, 1, 2]) == 3\nassert op_takewhilepos_max([10]) == 10\nassert op_takewhilepos_max([2, 4, 6]) == 6\nassert op_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_strip_prefixup", "entry_point": "op_strip_prefixup", "primitives": ["strip", "prefixup"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash.", "solution": "def op_strip_prefixup(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_strip_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_prefixup([]) == []\nassert op_strip_prefixup(['  a ', '', 'BC', 'bc']) == ['#a', '#', '#BC', '#bc']\nassert op_strip_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_strip_prefixup(['x']) == ['#x']\nassert op_strip_prefixup(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_negate_dropwhileneg", "entry_point": "op_negate_dropwhileneg", "primitives": ["negate", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values.", "solution": "def op_negate_dropwhileneg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_negate_dropwhileneg([1, 2, 3, 4]) == []\nassert op_negate_dropwhileneg([]) == []\nassert op_negate_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_dropwhileneg([5, 5, 5]) == []\nassert op_negate_dropwhileneg([3, 1, 2]) == []\nassert op_negate_dropwhileneg([10]) == []\nassert op_negate_dropwhileneg([2, 4, 6]) == []\nassert op_negate_dropwhileneg([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_evens_rev", "entry_point": "op_evens_rev", "primitives": ["evens", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order.", "solution": "def op_evens_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_evens_rev([]) == []\nassert op_evens_rev([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_rev([5, 5, 5]) == []\nassert op_evens_rev([3, 1, 2]) == [2]\nassert op_evens_rev([10]) == [10]\nassert op_evens_rev([2, 4, 6]) == [6, 4, 2]\nassert op_evens_rev([-7, 12, -7]) == [12]"}
{"id": "op_square_gt5", "entry_point": "op_square_gt5", "primitives": ["square", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five.", "solution": "def op_square_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_gt5([1, 2, 3, 4]) == [9, 16]\nassert op_square_gt5([]) == []\nassert op_square_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5([3, 1, 2]) == [9]\nassert op_square_gt5([10]) == [100]\nassert op_square_gt5([2, 4, 6]) == [16, 36]\nassert op_square_gt5([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_gt5_negate", "entry_point": "op_gt5_negate", "primitives": ["gt5", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each.", "solution": "def op_gt5_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_negate([1, 2, 3, 4]) == []\nassert op_gt5_negate([]) == []\nassert op_gt5_negate([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate([5, 5, 5]) == []\nassert op_gt5_negate([3, 1, 2]) == []\nassert op_gt5_negate([10]) == [-10]\nassert op_gt5_negate([2, 4, 6]) == [-6]\nassert op_gt5_negate([-7, 12, -7]) == [-12]"}
{"id": "op_dropfirst_gt5", "entry_point": "op_dropfirst_gt5", "primitives": ["dropfirst", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep values greater than five.", "solution": "def op_dropfirst_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_gt5([]) == []\nassert op_dropfirst_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_gt5([5, 5, 5]) == []\nassert op_dropfirst_gt5([3, 1, 2]) == []\nassert op_dropfirst_gt5([10]) == []\nassert op_dropfirst_gt5([2, 4, 6]) == [6]\nassert op_dropfirst_gt5([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dropwhileneg", "entry_point": "op_oremptyzero_dropwhileneg", "primitives": ["oremptyzero", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values.", "solution": "def op_oremptyzero_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_dropwhileneg([]) == [0]\nassert op_oremptyzero_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_dropwhileneg([10]) == [10]\nassert op_oremptyzero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_trimends", "entry_point": "op_padto3_trimends", "primitives": ["padto3", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_padto3_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_trimends([]) == [0]\nassert op_padto3_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_trimends([5, 5, 5]) == [5]\nassert op_padto3_trimends([3, 1, 2]) == [1]\nassert op_padto3_trimends([10]) == [0]\nassert op_padto3_trimends([2, 4, 6]) == [4]\nassert op_padto3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_last3_oremptyzero", "entry_point": "op_last3_oremptyzero", "primitives": ["last3", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero.", "solution": "def op_last3_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_oremptyzero([]) == [0]\nassert op_last3_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_last3_oremptyzero([10]) == [10]\nassert op_last3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_last3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_takewhilepos_dec", "entry_point": "op_takewhilepos_dec", "primitives": ["takewhilepos", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each.", "solution": "def op_takewhilepos_dec(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_takewhilepos_dec([]) == []\nassert op_takewhilepos_dec([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_dec([3, 1, 2]) == [2, 0, 1]\nassert op_takewhilepos_dec([10]) == [9]\nassert op_takewhilepos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_takewhilepos_dec([-7, 12, -7]) == []"}
{"id": "op_clamp10_rev", "entry_point": "op_clamp10_rev", "primitives": ["clamp10", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order.", "solution": "def op_clamp10_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_rev([]) == []\nassert op_clamp10_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_rev([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_rev([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_rev([10]) == [10]\nassert op_clamp10_rev([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_rev([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_add10_dropzeros", "entry_point": "op_add10_dropzeros", "primitives": ["add10", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros.", "solution": "def op_add10_dropzeros(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_add10_dropzeros([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros([]) == []\nassert op_add10_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropzeros([10]) == [20]\nassert op_add10_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_sortd_oremptyzero", "entry_point": "op_sortd_oremptyzero", "primitives": ["sortd", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero.", "solution": "def op_sortd_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_oremptyzero([]) == [0]\nassert op_sortd_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_oremptyzero([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_oremptyzero([10]) == [10]\nassert op_sortd_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_oremptyzero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortabs_dropwhileneg", "entry_point": "op_sortabs_dropwhileneg", "primitives": ["sortabs", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values.", "solution": "def op_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortabs_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_dropwhileneg([]) == []\nassert op_sortabs_dropwhileneg([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_dropwhileneg([10]) == [10]\nassert op_sortabs_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_negate_sorta", "entry_point": "op_negate_sorta", "primitives": ["negate", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending.", "solution": "def op_negate_sorta(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_negate_sorta([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_negate_sorta([]) == []\nassert op_negate_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_negate_sorta([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sorta([3, 1, 2]) == [-3, -2, -1]\nassert op_negate_sorta([10]) == [-10]\nassert op_negate_sorta([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_sorta([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_trimends_double", "entry_point": "op_trimends_double", "primitives": ["trimends", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each.", "solution": "def op_trimends_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_double([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_double([]) == []\nassert op_trimends_double([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_trimends_double([5, 5, 5]) == [10]\nassert op_trimends_double([3, 1, 2]) == [2]\nassert op_trimends_double([10]) == []\nassert op_trimends_double([2, 4, 6]) == [8]\nassert op_trimends_double([-7, 12, -7]) == [24]"}
{"id": "op_dropwhileneg_len", "entry_point": "op_dropwhileneg_len", "primitives": ["dropwhileneg", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return how many remain.", "solution": "def op_dropwhileneg_len(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r)", "tests": "assert op_dropwhileneg_len([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_len([]) == 0\nassert op_dropwhileneg_len([-2, -1, 0, 1, 2]) == 3\nassert op_dropwhileneg_len([5, 5, 5]) == 3\nassert op_dropwhileneg_len([3, 1, 2]) == 3\nassert op_dropwhileneg_len([10]) == 1\nassert op_dropwhileneg_len([2, 4, 6]) == 3\nassert op_dropwhileneg_len([-7, 12, -7]) == 2"}
{"id": "op_upper_lower", "entry_point": "op_upper_lower", "primitives": ["upper", "lower"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then lowercase each string.", "solution": "def op_upper_lower(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_upper_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_upper_lower([]) == []\nassert op_upper_lower(['  a ', '', 'BC', 'bc']) == ['  a ', '', 'bc', 'bc']\nassert op_upper_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_upper_lower(['x']) == ['x']\nassert op_upper_lower(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_sortd_takewhilepos", "entry_point": "op_sortd_takewhilepos", "primitives": ["sortd", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive.", "solution": "def op_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_takewhilepos([]) == []\nassert op_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_takewhilepos([10]) == [10]\nassert op_sortd_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_first3", "entry_point": "op_uniq_first3", "primitives": ["uniq", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the first three.", "solution": "def op_uniq_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    return r", "tests": "assert op_uniq_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_uniq_first3([]) == []\nassert op_uniq_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_uniq_first3([5, 5, 5]) == [5]\nassert op_uniq_first3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_first3([10]) == [10]\nassert op_uniq_first3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_first3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_last3_allpos", "entry_point": "op_last3_allpos", "primitives": ["last3", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return whether all values are positive.", "solution": "def op_last3_allpos(xs):\n    r = list(xs)\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_last3_allpos([1, 2, 3, 4]) == True\nassert op_last3_allpos([]) == True\nassert op_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_last3_allpos([5, 5, 5]) == True\nassert op_last3_allpos([3, 1, 2]) == True\nassert op_last3_allpos([10]) == True\nassert op_last3_allpos([2, 4, 6]) == True\nassert op_last3_allpos([-7, 12, -7]) == False"}
{"id": "op_rev_allpos", "entry_point": "op_rev_allpos", "primitives": ["rev", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return whether all values are positive.", "solution": "def op_rev_allpos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return all(x > 0 for x in r)", "tests": "assert op_rev_allpos([1, 2, 3, 4]) == True\nassert op_rev_allpos([]) == True\nassert op_rev_allpos([-2, -1, 0, 1, 2]) == False\nassert op_rev_allpos([5, 5, 5]) == True\nassert op_rev_allpos([3, 1, 2]) == True\nassert op_rev_allpos([10]) == True\nassert op_rev_allpos([2, 4, 6]) == True\nassert op_rev_allpos([-7, 12, -7]) == False"}
{"id": "op_upper_strip", "entry_point": "op_upper_strip", "primitives": ["upper", "strip"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then trim whitespace from each.", "solution": "def op_upper_strip(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_upper_strip(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_strip([]) == []\nassert op_upper_strip(['  a ', '', 'BC', 'bc']) == ['A', '', 'BC', 'BC']\nassert op_upper_strip(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_strip(['x']) == ['X']\nassert op_upper_strip(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_clamp10_uniq", "entry_point": "op_clamp10_uniq", "primitives": ["clamp10", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_uniq([]) == []\nassert op_clamp10_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_uniq([5, 5, 5]) == [5]\nassert op_clamp10_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_uniq([10]) == [10]\nassert op_clamp10_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_sortabs_inc", "entry_point": "op_sortabs_inc", "primitives": ["sortabs", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each.", "solution": "def op_sortabs_inc(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortabs_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_inc([]) == []\nassert op_sortabs_inc([-2, -1, 0, 1, 2]) == [1, 0, 2, -1, 3]\nassert op_sortabs_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_inc([10]) == [11]\nassert op_sortabs_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_dec_trimends", "entry_point": "op_dec_trimends", "primitives": ["dec", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first and last elements.", "solution": "def op_dec_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_trimends([1, 2, 3, 4]) == [1, 2]\nassert op_dec_trimends([]) == []\nassert op_dec_trimends([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_dec_trimends([5, 5, 5]) == [4]\nassert op_dec_trimends([3, 1, 2]) == [0]\nassert op_dec_trimends([10]) == []\nassert op_dec_trimends([2, 4, 6]) == [3]\nassert op_dec_trimends([-7, 12, -7]) == [11]"}
{"id": "op_add10_first3", "entry_point": "op_add10_first3", "primitives": ["add10", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three.", "solution": "def op_add10_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_add10_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_first3([]) == []\nassert op_add10_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_first3([10]) == [20]\nassert op_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_dropzeros_dec", "entry_point": "op_dropzeros_dec", "primitives": ["dropzeros", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then subtract one from each.", "solution": "def op_dropzeros_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropzeros_dec([]) == []\nassert op_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_dropzeros_dec([3, 1, 2]) == [2, 0, 1]\nassert op_dropzeros_dec([10]) == [9]\nassert op_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_dropzeros_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropwhileneg_rev", "entry_point": "op_dropwhileneg_rev", "primitives": ["dropwhileneg", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order.", "solution": "def op_dropwhileneg_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_rev([]) == []\nassert op_dropwhileneg_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropwhileneg_rev([10]) == [10]\nassert op_dropwhileneg_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sortlen_lower", "entry_point": "op_sortlen_lower", "primitives": ["sortlen", "lower"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then lowercase each string.", "solution": "def op_sortlen_lower(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_sortlen_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_sortlen_lower([]) == []\nassert op_sortlen_lower(['  a ', '', 'BC', 'bc']) == ['', 'bc', 'bc', '  a ']\nassert op_sortlen_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_sortlen_lower(['x']) == ['x']\nassert op_sortlen_lower(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_firstchar_sortlen", "entry_point": "op_firstchar_sortlen", "primitives": ["firstchar", "sortlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort by length, shortest first.", "solution": "def op_firstchar_sortlen(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_firstchar_sortlen(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_sortlen([]) == []\nassert op_firstchar_sortlen(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_sortlen(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_firstchar_sortlen(['x']) == ['x']\nassert op_firstchar_sortlen(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_trimends_allpos", "entry_point": "op_trimends_allpos", "primitives": ["trimends", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return whether all values are positive.", "solution": "def op_trimends_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_allpos([1, 2, 3, 4]) == True\nassert op_trimends_allpos([]) == True\nassert op_trimends_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_allpos([5, 5, 5]) == True\nassert op_trimends_allpos([3, 1, 2]) == True\nassert op_trimends_allpos([10]) == True\nassert op_trimends_allpos([2, 4, 6]) == True\nassert op_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_evens", "entry_point": "op_takewhilepos_evens", "primitives": ["takewhilepos", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers.", "solution": "def op_takewhilepos_evens(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_takewhilepos_evens([1, 2, 3, 4]) == [2, 4]\nassert op_takewhilepos_evens([]) == []\nassert op_takewhilepos_evens([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens([5, 5, 5]) == []\nassert op_takewhilepos_evens([3, 1, 2]) == [2]\nassert op_takewhilepos_evens([10]) == [10]\nassert op_takewhilepos_evens([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_evens([-7, 12, -7]) == []"}
{"id": "op_square_dropfirst", "entry_point": "op_square_dropfirst", "primitives": ["square", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element.", "solution": "def op_square_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_square_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_dropfirst([]) == []\nassert op_square_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_dropfirst([3, 1, 2]) == [1, 4]\nassert op_square_dropfirst([10]) == []\nassert op_square_dropfirst([2, 4, 6]) == [16, 36]\nassert op_square_dropfirst([-7, 12, -7]) == [144, 49]"}
{"id": "op_dropshort_prefixup", "entry_point": "op_dropshort_prefixup", "primitives": ["dropshort", "prefixup"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then prefix each with a hash.", "solution": "def op_dropshort_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_dropshort_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_dropshort_prefixup([]) == []\nassert op_dropshort_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ']\nassert op_dropshort_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_dropshort_prefixup(['x']) == []\nassert op_dropshort_prefixup(['abc', 'de', '']) == ['#abc']"}
{"id": "op_sorta_pos", "entry_point": "op_sorta_pos", "primitives": ["sorta", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers.", "solution": "def op_sorta_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_pos([]) == []\nassert op_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_pos([10]) == [10]\nassert op_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_sortabs", "entry_point": "op_dropwhileneg_sortabs", "primitives": ["dropwhileneg", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value.", "solution": "def op_dropwhileneg_sortabs(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropwhileneg_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_sortabs([]) == []\nassert op_dropwhileneg_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_sortabs([10]) == [10]\nassert op_dropwhileneg_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_rev_gt5", "entry_point": "op_rev_gt5", "primitives": ["rev", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five.", "solution": "def op_rev_gt5(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_rev_gt5([1, 2, 3, 4]) == []\nassert op_rev_gt5([]) == []\nassert op_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_rev_gt5([5, 5, 5]) == []\nassert op_rev_gt5([3, 1, 2]) == []\nassert op_rev_gt5([10]) == [10]\nassert op_rev_gt5([2, 4, 6]) == [6]\nassert op_rev_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_alldistinct", "entry_point": "op_dropwhileneg_alldistinct", "primitives": ["dropwhileneg", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return whether all values are distinct.", "solution": "def op_dropwhileneg_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_alldistinct([]) == True\nassert op_dropwhileneg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_alldistinct([10]) == True\nassert op_dropwhileneg_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_oremptyzero", "entry_point": "op_div3_oremptyzero", "primitives": ["div3", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero.", "solution": "def op_div3_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_div3_oremptyzero([]) == [0]\nassert op_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_oremptyzero([3, 1, 2]) == [3]\nassert op_div3_oremptyzero([10]) == [0]\nassert op_div3_oremptyzero([2, 4, 6]) == [6]\nassert op_div3_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_add10_allpos", "entry_point": "op_add10_allpos", "primitives": ["add10", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return whether all values are positive.", "solution": "def op_add10_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_allpos([1, 2, 3, 4]) == True\nassert op_add10_allpos([]) == True\nassert op_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_allpos([5, 5, 5]) == True\nassert op_add10_allpos([3, 1, 2]) == True\nassert op_add10_allpos([10]) == True\nassert op_add10_allpos([2, 4, 6]) == True\nassert op_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_beforezero_absval", "entry_point": "op_beforezero_absval", "primitives": ["beforezero", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each.", "solution": "def op_beforezero_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_absval([]) == []\nassert op_beforezero_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_absval([10]) == [10]\nassert op_beforezero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_rev_first3", "entry_point": "op_rev_first3", "primitives": ["rev", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three.", "solution": "def op_rev_first3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_rev_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3([]) == []\nassert op_rev_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3([10]) == [10]\nassert op_rev_first3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_trimends_min", "entry_point": "op_trimends_min", "primitives": ["trimends", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return the minimum (0 if empty).", "solution": "def op_trimends_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return min(r) if r else 0", "tests": "assert op_trimends_min([1, 2, 3, 4]) == 2\nassert op_trimends_min([]) == 0\nassert op_trimends_min([-2, -1, 0, 1, 2]) == -1\nassert op_trimends_min([5, 5, 5]) == 5\nassert op_trimends_min([3, 1, 2]) == 1\nassert op_trimends_min([10]) == 0\nassert op_trimends_min([2, 4, 6]) == 4\nassert op_trimends_min([-7, 12, -7]) == 12"}
{"id": "op_odds_sum", "entry_point": "op_odds_sum", "primitives": ["odds", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return their sum.", "solution": "def op_odds_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return sum(r)", "tests": "assert op_odds_sum([1, 2, 3, 4]) == 4\nassert op_odds_sum([]) == 0\nassert op_odds_sum([-2, -1, 0, 1, 2]) == 0\nassert op_odds_sum([5, 5, 5]) == 15\nassert op_odds_sum([3, 1, 2]) == 4\nassert op_odds_sum([10]) == 0\nassert op_odds_sum([2, 4, 6]) == 0\nassert op_odds_sum([-7, 12, -7]) == -14"}
{"id": "op_beforezero_counteven", "entry_point": "op_beforezero_counteven", "primitives": ["beforezero", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return how many values are even.", "solution": "def op_beforezero_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_counteven([]) == 0\nassert op_beforezero_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_counteven([5, 5, 5]) == 0\nassert op_beforezero_counteven([3, 1, 2]) == 1\nassert op_beforezero_counteven([10]) == 1\nassert op_beforezero_counteven([2, 4, 6]) == 3\nassert op_beforezero_counteven([-7, 12, -7]) == 1"}
{"id": "op_takewhilepos_allpos", "entry_point": "op_takewhilepos_allpos", "primitives": ["takewhilepos", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return whether all values are positive.", "solution": "def op_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_takewhilepos_allpos([]) == True\nassert op_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_allpos([5, 5, 5]) == True\nassert op_takewhilepos_allpos([3, 1, 2]) == True\nassert op_takewhilepos_allpos([10]) == True\nassert op_takewhilepos_allpos([2, 4, 6]) == True\nassert op_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_padto3_len", "entry_point": "op_padto3_len", "primitives": ["padto3", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return how many remain.", "solution": "def op_padto3_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_padto3_len([1, 2, 3, 4]) == 4\nassert op_padto3_len([]) == 3\nassert op_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_len([5, 5, 5]) == 3\nassert op_padto3_len([3, 1, 2]) == 3\nassert op_padto3_len([10]) == 3\nassert op_padto3_len([2, 4, 6]) == 3\nassert op_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_oremptyzero_dropfirst", "entry_point": "op_oremptyzero_dropfirst", "primitives": ["oremptyzero", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element.", "solution": "def op_oremptyzero_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_dropfirst([]) == []\nassert op_oremptyzero_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_oremptyzero_dropfirst([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_dropfirst([3, 1, 2]) == [1, 2]\nassert op_oremptyzero_dropfirst([10]) == []\nassert op_oremptyzero_dropfirst([2, 4, 6]) == [4, 6]\nassert op_oremptyzero_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_last3_max", "entry_point": "op_last3_max", "primitives": ["last3", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then return the maximum (0 if empty).", "solution": "def op_last3_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_last3_max([1, 2, 3, 4]) == 4\nassert op_last3_max([]) == 0\nassert op_last3_max([-2, -1, 0, 1, 2]) == 2\nassert op_last3_max([5, 5, 5]) == 5\nassert op_last3_max([3, 1, 2]) == 3\nassert op_last3_max([10]) == 10\nassert op_last3_max([2, 4, 6]) == 6\nassert op_last3_max([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_square", "entry_point": "op_takewhilepos_square", "primitives": ["takewhilepos", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each.", "solution": "def op_takewhilepos_square(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_takewhilepos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_square([]) == []\nassert op_takewhilepos_square([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square([5, 5, 5]) == [25, 25, 25]\nassert op_takewhilepos_square([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_square([10]) == [100]\nassert op_takewhilepos_square([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_square([-7, 12, -7]) == []"}
{"id": "op_uniq_dropfirst", "entry_point": "op_uniq_dropfirst", "primitives": ["uniq", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element.", "solution": "def op_uniq_dropfirst(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return r", "tests": "assert op_uniq_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_dropfirst([]) == []\nassert op_uniq_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_uniq_dropfirst([5, 5, 5]) == []\nassert op_uniq_dropfirst([3, 1, 2]) == [1, 2]\nassert op_uniq_dropfirst([10]) == []\nassert op_uniq_dropfirst([2, 4, 6]) == [4, 6]\nassert op_uniq_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_sorta_rev", "entry_point": "op_sorta_rev", "primitives": ["sorta", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order.", "solution": "def op_sorta_rev(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sorta_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_rev([]) == []\nassert op_sorta_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_rev([10]) == [10]\nassert op_sorta_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortlen_maxlen", "entry_point": "op_sortlen_maxlen", "primitives": ["sortlen", "maxlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then return the length of the longest string (0 if none).", "solution": "def op_sortlen_maxlen(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortlen_maxlen(['Hello', 'world']) == 5\nassert op_sortlen_maxlen([]) == 0\nassert op_sortlen_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortlen_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortlen_maxlen(['x']) == 1\nassert op_sortlen_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_double_sortd", "entry_point": "op_double_sortd", "primitives": ["double", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending.", "solution": "def op_double_sortd(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_sortd([]) == []\nassert op_double_sortd([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_double_sortd([10]) == [20]\nassert op_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_double_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_last3_odds", "entry_point": "op_last3_odds", "primitives": ["last3", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers.", "solution": "def op_last3_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_odds([1, 2, 3, 4]) == [3]\nassert op_last3_odds([]) == []\nassert op_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_last3_odds([3, 1, 2]) == [3, 1]\nassert op_last3_odds([10]) == []\nassert op_last3_odds([2, 4, 6]) == []\nassert op_last3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sorta_double", "entry_point": "op_sorta_double", "primitives": ["sorta", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each.", "solution": "def op_sorta_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sorta_double([]) == []\nassert op_sorta_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_sorta_double([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_double([3, 1, 2]) == [2, 4, 6]\nassert op_sorta_double([10]) == [20]\nassert op_sorta_double([2, 4, 6]) == [4, 8, 12]\nassert op_sorta_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_add10_dropfirst", "entry_point": "op_add10_dropfirst", "primitives": ["add10", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element.", "solution": "def op_add10_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_add10_dropfirst([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropfirst([]) == []\nassert op_add10_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_dropfirst([5, 5, 5]) == [15, 15]\nassert op_add10_dropfirst([3, 1, 2]) == [11, 12]\nassert op_add10_dropfirst([10]) == []\nassert op_add10_dropfirst([2, 4, 6]) == [14, 16]\nassert op_add10_dropfirst([-7, 12, -7]) == [22, 3]"}
{"id": "op_trimends_uniq", "entry_point": "op_trimends_uniq", "primitives": ["trimends", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_trimends_uniq(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_trimends_uniq([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_uniq([]) == []\nassert op_trimends_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_uniq([5, 5, 5]) == [5]\nassert op_trimends_uniq([3, 1, 2]) == [1]\nassert op_trimends_uniq([10]) == []\nassert op_trimends_uniq([2, 4, 6]) == [4]\nassert op_trimends_uniq([-7, 12, -7]) == [12]"}
{"id": "op_first3_allpos", "entry_point": "op_first3_allpos", "primitives": ["first3", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return whether all values are positive.", "solution": "def op_first3_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_first3_allpos([1, 2, 3, 4]) == True\nassert op_first3_allpos([]) == True\nassert op_first3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_first3_allpos([5, 5, 5]) == True\nassert op_first3_allpos([3, 1, 2]) == True\nassert op_first3_allpos([10]) == True\nassert op_first3_allpos([2, 4, 6]) == True\nassert op_first3_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_sortabs", "entry_point": "op_div3_sortabs", "primitives": ["div3", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value.", "solution": "def op_div3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_sortabs([1, 2, 3, 4]) == [3]\nassert op_div3_sortabs([]) == []\nassert op_div3_sortabs([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_sortabs([5, 5, 5]) == []\nassert op_div3_sortabs([3, 1, 2]) == [3]\nassert op_div3_sortabs([10]) == []\nassert op_div3_sortabs([2, 4, 6]) == [6]\nassert op_div3_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_sorta", "entry_point": "op_beforezero_sorta", "primitives": ["beforezero", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending.", "solution": "def op_beforezero_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sorta([]) == []\nassert op_beforezero_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sorta([10]) == [10]\nassert op_beforezero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_evens_sum", "entry_point": "op_evens_sum", "primitives": ["evens", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return their sum.", "solution": "def op_evens_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_evens_sum([1, 2, 3, 4]) == 6\nassert op_evens_sum([]) == 0\nassert op_evens_sum([-2, -1, 0, 1, 2]) == 0\nassert op_evens_sum([5, 5, 5]) == 0\nassert op_evens_sum([3, 1, 2]) == 2\nassert op_evens_sum([10]) == 10\nassert op_evens_sum([2, 4, 6]) == 12\nassert op_evens_sum([-7, 12, -7]) == 12"}
{"id": "op_ages_haszero", "entry_point": "op_ages_haszero", "primitives": ["ages", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return whether the list contains a zero.", "solution": "def op_ages_haszero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return 0 in r", "tests": "assert op_ages_haszero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_haszero([]) == False\nassert op_ages_haszero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_haszero([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_ages_evens", "entry_point": "op_ages_evens", "primitives": ["ages", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers.", "solution": "def op_ages_evens(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_ages_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_evens([]) == []\nassert op_ages_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_padto3_issorted", "entry_point": "op_padto3_issorted", "primitives": ["padto3", "issorted"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_padto3_issorted(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_padto3_issorted([1, 2, 3, 4]) == True\nassert op_padto3_issorted([]) == True\nassert op_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_padto3_issorted([5, 5, 5]) == True\nassert op_padto3_issorted([3, 1, 2]) == False\nassert op_padto3_issorted([10]) == False\nassert op_padto3_issorted([2, 4, 6]) == True\nassert op_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_rev_square", "entry_point": "op_rev_square", "primitives": ["rev", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each.", "solution": "def op_rev_square(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_rev_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_square([]) == []\nassert op_rev_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_rev_square([5, 5, 5]) == [25, 25, 25]\nassert op_rev_square([3, 1, 2]) == [4, 1, 9]\nassert op_rev_square([10]) == [100]\nassert op_rev_square([2, 4, 6]) == [36, 16, 4]\nassert op_rev_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_double_first3", "entry_point": "op_double_first3", "primitives": ["double", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three.", "solution": "def op_double_first3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_double_first3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_first3([]) == []\nassert op_double_first3([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_double_first3([5, 5, 5]) == [10, 10, 10]\nassert op_double_first3([3, 1, 2]) == [6, 2, 4]\nassert op_double_first3([10]) == [20]\nassert op_double_first3([2, 4, 6]) == [4, 8, 12]\nassert op_double_first3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_neg_dropfirst", "entry_point": "op_neg_dropfirst", "primitives": ["neg", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element.", "solution": "def op_neg_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_dropfirst([]) == []\nassert op_neg_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_dropfirst([5, 5, 5]) == []\nassert op_neg_dropfirst([3, 1, 2]) == []\nassert op_neg_dropfirst([10]) == []\nassert op_neg_dropfirst([2, 4, 6]) == []\nassert op_neg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_double_min", "entry_point": "op_double_min", "primitives": ["double", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then return the minimum (0 if empty).", "solution": "def op_double_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_double_min([1, 2, 3, 4]) == 2\nassert op_double_min([]) == 0\nassert op_double_min([-2, -1, 0, 1, 2]) == -4\nassert op_double_min([5, 5, 5]) == 10\nassert op_double_min([3, 1, 2]) == 2\nassert op_double_min([10]) == 20\nassert op_double_min([2, 4, 6]) == 4\nassert op_double_min([-7, 12, -7]) == -14"}
{"id": "op_dropwhileneg_first3", "entry_point": "op_dropwhileneg_first3", "primitives": ["dropwhileneg", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three.", "solution": "def op_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_dropwhileneg_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropwhileneg_first3([]) == []\nassert op_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_first3([10]) == [10]\nassert op_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_negate_sortabs", "entry_point": "op_negate_sortabs", "primitives": ["negate", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort by absolute value.", "solution": "def op_negate_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_sortabs([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_sortabs([]) == []\nassert op_negate_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_negate_sortabs([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sortabs([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sortabs([10]) == [-10]\nassert op_negate_sortabs([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sortabs([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_dec_firsteven", "entry_point": "op_dec_firsteven", "primitives": ["dec", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return the first even value (0 if none).", "solution": "def op_dec_firsteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dec_firsteven([1, 2, 3, 4]) == 0\nassert op_dec_firsteven([]) == 0\nassert op_dec_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dec_firsteven([5, 5, 5]) == 4\nassert op_dec_firsteven([3, 1, 2]) == 2\nassert op_dec_firsteven([10]) == 0\nassert op_dec_firsteven([2, 4, 6]) == 0\nassert op_dec_firsteven([-7, 12, -7]) == -8"}
{"id": "op_prefixup_longest", "entry_point": "op_prefixup_longest", "primitives": ["prefixup", "longest"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then return the longest string (empty if none).", "solution": "def op_prefixup_longest(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_prefixup_longest(['Hello', 'world']) == '#Hello'\nassert op_prefixup_longest([]) == ''\nassert op_prefixup_longest(['  a ', '', 'BC', 'bc']) == '#  a '\nassert op_prefixup_longest(['one', 'one', 'Two']) == '#one'\nassert op_prefixup_longest(['x']) == '#x'\nassert op_prefixup_longest(['abc', 'de', '']) == '#abc'"}
{"id": "op_dropfirst_min", "entry_point": "op_dropfirst_min", "primitives": ["dropfirst", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return the minimum (0 if empty).", "solution": "def op_dropfirst_min(xs):\n    r = list(xs)\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_dropfirst_min([1, 2, 3, 4]) == 2\nassert op_dropfirst_min([]) == 0\nassert op_dropfirst_min([-2, -1, 0, 1, 2]) == -1\nassert op_dropfirst_min([5, 5, 5]) == 5\nassert op_dropfirst_min([3, 1, 2]) == 1\nassert op_dropfirst_min([10]) == 0\nassert op_dropfirst_min([2, 4, 6]) == 4\nassert op_dropfirst_min([-7, 12, -7]) == -7"}
{"id": "op_odds_prod", "entry_point": "op_odds_prod", "primitives": ["odds", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return their product.", "solution": "def op_odds_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return __import__('math').prod(r)", "tests": "assert op_odds_prod([1, 2, 3, 4]) == 3\nassert op_odds_prod([]) == 1\nassert op_odds_prod([-2, -1, 0, 1, 2]) == -1\nassert op_odds_prod([5, 5, 5]) == 125\nassert op_odds_prod([3, 1, 2]) == 3\nassert op_odds_prod([10]) == 1\nassert op_odds_prod([2, 4, 6]) == 1\nassert op_odds_prod([-7, 12, -7]) == 49"}
{"id": "op_last3_negate", "entry_point": "op_last3_negate", "primitives": ["last3", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each.", "solution": "def op_last3_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_negate([]) == []\nassert op_last3_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_last3_negate([10]) == [-10]\nassert op_last3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_add10_haszero", "entry_point": "op_add10_haszero", "primitives": ["add10", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return whether the list contains a zero.", "solution": "def op_add10_haszero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return 0 in r", "tests": "assert op_add10_haszero([1, 2, 3, 4]) == False\nassert op_add10_haszero([]) == False\nassert op_add10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_add10_haszero([5, 5, 5]) == False\nassert op_add10_haszero([3, 1, 2]) == False\nassert op_add10_haszero([10]) == False\nassert op_add10_haszero([2, 4, 6]) == False\nassert op_add10_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_prod", "entry_point": "op_dropwhileneg_prod", "primitives": ["dropwhileneg", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return their product.", "solution": "def op_dropwhileneg_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_prod([1, 2, 3, 4]) == 24\nassert op_dropwhileneg_prod([]) == 1\nassert op_dropwhileneg_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_prod([5, 5, 5]) == 125\nassert op_dropwhileneg_prod([3, 1, 2]) == 6\nassert op_dropwhileneg_prod([10]) == 10\nassert op_dropwhileneg_prod([2, 4, 6]) == 48\nassert op_dropwhileneg_prod([-7, 12, -7]) == -84"}
{"id": "op_sortalpha_sortlen", "entry_point": "op_sortalpha_sortlen", "primitives": ["sortalpha", "sortlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then sort by length, shortest first.", "solution": "def op_sortalpha_sortlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_sortalpha_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_sortlen([]) == []\nassert op_sortalpha_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_sortalpha_sortlen(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_sortlen(['x']) == ['x']\nassert op_sortalpha_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_dropshort_sortlen", "entry_point": "op_dropshort_sortlen", "primitives": ["dropshort", "sortlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then sort by length, shortest first.", "solution": "def op_dropshort_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_dropshort_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_dropshort_sortlen([]) == []\nassert op_dropshort_sortlen(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_dropshort_sortlen(['x']) == []\nassert op_dropshort_sortlen(['abc', 'de', '']) == ['abc']"}
{"id": "op_upper_joinc", "entry_point": "op_upper_joinc", "primitives": ["upper", "joinc"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then join them with commas.", "solution": "def op_upper_joinc(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return ','.join(r)", "tests": "assert op_upper_joinc(['Hello', 'world']) == 'HELLO,WORLD'\nassert op_upper_joinc([]) == ''\nassert op_upper_joinc(['  a ', '', 'BC', 'bc']) == '  A ,,BC,BC'\nassert op_upper_joinc(['one', 'one', 'Two']) == 'ONE,ONE,TWO'\nassert op_upper_joinc(['x']) == 'X'\nassert op_upper_joinc(['abc', 'de', '']) == 'ABC,DE,'"}
{"id": "op_lower_sortalpha", "entry_point": "op_lower_sortalpha", "primitives": ["lower", "sortalpha"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort alphabetically.", "solution": "def op_lower_sortalpha(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_lower_sortalpha(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortalpha([]) == []\nassert op_lower_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc', 'bc']\nassert op_lower_sortalpha(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_sortalpha(['x']) == ['x']\nassert op_lower_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_gt5_add10", "entry_point": "op_gt5_add10", "primitives": ["gt5", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each.", "solution": "def op_gt5_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_gt5_add10([1, 2, 3, 4]) == []\nassert op_gt5_add10([]) == []\nassert op_gt5_add10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10([5, 5, 5]) == []\nassert op_gt5_add10([3, 1, 2]) == []\nassert op_gt5_add10([10]) == [20]\nassert op_gt5_add10([2, 4, 6]) == [16]\nassert op_gt5_add10([-7, 12, -7]) == [22]"}
{"id": "op_add10_evens", "entry_point": "op_add10_evens", "primitives": ["add10", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the even numbers.", "solution": "def op_add10_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_evens([]) == []\nassert op_add10_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_evens([5, 5, 5]) == []\nassert op_add10_evens([3, 1, 2]) == [12]\nassert op_add10_evens([10]) == [20]\nassert op_add10_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_evens([-7, 12, -7]) == [22]"}
{"id": "op_square_neg", "entry_point": "op_square_neg", "primitives": ["square", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the negative numbers.", "solution": "def op_square_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_neg([1, 2, 3, 4]) == []\nassert op_square_neg([]) == []\nassert op_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_neg([5, 5, 5]) == []\nassert op_square_neg([3, 1, 2]) == []\nassert op_square_neg([10]) == []\nassert op_square_neg([2, 4, 6]) == []\nassert op_square_neg([-7, 12, -7]) == []"}
{"id": "op_square_last3", "entry_point": "op_square_last3", "primitives": ["square", "last3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three.", "solution": "def op_square_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_square_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_last3([]) == []\nassert op_square_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_square_last3([5, 5, 5]) == [25, 25, 25]\nassert op_square_last3([3, 1, 2]) == [9, 1, 4]\nassert op_square_last3([10]) == [100]\nassert op_square_last3([2, 4, 6]) == [4, 16, 36]\nassert op_square_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sortabs_gt5", "entry_point": "op_sortabs_gt5", "primitives": ["sortabs", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five.", "solution": "def op_sortabs_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_gt5([]) == []\nassert op_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_gt5([5, 5, 5]) == []\nassert op_sortabs_gt5([3, 1, 2]) == []\nassert op_sortabs_gt5([10]) == [10]\nassert op_sortabs_gt5([2, 4, 6]) == [6]\nassert op_sortabs_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_sortd", "entry_point": "op_dropfirst_sortd", "primitives": ["dropfirst", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending.", "solution": "def op_dropfirst_sortd(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropfirst_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_sortd([]) == []\nassert op_dropfirst_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_sortd([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortd([3, 1, 2]) == [2, 1]\nassert op_dropfirst_sortd([10]) == []\nassert op_dropfirst_sortd([2, 4, 6]) == [6, 4]\nassert op_dropfirst_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_clamp10_anyeven", "entry_point": "op_clamp10_anyeven", "primitives": ["clamp10", "anyeven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then return whether any value is even.", "solution": "def op_clamp10_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_anyeven([]) == False\nassert op_clamp10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_anyeven([5, 5, 5]) == False\nassert op_clamp10_anyeven([3, 1, 2]) == True\nassert op_clamp10_anyeven([10]) == True\nassert op_clamp10_anyeven([2, 4, 6]) == True\nassert op_clamp10_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortabs_evens", "entry_point": "op_sortabs_evens", "primitives": ["sortabs", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers.", "solution": "def op_sortabs_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_evens([]) == []\nassert op_sortabs_evens([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_evens([5, 5, 5]) == []\nassert op_sortabs_evens([3, 1, 2]) == [2]\nassert op_sortabs_evens([10]) == [10]\nassert op_sortabs_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_evens([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_dec", "entry_point": "op_beforezero_dec", "primitives": ["beforezero", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each.", "solution": "def op_beforezero_dec(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_beforezero_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_beforezero_dec([]) == []\nassert op_beforezero_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_beforezero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dec([3, 1, 2]) == [2, 0, 1]\nassert op_beforezero_dec([10]) == [9]\nassert op_beforezero_dec([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_neg_add10", "entry_point": "op_neg_add10", "primitives": ["neg", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each.", "solution": "def op_neg_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_add10([1, 2, 3, 4]) == []\nassert op_neg_add10([]) == []\nassert op_neg_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_neg_add10([5, 5, 5]) == []\nassert op_neg_add10([3, 1, 2]) == []\nassert op_neg_add10([10]) == []\nassert op_neg_add10([2, 4, 6]) == []\nassert op_neg_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_takewhilepos_inc", "entry_point": "op_takewhilepos_inc", "primitives": ["takewhilepos", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each.", "solution": "def op_takewhilepos_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_takewhilepos_inc([]) == []\nassert op_takewhilepos_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_inc([3, 1, 2]) == [4, 2, 3]\nassert op_takewhilepos_inc([10]) == [11]\nassert op_takewhilepos_inc([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_inc([-7, 12, -7]) == []"}
{"id": "op_absval_dec", "entry_point": "op_absval_dec", "primitives": ["absval", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each.", "solution": "def op_absval_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_absval_dec([]) == []\nassert op_absval_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, 0, 1]\nassert op_absval_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_dec([3, 1, 2]) == [2, 0, 1]\nassert op_absval_dec([10]) == [9]\nassert op_absval_dec([2, 4, 6]) == [1, 3, 5]\nassert op_absval_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_dropfirst_oremptyzero", "entry_point": "op_dropfirst_oremptyzero", "primitives": ["dropfirst", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero.", "solution": "def op_dropfirst_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_oremptyzero([]) == [0]\nassert op_dropfirst_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_oremptyzero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_oremptyzero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_oremptyzero([10]) == [0]\nassert op_dropfirst_oremptyzero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_oremptyzero([-7, 12, -7]) == [12, -7]"}
{"id": "op_pos_min", "entry_point": "op_pos_min", "primitives": ["pos", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return the minimum (0 if empty).", "solution": "def op_pos_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return min(r) if r else 0", "tests": "assert op_pos_min([1, 2, 3, 4]) == 1\nassert op_pos_min([]) == 0\nassert op_pos_min([-2, -1, 0, 1, 2]) == 1\nassert op_pos_min([5, 5, 5]) == 5\nassert op_pos_min([3, 1, 2]) == 1\nassert op_pos_min([10]) == 10\nassert op_pos_min([2, 4, 6]) == 2\nassert op_pos_min([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_sortd", "entry_point": "op_oremptyzero_sortd", "primitives": ["oremptyzero", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending.", "solution": "def op_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_oremptyzero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_oremptyzero_sortd([]) == [0]\nassert op_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_oremptyzero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_oremptyzero_sortd([10]) == [10]\nassert op_oremptyzero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_oremptyzero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_haszero", "entry_point": "op_gt5_haszero", "primitives": ["gt5", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return whether the list contains a zero.", "solution": "def op_gt5_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_gt5_haszero([1, 2, 3, 4]) == False\nassert op_gt5_haszero([]) == False\nassert op_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_haszero([5, 5, 5]) == False\nassert op_gt5_haszero([3, 1, 2]) == False\nassert op_gt5_haszero([10]) == False\nassert op_gt5_haszero([2, 4, 6]) == False\nassert op_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_anyeven", "entry_point": "op_dropwhileneg_anyeven", "primitives": ["dropwhileneg", "anyeven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return whether any value is even.", "solution": "def op_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_anyeven([]) == False\nassert op_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_anyeven([10]) == True\nassert op_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropfirst_evens", "entry_point": "op_dropfirst_evens", "primitives": ["dropfirst", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers.", "solution": "def op_dropfirst_evens(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropfirst_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropfirst_evens([]) == []\nassert op_dropfirst_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropfirst_evens([5, 5, 5]) == []\nassert op_dropfirst_evens([3, 1, 2]) == [2]\nassert op_dropfirst_evens([10]) == []\nassert op_dropfirst_evens([2, 4, 6]) == [4, 6]\nassert op_dropfirst_evens([-7, 12, -7]) == [12]"}
{"id": "op_inc_add10", "entry_point": "op_inc_add10", "primitives": ["inc", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each.", "solution": "def op_inc_add10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_inc_add10([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_add10([]) == []\nassert op_inc_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_add10([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10([3, 1, 2]) == [14, 12, 13]\nassert op_inc_add10([10]) == [21]\nassert op_inc_add10([2, 4, 6]) == [13, 15, 17]\nassert op_inc_add10([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_div3_trimends", "entry_point": "op_div3_trimends", "primitives": ["div3", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements.", "solution": "def op_div3_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_trimends([1, 2, 3, 4]) == []\nassert op_div3_trimends([]) == []\nassert op_div3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends([5, 5, 5]) == []\nassert op_div3_trimends([3, 1, 2]) == []\nassert op_div3_trimends([10]) == []\nassert op_div3_trimends([2, 4, 6]) == []\nassert op_div3_trimends([-7, 12, -7]) == []"}
{"id": "op_nonempty_maxlen", "entry_point": "op_nonempty_maxlen", "primitives": ["nonempty", "maxlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then return the length of the longest string (0 if none).", "solution": "def op_nonempty_maxlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_nonempty_maxlen(['Hello', 'world']) == 5\nassert op_nonempty_maxlen([]) == 0\nassert op_nonempty_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_nonempty_maxlen(['one', 'one', 'Two']) == 3\nassert op_nonempty_maxlen(['x']) == 1\nassert op_nonempty_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_first3_anyeven", "entry_point": "op_first3_anyeven", "primitives": ["first3", "anyeven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return whether any value is even.", "solution": "def op_first3_anyeven(xs):\n    r = list(xs)\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_first3_anyeven([1, 2, 3, 4]) == True\nassert op_first3_anyeven([]) == False\nassert op_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_first3_anyeven([5, 5, 5]) == False\nassert op_first3_anyeven([3, 1, 2]) == True\nassert op_first3_anyeven([10]) == True\nassert op_first3_anyeven([2, 4, 6]) == True\nassert op_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_ages_len", "entry_point": "op_ages_len", "primitives": ["ages", "len"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return how many remain.", "solution": "def op_ages_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return len(r)", "tests": "assert op_ages_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_len([]) == 0\nassert op_ages_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_negate_clamp10", "entry_point": "op_negate_clamp10", "primitives": ["negate", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10.", "solution": "def op_negate_clamp10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_negate_clamp10([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_clamp10([]) == []\nassert op_negate_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_clamp10([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_clamp10([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_clamp10([10]) == [-10]\nassert op_negate_clamp10([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_clamp10([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_uniq_anyeven", "entry_point": "op_uniq_anyeven", "primitives": ["uniq", "anyeven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_uniq_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_anyeven([]) == False\nassert op_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_anyeven([5, 5, 5]) == False\nassert op_uniq_anyeven([3, 1, 2]) == True\nassert op_uniq_anyeven([10]) == True\nassert op_uniq_anyeven([2, 4, 6]) == True\nassert op_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_pos_square", "entry_point": "op_pos_square", "primitives": ["pos", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each.", "solution": "def op_pos_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_square([]) == []\nassert op_pos_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_square([5, 5, 5]) == [25, 25, 25]\nassert op_pos_square([3, 1, 2]) == [9, 1, 4]\nassert op_pos_square([10]) == [100]\nassert op_pos_square([2, 4, 6]) == [4, 16, 36]\nassert op_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_odds_allpos", "entry_point": "op_odds_allpos", "primitives": ["odds", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return whether all values are positive.", "solution": "def op_odds_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_odds_allpos([1, 2, 3, 4]) == True\nassert op_odds_allpos([]) == True\nassert op_odds_allpos([-2, -1, 0, 1, 2]) == False\nassert op_odds_allpos([5, 5, 5]) == True\nassert op_odds_allpos([3, 1, 2]) == True\nassert op_odds_allpos([10]) == True\nassert op_odds_allpos([2, 4, 6]) == True\nassert op_odds_allpos([-7, 12, -7]) == False"}
{"id": "op_lower_prefixup", "entry_point": "op_lower_prefixup", "primitives": ["lower", "prefixup"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then prefix each with a hash.", "solution": "def op_lower_prefixup(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_lower_prefixup(['Hello', 'world']) == ['#hello', '#world']\nassert op_lower_prefixup([]) == []\nassert op_lower_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ', '#', '#bc', '#bc']\nassert op_lower_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#two']\nassert op_lower_prefixup(['x']) == ['#x']\nassert op_lower_prefixup(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_double_padto3", "entry_point": "op_double_padto3", "primitives": ["double", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements.", "solution": "def op_double_padto3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_double_padto3([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_padto3([]) == [0, 0, 0]\nassert op_double_padto3([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_padto3([5, 5, 5]) == [10, 10, 10]\nassert op_double_padto3([3, 1, 2]) == [6, 2, 4]\nassert op_double_padto3([10]) == [20, 0, 0]\nassert op_double_padto3([2, 4, 6]) == [4, 8, 12]\nassert op_double_padto3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_sortlen_prefixup", "entry_point": "op_sortlen_prefixup", "primitives": ["sortlen", "prefixup"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then prefix each with a hash.", "solution": "def op_sortlen_prefixup(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_sortlen_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortlen_prefixup([]) == []\nassert op_sortlen_prefixup(['  a ', '', 'BC', 'bc']) == ['#', '#BC', '#bc', '#  a ']\nassert op_sortlen_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_sortlen_prefixup(['x']) == ['#x']\nassert op_sortlen_prefixup(['abc', 'de', '']) == ['#', '#de', '#abc']"}
{"id": "op_lower_dropshort", "entry_point": "op_lower_dropshort", "primitives": ["lower", "dropshort"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop strings shorter than three characters.", "solution": "def op_lower_dropshort(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_lower_dropshort(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_dropshort([]) == []\nassert op_lower_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_lower_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_dropshort(['x']) == []\nassert op_lower_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_lower_nonempty", "entry_point": "op_lower_nonempty", "primitives": ["lower", "nonempty"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop empty strings.", "solution": "def op_lower_nonempty(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_lower_nonempty(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_nonempty([]) == []\nassert op_lower_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ', 'bc', 'bc']\nassert op_lower_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_nonempty(['x']) == ['x']\nassert op_lower_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_prefixup_firstchar", "entry_point": "op_prefixup_firstchar", "primitives": ["prefixup", "firstchar"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then keep the first character of each (dropping empties).", "solution": "def op_prefixup_firstchar(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_prefixup_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_prefixup_firstchar([]) == []\nassert op_prefixup_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_prefixup_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_prefixup_firstchar(['x']) == ['#']\nassert op_prefixup_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_dec_beforezero", "entry_point": "op_dec_beforezero", "primitives": ["dec", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero.", "solution": "def op_dec_beforezero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dec_beforezero([1, 2, 3, 4]) == []\nassert op_dec_beforezero([]) == []\nassert op_dec_beforezero([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_beforezero([5, 5, 5]) == [4, 4, 4]\nassert op_dec_beforezero([3, 1, 2]) == [2]\nassert op_dec_beforezero([10]) == [9]\nassert op_dec_beforezero([2, 4, 6]) == [1, 3, 5]\nassert op_dec_beforezero([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dec_neg", "entry_point": "op_dec_neg", "primitives": ["dec", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers.", "solution": "def op_dec_neg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dec_neg([1, 2, 3, 4]) == []\nassert op_dec_neg([]) == []\nassert op_dec_neg([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_neg([5, 5, 5]) == []\nassert op_dec_neg([3, 1, 2]) == []\nassert op_dec_neg([10]) == []\nassert op_dec_neg([2, 4, 6]) == []\nassert op_dec_neg([-7, 12, -7]) == [-8, -8]"}
{"id": "op_evens_min", "entry_point": "op_evens_min", "primitives": ["evens", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_evens_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_evens_min([1, 2, 3, 4]) == 2\nassert op_evens_min([]) == 0\nassert op_evens_min([-2, -1, 0, 1, 2]) == -2\nassert op_evens_min([5, 5, 5]) == 0\nassert op_evens_min([3, 1, 2]) == 2\nassert op_evens_min([10]) == 10\nassert op_evens_min([2, 4, 6]) == 2\nassert op_evens_min([-7, 12, -7]) == 12"}
{"id": "op_names_lens", "entry_point": "op_names_lens", "primitives": ["names", "lens"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then return the total number of characters.", "solution": "def op_names_lens(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return sum(len(s) for s in r)", "tests": "assert op_names_lens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 5\nassert op_names_lens([]) == 0\nassert op_names_lens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 7\nassert op_names_lens([{'name': 'Fi', 'age': 41}]) == 2"}
{"id": "op_uniqs_maxlen", "entry_point": "op_uniqs_maxlen", "primitives": ["uniqs", "maxlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then return the length of the longest string (0 if none).", "solution": "def op_uniqs_maxlen(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return max((len(s) for s in r), default=0)", "tests": "assert op_uniqs_maxlen(['Hello', 'world']) == 5\nassert op_uniqs_maxlen([]) == 0\nassert op_uniqs_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_uniqs_maxlen(['one', 'one', 'Two']) == 3\nassert op_uniqs_maxlen(['x']) == 1\nassert op_uniqs_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_rev_add10", "entry_point": "op_rev_add10", "primitives": ["rev", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each.", "solution": "def op_rev_add10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_rev_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_rev_add10([]) == []\nassert op_rev_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_rev_add10([5, 5, 5]) == [15, 15, 15]\nassert op_rev_add10([3, 1, 2]) == [12, 11, 13]\nassert op_rev_add10([10]) == [20]\nassert op_rev_add10([2, 4, 6]) == [16, 14, 12]\nassert op_rev_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_absval_square", "entry_point": "op_absval_square", "primitives": ["absval", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each.", "solution": "def op_absval_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_absval_square([]) == []\nassert op_absval_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_absval_square([5, 5, 5]) == [25, 25, 25]\nassert op_absval_square([3, 1, 2]) == [9, 1, 4]\nassert op_absval_square([10]) == [100]\nassert op_absval_square([2, 4, 6]) == [4, 16, 36]\nassert op_absval_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_takewhilepos_alldistinct", "entry_point": "op_takewhilepos_alldistinct", "primitives": ["takewhilepos", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return whether all values are distinct.", "solution": "def op_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_takewhilepos_alldistinct([]) == True\nassert op_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_takewhilepos_alldistinct([10]) == True\nassert op_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_uniqs_counts", "entry_point": "op_uniqs_counts", "primitives": ["uniqs", "counts"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then return how many strings remain.", "solution": "def op_uniqs_counts(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_uniqs_counts(['Hello', 'world']) == 2\nassert op_uniqs_counts([]) == 0\nassert op_uniqs_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_uniqs_counts(['one', 'one', 'Two']) == 2\nassert op_uniqs_counts(['x']) == 1\nassert op_uniqs_counts(['abc', 'de', '']) == 3"}
{"id": "op_last3_dropzeros", "entry_point": "op_last3_dropzeros", "primitives": ["last3", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros.", "solution": "def op_last3_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_dropzeros([]) == []\nassert op_last3_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_last3_dropzeros([10]) == [10]\nassert op_last3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_last3_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_trimends_haszero", "entry_point": "op_trimends_haszero", "primitives": ["trimends", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return whether the list contains a zero.", "solution": "def op_trimends_haszero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return 0 in r", "tests": "assert op_trimends_haszero([1, 2, 3, 4]) == False\nassert op_trimends_haszero([]) == False\nassert op_trimends_haszero([-2, -1, 0, 1, 2]) == True\nassert op_trimends_haszero([5, 5, 5]) == False\nassert op_trimends_haszero([3, 1, 2]) == False\nassert op_trimends_haszero([10]) == False\nassert op_trimends_haszero([2, 4, 6]) == False\nassert op_trimends_haszero([-7, 12, -7]) == False"}
{"id": "op_dropshort_joinc", "entry_point": "op_dropshort_joinc", "primitives": ["dropshort", "joinc"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then join them with commas.", "solution": "def op_dropshort_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return ','.join(r)", "tests": "assert op_dropshort_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_dropshort_joinc([]) == ''\nassert op_dropshort_joinc(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_dropshort_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_dropshort_joinc(['x']) == ''\nassert op_dropshort_joinc(['abc', 'de', '']) == 'abc'"}
{"id": "op_dropwhileneg_takewhilepos", "entry_point": "op_dropwhileneg_takewhilepos", "primitives": ["dropwhileneg", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive.", "solution": "def op_dropwhileneg_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_takewhilepos([]) == []\nassert op_dropwhileneg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_takewhilepos([10]) == [10]\nassert op_dropwhileneg_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_sortlen_dropshort", "entry_point": "op_sortlen_dropshort", "primitives": ["sortlen", "dropshort"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop strings shorter than three characters.", "solution": "def op_sortlen_dropshort(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_sortlen_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_dropshort([]) == []\nassert op_sortlen_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_sortlen_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_sortlen_dropshort(['x']) == []\nassert op_sortlen_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_clamp10_double", "entry_point": "op_clamp10_double", "primitives": ["clamp10", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each.", "solution": "def op_clamp10_double(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_clamp10_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_clamp10_double([]) == []\nassert op_clamp10_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_clamp10_double([5, 5, 5]) == [10, 10, 10]\nassert op_clamp10_double([3, 1, 2]) == [6, 2, 4]\nassert op_clamp10_double([10]) == [20]\nassert op_clamp10_double([2, 4, 6]) == [4, 8, 12]\nassert op_clamp10_double([-7, 12, -7]) == [-14, 20, -14]"}
{"id": "op_uniq_sorta", "entry_point": "op_uniq_sorta", "primitives": ["uniq", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending.", "solution": "def op_uniq_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sorta([]) == []\nassert op_uniq_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_sorta([5, 5, 5]) == [5]\nassert op_uniq_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sorta([10]) == [10]\nassert op_uniq_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_rev_sortabs", "entry_point": "op_rev_sortabs", "primitives": ["rev", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value.", "solution": "def op_rev_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_sortabs([]) == []\nassert op_rev_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_rev_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sortabs([10]) == [10]\nassert op_rev_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_double", "entry_point": "op_pos_double", "primitives": ["pos", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each.", "solution": "def op_pos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_double([]) == []\nassert op_pos_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double([3, 1, 2]) == [6, 2, 4]\nassert op_pos_double([10]) == [20]\nassert op_pos_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_double([-7, 12, -7]) == [24]"}
{"id": "op_pos_dec", "entry_point": "op_pos_dec", "primitives": ["pos", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each.", "solution": "def op_pos_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_pos_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_pos_dec([]) == []\nassert op_pos_dec([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_dec([5, 5, 5]) == [4, 4, 4]\nassert op_pos_dec([3, 1, 2]) == [2, 0, 1]\nassert op_pos_dec([10]) == [9]\nassert op_pos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_pos_dec([-7, 12, -7]) == [11]"}
{"id": "op_evens_firsteven", "entry_point": "op_evens_firsteven", "primitives": ["evens", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return the first even value (0 if none).", "solution": "def op_evens_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_evens_firsteven([1, 2, 3, 4]) == 2\nassert op_evens_firsteven([]) == 0\nassert op_evens_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_evens_firsteven([5, 5, 5]) == 0\nassert op_evens_firsteven([3, 1, 2]) == 2\nassert op_evens_firsteven([10]) == 10\nassert op_evens_firsteven([2, 4, 6]) == 2\nassert op_evens_firsteven([-7, 12, -7]) == 12"}
{"id": "op_first3_rev", "entry_point": "op_first3_rev", "primitives": ["first3", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order.", "solution": "def op_first3_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_rev([]) == []\nassert op_first3_rev([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_first3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_first3_rev([10]) == [10]\nassert op_first3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_first3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dec_alldistinct", "entry_point": "op_dec_alldistinct", "primitives": ["dec", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return whether all values are distinct.", "solution": "def op_dec_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dec_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_alldistinct([]) == True\nassert op_dec_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_alldistinct([5, 5, 5]) == False\nassert op_dec_alldistinct([3, 1, 2]) == True\nassert op_dec_alldistinct([10]) == True\nassert op_dec_alldistinct([2, 4, 6]) == True\nassert op_dec_alldistinct([-7, 12, -7]) == False"}
{"id": "op_square_issorted", "entry_point": "op_square_issorted", "primitives": ["square", "issorted"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then return whether the list is sorted ascending.", "solution": "def op_square_issorted(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_square_issorted([1, 2, 3, 4]) == True\nassert op_square_issorted([]) == True\nassert op_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_square_issorted([5, 5, 5]) == True\nassert op_square_issorted([3, 1, 2]) == False\nassert op_square_issorted([10]) == True\nassert op_square_issorted([2, 4, 6]) == True\nassert op_square_issorted([-7, 12, -7]) == False"}
{"id": "op_strip_lower", "entry_point": "op_strip_lower", "primitives": ["strip", "lower"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then lowercase each string.", "solution": "def op_strip_lower(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_strip_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_strip_lower([]) == []\nassert op_strip_lower(['  a ', '', 'BC', 'bc']) == ['a', '', 'bc', 'bc']\nassert op_strip_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_strip_lower(['x']) == ['x']\nassert op_strip_lower(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_takewhilepos_odds", "entry_point": "op_takewhilepos_odds", "primitives": ["takewhilepos", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers.", "solution": "def op_takewhilepos_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_takewhilepos_odds([]) == []\nassert op_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_odds([3, 1, 2]) == [3, 1]\nassert op_takewhilepos_odds([10]) == []\nassert op_takewhilepos_odds([2, 4, 6]) == []\nassert op_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_inc_allpos", "entry_point": "op_inc_allpos", "primitives": ["inc", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then return whether all values are positive.", "solution": "def op_inc_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_allpos([1, 2, 3, 4]) == True\nassert op_inc_allpos([]) == True\nassert op_inc_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_allpos([5, 5, 5]) == True\nassert op_inc_allpos([3, 1, 2]) == True\nassert op_inc_allpos([10]) == True\nassert op_inc_allpos([2, 4, 6]) == True\nassert op_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_uniq_square", "entry_point": "op_uniq_square", "primitives": ["uniq", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each.", "solution": "def op_uniq_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_square([]) == []\nassert op_uniq_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_uniq_square([5, 5, 5]) == [25]\nassert op_uniq_square([3, 1, 2]) == [9, 1, 4]\nassert op_uniq_square([10]) == [100]\nassert op_uniq_square([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_square([-7, 12, -7]) == [49, 144]"}
{"id": "op_sortalpha_dropshort", "entry_point": "op_sortalpha_dropshort", "primitives": ["sortalpha", "dropshort"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters.", "solution": "def op_sortalpha_dropshort(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_sortalpha_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_dropshort([]) == []\nassert op_sortalpha_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_sortalpha_dropshort(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_dropshort(['x']) == []\nassert op_sortalpha_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_trimends_sortabs", "entry_point": "op_trimends_sortabs", "primitives": ["trimends", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value.", "solution": "def op_trimends_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_sortabs([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_sortabs([]) == []\nassert op_trimends_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_trimends_sortabs([5, 5, 5]) == [5]\nassert op_trimends_sortabs([3, 1, 2]) == [1]\nassert op_trimends_sortabs([10]) == []\nassert op_trimends_sortabs([2, 4, 6]) == [4]\nassert op_trimends_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_first3_pos", "entry_point": "op_first3_pos", "primitives": ["first3", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers.", "solution": "def op_first3_pos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_first3_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_pos([]) == []\nassert op_first3_pos([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_first3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_first3_pos([10]) == [10]\nassert op_first3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_first3_pos([-7, 12, -7]) == [12]"}
{"id": "op_sortalpha_counts", "entry_point": "op_sortalpha_counts", "primitives": ["sortalpha", "counts"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then return how many strings remain.", "solution": "def op_sortalpha_counts(xs):\n    r = list(xs)\n    r = sorted(r)\n    return len(r)", "tests": "assert op_sortalpha_counts(['Hello', 'world']) == 2\nassert op_sortalpha_counts([]) == 0\nassert op_sortalpha_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_counts(['one', 'one', 'Two']) == 3\nassert op_sortalpha_counts(['x']) == 1\nassert op_sortalpha_counts(['abc', 'de', '']) == 3"}
{"id": "op_double_dec", "entry_point": "op_double_dec", "primitives": ["double", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each.", "solution": "def op_double_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_dec([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_double_dec([]) == []\nassert op_double_dec([-2, -1, 0, 1, 2]) == [-5, -3, -1, 1, 3]\nassert op_double_dec([5, 5, 5]) == [9, 9, 9]\nassert op_double_dec([3, 1, 2]) == [5, 1, 3]\nassert op_double_dec([10]) == [19]\nassert op_double_dec([2, 4, 6]) == [3, 7, 11]\nassert op_double_dec([-7, 12, -7]) == [-15, 23, -15]"}
{"id": "op_div3_takewhilepos", "entry_point": "op_div3_takewhilepos", "primitives": ["div3", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive.", "solution": "def op_div3_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos([]) == []\nassert op_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos([5, 5, 5]) == []\nassert op_div3_takewhilepos([3, 1, 2]) == [3]\nassert op_div3_takewhilepos([10]) == []\nassert op_div3_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_gt5_beforezero", "entry_point": "op_gt5_beforezero", "primitives": ["gt5", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero.", "solution": "def op_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_gt5_beforezero([]) == []\nassert op_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_gt5_beforezero([5, 5, 5]) == []\nassert op_gt5_beforezero([3, 1, 2]) == []\nassert op_gt5_beforezero([10]) == [10]\nassert op_gt5_beforezero([2, 4, 6]) == [6]\nassert op_gt5_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_square_inc", "entry_point": "op_square_inc", "primitives": ["square", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each.", "solution": "def op_square_inc(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_square_inc([1, 2, 3, 4]) == [2, 5, 10, 17]\nassert op_square_inc([]) == []\nassert op_square_inc([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_square_inc([5, 5, 5]) == [26, 26, 26]\nassert op_square_inc([3, 1, 2]) == [10, 2, 5]\nassert op_square_inc([10]) == [101]\nassert op_square_inc([2, 4, 6]) == [5, 17, 37]\nassert op_square_inc([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_absval_first3", "entry_point": "op_absval_first3", "primitives": ["absval", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three.", "solution": "def op_absval_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_absval_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_first3([]) == []\nassert op_absval_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_first3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_first3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_first3([10]) == [10]\nassert op_absval_first3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_first3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_first3_uniq", "entry_point": "op_first3_uniq", "primitives": ["first3", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_first3_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_uniq([]) == []\nassert op_first3_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_uniq([5, 5, 5]) == [5]\nassert op_first3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_first3_uniq([10]) == [10]\nassert op_first3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_first3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropfirst_len", "entry_point": "op_dropfirst_len", "primitives": ["dropfirst", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return how many remain.", "solution": "def op_dropfirst_len(xs):\n    r = list(xs)\n    r = r[1:]\n    return len(r)", "tests": "assert op_dropfirst_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_len([]) == 0\nassert op_dropfirst_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_len([5, 5, 5]) == 2\nassert op_dropfirst_len([3, 1, 2]) == 2\nassert op_dropfirst_len([10]) == 0\nassert op_dropfirst_len([2, 4, 6]) == 2\nassert op_dropfirst_len([-7, 12, -7]) == 2"}
{"id": "op_rev_inc", "entry_point": "op_rev_inc", "primitives": ["rev", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each.", "solution": "def op_rev_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_rev_inc([]) == []\nassert op_rev_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_rev_inc([5, 5, 5]) == [6, 6, 6]\nassert op_rev_inc([3, 1, 2]) == [3, 2, 4]\nassert op_rev_inc([10]) == [11]\nassert op_rev_inc([2, 4, 6]) == [7, 5, 3]\nassert op_rev_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_inc_neg", "entry_point": "op_inc_neg", "primitives": ["inc", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers.", "solution": "def op_inc_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_neg([1, 2, 3, 4]) == []\nassert op_inc_neg([]) == []\nassert op_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg([5, 5, 5]) == []\nassert op_inc_neg([3, 1, 2]) == []\nassert op_inc_neg([10]) == []\nassert op_inc_neg([2, 4, 6]) == []\nassert op_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_absval_oremptyzero", "entry_point": "op_absval_oremptyzero", "primitives": ["absval", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then if empty, use a single zero.", "solution": "def op_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_absval_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_oremptyzero([]) == [0]\nassert op_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_absval_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_absval_oremptyzero([10]) == [10]\nassert op_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_absval_oremptyzero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_square_evens", "entry_point": "op_square_evens", "primitives": ["square", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers.", "solution": "def op_square_evens(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_square_evens([1, 2, 3, 4]) == [4, 16]\nassert op_square_evens([]) == []\nassert op_square_evens([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_square_evens([5, 5, 5]) == []\nassert op_square_evens([3, 1, 2]) == [4]\nassert op_square_evens([10]) == [100]\nassert op_square_evens([2, 4, 6]) == [4, 16, 36]\nassert op_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_takewhilepos_sum", "entry_point": "op_takewhilepos_sum", "primitives": ["takewhilepos", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return their sum.", "solution": "def op_takewhilepos_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_takewhilepos_sum([1, 2, 3, 4]) == 10\nassert op_takewhilepos_sum([]) == 0\nassert op_takewhilepos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sum([5, 5, 5]) == 15\nassert op_takewhilepos_sum([3, 1, 2]) == 6\nassert op_takewhilepos_sum([10]) == 10\nassert op_takewhilepos_sum([2, 4, 6]) == 12\nassert op_takewhilepos_sum([-7, 12, -7]) == 0"}
{"id": "op_evens_square", "entry_point": "op_evens_square", "primitives": ["evens", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each.", "solution": "def op_evens_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_evens_square([]) == []\nassert op_evens_square([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_evens_square([5, 5, 5]) == []\nassert op_evens_square([3, 1, 2]) == [4]\nassert op_evens_square([10]) == [100]\nassert op_evens_square([2, 4, 6]) == [4, 16, 36]\nassert op_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_evens_beforezero", "entry_point": "op_evens_beforezero", "primitives": ["evens", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero.", "solution": "def op_evens_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_beforezero([]) == []\nassert op_evens_beforezero([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_beforezero([5, 5, 5]) == []\nassert op_evens_beforezero([3, 1, 2]) == [2]\nassert op_evens_beforezero([10]) == [10]\nassert op_evens_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_rev_prod", "entry_point": "op_rev_prod", "primitives": ["rev", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return their product.", "solution": "def op_rev_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return __import__('math').prod(r)", "tests": "assert op_rev_prod([1, 2, 3, 4]) == 24\nassert op_rev_prod([]) == 1\nassert op_rev_prod([-2, -1, 0, 1, 2]) == 0\nassert op_rev_prod([5, 5, 5]) == 125\nassert op_rev_prod([3, 1, 2]) == 6\nassert op_rev_prod([10]) == 10\nassert op_rev_prod([2, 4, 6]) == 48\nassert op_rev_prod([-7, 12, -7]) == 588"}
{"id": "op_evens_dec", "entry_point": "op_evens_dec", "primitives": ["evens", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then subtract one from each.", "solution": "def op_evens_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_evens_dec([1, 2, 3, 4]) == [1, 3]\nassert op_evens_dec([]) == []\nassert op_evens_dec([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_evens_dec([5, 5, 5]) == []\nassert op_evens_dec([3, 1, 2]) == [1]\nassert op_evens_dec([10]) == [9]\nassert op_evens_dec([2, 4, 6]) == [1, 3, 5]\nassert op_evens_dec([-7, 12, -7]) == [11]"}
{"id": "op_clamp10_dec", "entry_point": "op_clamp10_dec", "primitives": ["clamp10", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each.", "solution": "def op_clamp10_dec(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_clamp10_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_clamp10_dec([]) == []\nassert op_clamp10_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_clamp10_dec([5, 5, 5]) == [4, 4, 4]\nassert op_clamp10_dec([3, 1, 2]) == [2, 0, 1]\nassert op_clamp10_dec([10]) == [9]\nassert op_clamp10_dec([2, 4, 6]) == [1, 3, 5]\nassert op_clamp10_dec([-7, 12, -7]) == [-8, 9, -8]"}
{"id": "op_sortabs_oremptyzero", "entry_point": "op_sortabs_oremptyzero", "primitives": ["sortabs", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero.", "solution": "def op_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_oremptyzero([]) == [0]\nassert op_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_oremptyzero([10]) == [10]\nassert op_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_div3_prod", "entry_point": "op_div3_prod", "primitives": ["div3", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return their product.", "solution": "def op_div3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_div3_prod([1, 2, 3, 4]) == 3\nassert op_div3_prod([]) == 1\nassert op_div3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_div3_prod([5, 5, 5]) == 1\nassert op_div3_prod([3, 1, 2]) == 3\nassert op_div3_prod([10]) == 1\nassert op_div3_prod([2, 4, 6]) == 6\nassert op_div3_prod([-7, 12, -7]) == 12"}
{"id": "op_evens_oremptyzero", "entry_point": "op_evens_oremptyzero", "primitives": ["evens", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero.", "solution": "def op_evens_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_oremptyzero([]) == [0]\nassert op_evens_oremptyzero([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_oremptyzero([10]) == [10]\nassert op_evens_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_inc_takewhilepos", "entry_point": "op_inc_takewhilepos", "primitives": ["inc", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive.", "solution": "def op_inc_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_takewhilepos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_takewhilepos([]) == []\nassert op_inc_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_takewhilepos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_takewhilepos([10]) == [11]\nassert op_inc_takewhilepos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_double_sorta", "entry_point": "op_double_sorta", "primitives": ["double", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending.", "solution": "def op_double_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_double_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_sorta([]) == []\nassert op_double_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_double_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_double_sorta([10]) == [20]\nassert op_double_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_double_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropwhileneg_max", "entry_point": "op_dropwhileneg_max", "primitives": ["dropwhileneg", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_max([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_max([]) == 0\nassert op_dropwhileneg_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_max([5, 5, 5]) == 5\nassert op_dropwhileneg_max([3, 1, 2]) == 3\nassert op_dropwhileneg_max([10]) == 10\nassert op_dropwhileneg_max([2, 4, 6]) == 6\nassert op_dropwhileneg_max([-7, 12, -7]) == 12"}
{"id": "op_absval_add10", "entry_point": "op_absval_add10", "primitives": ["absval", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each.", "solution": "def op_absval_add10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_absval_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_absval_add10([]) == []\nassert op_absval_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 11, 12]\nassert op_absval_add10([5, 5, 5]) == [15, 15, 15]\nassert op_absval_add10([3, 1, 2]) == [13, 11, 12]\nassert op_absval_add10([10]) == [20]\nassert op_absval_add10([2, 4, 6]) == [12, 14, 16]\nassert op_absval_add10([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_sortabs_add10", "entry_point": "op_sortabs_add10", "primitives": ["sortabs", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add ten to each.", "solution": "def op_sortabs_add10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortabs_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sortabs_add10([]) == []\nassert op_sortabs_add10([-2, -1, 0, 1, 2]) == [10, 9, 11, 8, 12]\nassert op_sortabs_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sortabs_add10([3, 1, 2]) == [11, 12, 13]\nassert op_sortabs_add10([10]) == [20]\nassert op_sortabs_add10([2, 4, 6]) == [12, 14, 16]\nassert op_sortabs_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_pos_last3", "entry_point": "op_pos_last3", "primitives": ["pos", "last3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three.", "solution": "def op_pos_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_pos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_last3([]) == []\nassert op_pos_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_last3([10]) == [10]\nassert op_pos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_last3([-7, 12, -7]) == [12]"}
{"id": "op_padto3_dropzeros", "entry_point": "op_padto3_dropzeros", "primitives": ["padto3", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros.", "solution": "def op_padto3_dropzeros(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_padto3_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_dropzeros([]) == []\nassert op_padto3_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_padto3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_dropzeros([10]) == [10]\nassert op_padto3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst_counteven", "entry_point": "op_dropfirst_counteven", "primitives": ["dropfirst", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return how many values are even.", "solution": "def op_dropfirst_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_counteven([]) == 0\nassert op_dropfirst_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_counteven([5, 5, 5]) == 0\nassert op_dropfirst_counteven([3, 1, 2]) == 1\nassert op_dropfirst_counteven([10]) == 0\nassert op_dropfirst_counteven([2, 4, 6]) == 2\nassert op_dropfirst_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_takewhilepos", "entry_point": "op_clamp10_takewhilepos", "primitives": ["clamp10", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive.", "solution": "def op_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_clamp10_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_takewhilepos([]) == []\nassert op_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_takewhilepos([10]) == [10]\nassert op_clamp10_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_add10_takewhilepos", "entry_point": "op_add10_takewhilepos", "primitives": ["add10", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive.", "solution": "def op_add10_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_add10_takewhilepos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_takewhilepos([]) == []\nassert op_add10_takewhilepos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_takewhilepos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_takewhilepos([10]) == [20]\nassert op_add10_takewhilepos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_takewhilepos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_ages_min", "entry_point": "op_ages_min", "primitives": ["ages", "min"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return the minimum (0 if empty).", "solution": "def op_ages_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return min(r) if r else 0", "tests": "assert op_ages_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_min([]) == 0\nassert op_ages_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_evens_odds", "entry_point": "op_evens_odds", "primitives": ["evens", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers.", "solution": "def op_evens_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_odds([1, 2, 3, 4]) == []\nassert op_evens_odds([]) == []\nassert op_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds([5, 5, 5]) == []\nassert op_evens_odds([3, 1, 2]) == []\nassert op_evens_odds([10]) == []\nassert op_evens_odds([2, 4, 6]) == []\nassert op_evens_odds([-7, 12, -7]) == []"}
{"id": "op_beforezero_double", "entry_point": "op_beforezero_double", "primitives": ["beforezero", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each.", "solution": "def op_beforezero_double(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_beforezero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_beforezero_double([]) == []\nassert op_beforezero_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_beforezero_double([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_double([3, 1, 2]) == [6, 2, 4]\nassert op_beforezero_double([10]) == [20]\nassert op_beforezero_double([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_add10_sortd", "entry_point": "op_add10_sortd", "primitives": ["add10", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort descending.", "solution": "def op_add10_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_sortd([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_sortd([]) == []\nassert op_add10_sortd([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_add10_sortd([10]) == [20]\nassert op_add10_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_add10_sortd([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_takewhilepos_dropfirst", "entry_point": "op_takewhilepos_dropfirst", "primitives": ["takewhilepos", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element.", "solution": "def op_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_takewhilepos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_dropfirst([]) == []\nassert op_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_takewhilepos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_takewhilepos_dropfirst([10]) == []\nassert op_takewhilepos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_takewhilepos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_trimends_absval", "entry_point": "op_trimends_absval", "primitives": ["trimends", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each.", "solution": "def op_trimends_absval(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_trimends_absval([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_absval([]) == []\nassert op_trimends_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_absval([5, 5, 5]) == [5]\nassert op_trimends_absval([3, 1, 2]) == [1]\nassert op_trimends_absval([10]) == []\nassert op_trimends_absval([2, 4, 6]) == [4]\nassert op_trimends_absval([-7, 12, -7]) == [12]"}
{"id": "op_negate_pos", "entry_point": "op_negate_pos", "primitives": ["negate", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers.", "solution": "def op_negate_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_pos([1, 2, 3, 4]) == []\nassert op_negate_pos([]) == []\nassert op_negate_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_pos([5, 5, 5]) == []\nassert op_negate_pos([3, 1, 2]) == []\nassert op_negate_pos([10]) == []\nassert op_negate_pos([2, 4, 6]) == []\nassert op_negate_pos([-7, 12, -7]) == [7, 7]"}
{"id": "op_uniq_rev", "entry_point": "op_uniq_rev", "primitives": ["uniq", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_uniq_rev(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_uniq_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_rev([]) == []\nassert op_uniq_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_rev([5, 5, 5]) == [5]\nassert op_uniq_rev([3, 1, 2]) == [2, 1, 3]\nassert op_uniq_rev([10]) == [10]\nassert op_uniq_rev([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_rev([-7, 12, -7]) == [12, -7]"}
{"id": "op_neg_sorta", "entry_point": "op_neg_sorta", "primitives": ["neg", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending.", "solution": "def op_neg_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_neg_sorta([1, 2, 3, 4]) == []\nassert op_neg_sorta([]) == []\nassert op_neg_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_sorta([5, 5, 5]) == []\nassert op_neg_sorta([3, 1, 2]) == []\nassert op_neg_sorta([10]) == []\nassert op_neg_sorta([2, 4, 6]) == []\nassert op_neg_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_trimends_dec", "entry_point": "op_trimends_dec", "primitives": ["trimends", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each.", "solution": "def op_trimends_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_dec([1, 2, 3, 4]) == [1, 2]\nassert op_trimends_dec([]) == []\nassert op_trimends_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_trimends_dec([5, 5, 5]) == [4]\nassert op_trimends_dec([3, 1, 2]) == [0]\nassert op_trimends_dec([10]) == []\nassert op_trimends_dec([2, 4, 6]) == [3]\nassert op_trimends_dec([-7, 12, -7]) == [11]"}
{"id": "op_negate_len", "entry_point": "op_negate_len", "primitives": ["negate", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then return how many remain.", "solution": "def op_negate_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_negate_len([1, 2, 3, 4]) == 4\nassert op_negate_len([]) == 0\nassert op_negate_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_len([5, 5, 5]) == 3\nassert op_negate_len([3, 1, 2]) == 3\nassert op_negate_len([10]) == 1\nassert op_negate_len([2, 4, 6]) == 3\nassert op_negate_len([-7, 12, -7]) == 3"}
{"id": "op_pos_clamp10", "entry_point": "op_pos_clamp10", "primitives": ["pos", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10.", "solution": "def op_pos_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_clamp10([]) == []\nassert op_pos_clamp10([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_pos_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10([10]) == [10]\nassert op_pos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_sortabs_padto3", "entry_point": "op_sortabs_padto3", "primitives": ["sortabs", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_sortabs_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_padto3([]) == [0, 0, 0]\nassert op_sortabs_padto3([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_padto3([10]) == [10, 0, 0]\nassert op_sortabs_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_sum", "entry_point": "op_beforezero_sum", "primitives": ["beforezero", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return their sum.", "solution": "def op_beforezero_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(r)", "tests": "assert op_beforezero_sum([1, 2, 3, 4]) == 10\nassert op_beforezero_sum([]) == 0\nassert op_beforezero_sum([-2, -1, 0, 1, 2]) == -3\nassert op_beforezero_sum([5, 5, 5]) == 15\nassert op_beforezero_sum([3, 1, 2]) == 6\nassert op_beforezero_sum([10]) == 10\nassert op_beforezero_sum([2, 4, 6]) == 12\nassert op_beforezero_sum([-7, 12, -7]) == -2"}
{"id": "op_div3_firsteven", "entry_point": "op_div3_firsteven", "primitives": ["div3", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then return the first even value (0 if none).", "solution": "def op_div3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_firsteven([]) == 0\nassert op_div3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_firsteven([5, 5, 5]) == 0\nassert op_div3_firsteven([3, 1, 2]) == 0\nassert op_div3_firsteven([10]) == 0\nassert op_div3_firsteven([2, 4, 6]) == 6\nassert op_div3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_odds_gt5", "entry_point": "op_odds_gt5", "primitives": ["odds", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep values greater than five.", "solution": "def op_odds_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_gt5([1, 2, 3, 4]) == []\nassert op_odds_gt5([]) == []\nassert op_odds_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_gt5([5, 5, 5]) == []\nassert op_odds_gt5([3, 1, 2]) == []\nassert op_odds_gt5([10]) == []\nassert op_odds_gt5([2, 4, 6]) == []\nassert op_odds_gt5([-7, 12, -7]) == []"}
{"id": "op_ages_counteven", "entry_point": "op_ages_counteven", "primitives": ["ages", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return how many values are even.", "solution": "def op_ages_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_counteven([]) == 0\nassert op_ages_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_ages_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_beforezero_max", "entry_point": "op_beforezero_max", "primitives": ["beforezero", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_beforezero_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_beforezero_max([1, 2, 3, 4]) == 4\nassert op_beforezero_max([]) == 0\nassert op_beforezero_max([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_max([5, 5, 5]) == 5\nassert op_beforezero_max([3, 1, 2]) == 3\nassert op_beforezero_max([10]) == 10\nassert op_beforezero_max([2, 4, 6]) == 6\nassert op_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_firstchar_uniqs", "entry_point": "op_firstchar_uniqs", "primitives": ["firstchar", "uniqs"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then drop duplicate strings keeping the first.", "solution": "def op_firstchar_uniqs(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_firstchar_uniqs(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_uniqs([]) == []\nassert op_firstchar_uniqs(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_uniqs(['one', 'one', 'Two']) == ['o', 'T']\nassert op_firstchar_uniqs(['x']) == ['x']\nassert op_firstchar_uniqs(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortage_ages", "entry_point": "op_sortage_ages", "primitives": ["sortage", "ages"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages.", "solution": "def op_sortage_ages(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    return r", "tests": "assert op_sortage_ages([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_sortage_ages([]) == []\nassert op_sortage_ages([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_sortage_ages([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sorta_sum", "entry_point": "op_sorta_sum", "primitives": ["sorta", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then return their sum.", "solution": "def op_sorta_sum(xs):\n    r = list(xs)\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_sorta_sum([1, 2, 3, 4]) == 10\nassert op_sorta_sum([]) == 0\nassert op_sorta_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_sum([5, 5, 5]) == 15\nassert op_sorta_sum([3, 1, 2]) == 6\nassert op_sorta_sum([10]) == 10\nassert op_sorta_sum([2, 4, 6]) == 12\nassert op_sorta_sum([-7, 12, -7]) == -2"}
{"id": "op_sortd_rev", "entry_point": "op_sortd_rev", "primitives": ["sortd", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then reverse the order.", "solution": "def op_sortd_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_rev([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_rev([]) == []\nassert op_sortd_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_rev([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_rev([10]) == [10]\nassert op_sortd_rev([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_rev([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_negate_dec", "entry_point": "op_negate_dec", "primitives": ["negate", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each.", "solution": "def op_negate_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_dec([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_negate_dec([]) == []\nassert op_negate_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_negate_dec([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_dec([3, 1, 2]) == [-4, -2, -3]\nassert op_negate_dec([10]) == [-11]\nassert op_negate_dec([2, 4, 6]) == [-3, -5, -7]\nassert op_negate_dec([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_lower_uniqs", "entry_point": "op_lower_uniqs", "primitives": ["lower", "uniqs"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop duplicate strings keeping the first.", "solution": "def op_lower_uniqs(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_lower_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_uniqs([]) == []\nassert op_lower_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ', '', 'bc']\nassert op_lower_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_lower_uniqs(['x']) == ['x']\nassert op_lower_uniqs(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_absval_allpos", "entry_point": "op_absval_allpos", "primitives": ["absval", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return whether all values are positive.", "solution": "def op_absval_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_allpos([1, 2, 3, 4]) == True\nassert op_absval_allpos([]) == True\nassert op_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_absval_allpos([5, 5, 5]) == True\nassert op_absval_allpos([3, 1, 2]) == True\nassert op_absval_allpos([10]) == True\nassert op_absval_allpos([2, 4, 6]) == True\nassert op_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_evens_double", "entry_point": "op_evens_double", "primitives": ["evens", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each.", "solution": "def op_evens_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_double([1, 2, 3, 4]) == [4, 8]\nassert op_evens_double([]) == []\nassert op_evens_double([-2, -1, 0, 1, 2]) == [-4, 0, 4]\nassert op_evens_double([5, 5, 5]) == []\nassert op_evens_double([3, 1, 2]) == [4]\nassert op_evens_double([10]) == [20]\nassert op_evens_double([2, 4, 6]) == [4, 8, 12]\nassert op_evens_double([-7, 12, -7]) == [24]"}
{"id": "op_double_inc", "entry_point": "op_double_inc", "primitives": ["double", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each.", "solution": "def op_double_inc(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_double_inc([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_double_inc([]) == []\nassert op_double_inc([-2, -1, 0, 1, 2]) == [-3, -1, 1, 3, 5]\nassert op_double_inc([5, 5, 5]) == [11, 11, 11]\nassert op_double_inc([3, 1, 2]) == [7, 3, 5]\nassert op_double_inc([10]) == [21]\nassert op_double_inc([2, 4, 6]) == [5, 9, 13]\nassert op_double_inc([-7, 12, -7]) == [-13, 25, -13]"}
{"id": "op_sortabs_trimends", "entry_point": "op_sortabs_trimends", "primitives": ["sortabs", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements.", "solution": "def op_sortabs_trimends(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_sortabs_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sortabs_trimends([]) == []\nassert op_sortabs_trimends([-2, -1, 0, 1, 2]) == [-1, 1, -2]\nassert op_sortabs_trimends([5, 5, 5]) == [5]\nassert op_sortabs_trimends([3, 1, 2]) == [2]\nassert op_sortabs_trimends([10]) == []\nassert op_sortabs_trimends([2, 4, 6]) == [4]\nassert op_sortabs_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_div3_absval", "entry_point": "op_div3_absval", "primitives": ["div3", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each.", "solution": "def op_div3_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_absval([1, 2, 3, 4]) == [3]\nassert op_div3_absval([]) == []\nassert op_div3_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_absval([5, 5, 5]) == []\nassert op_div3_absval([3, 1, 2]) == [3]\nassert op_div3_absval([10]) == []\nassert op_div3_absval([2, 4, 6]) == [6]\nassert op_div3_absval([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_issorted", "entry_point": "op_dropfirst_issorted", "primitives": ["dropfirst", "issorted"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    return r == sorted(r)", "tests": "assert op_dropfirst_issorted([1, 2, 3, 4]) == True\nassert op_dropfirst_issorted([]) == True\nassert op_dropfirst_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_issorted([5, 5, 5]) == True\nassert op_dropfirst_issorted([3, 1, 2]) == True\nassert op_dropfirst_issorted([10]) == True\nassert op_dropfirst_issorted([2, 4, 6]) == True\nassert op_dropfirst_issorted([-7, 12, -7]) == False"}
{"id": "op_inc_padto3", "entry_point": "op_inc_padto3", "primitives": ["inc", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements.", "solution": "def op_inc_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_padto3([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_padto3([]) == [0, 0, 0]\nassert op_inc_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_padto3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_padto3([10]) == [11, 0, 0]\nassert op_inc_padto3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_padto3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_nonempty_sortalpha", "entry_point": "op_nonempty_sortalpha", "primitives": ["nonempty", "sortalpha"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort alphabetically.", "solution": "def op_nonempty_sortalpha(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r)\n    return r", "tests": "assert op_nonempty_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_sortalpha([]) == []\nassert op_nonempty_sortalpha(['  a ', '', 'BC', 'bc']) == ['  a ', 'BC', 'bc']\nassert op_nonempty_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_nonempty_sortalpha(['x']) == ['x']\nassert op_nonempty_sortalpha(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_ages_firsteven", "entry_point": "op_ages_firsteven", "primitives": ["ages", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return the first even value (0 if none).", "solution": "def op_ages_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_firsteven([]) == 0\nassert op_ages_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 18\nassert op_ages_firsteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_strip_dropshort", "entry_point": "op_strip_dropshort", "primitives": ["strip", "dropshort"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop strings shorter than three characters.", "solution": "def op_strip_dropshort(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_strip_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_dropshort([]) == []\nassert op_strip_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_strip_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_strip_dropshort(['x']) == []\nassert op_strip_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_add10_odds", "entry_point": "op_add10_odds", "primitives": ["add10", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers.", "solution": "def op_add10_odds(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_add10_odds([1, 2, 3, 4]) == [11, 13]\nassert op_add10_odds([]) == []\nassert op_add10_odds([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_add10_odds([5, 5, 5]) == [15, 15, 15]\nassert op_add10_odds([3, 1, 2]) == [13, 11]\nassert op_add10_odds([10]) == []\nassert op_add10_odds([2, 4, 6]) == []\nassert op_add10_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_sortd_sorta", "entry_point": "op_sortd_sorta", "primitives": ["sortd", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending.", "solution": "def op_sortd_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sorta([]) == []\nassert op_sortd_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sorta([10]) == [10]\nassert op_sortd_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_inc_alldistinct", "entry_point": "op_inc_alldistinct", "primitives": ["inc", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then return whether all values are distinct.", "solution": "def op_inc_alldistinct(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_inc_alldistinct([1, 2, 3, 4]) == True\nassert op_inc_alldistinct([]) == True\nassert op_inc_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_inc_alldistinct([5, 5, 5]) == False\nassert op_inc_alldistinct([3, 1, 2]) == True\nassert op_inc_alldistinct([10]) == True\nassert op_inc_alldistinct([2, 4, 6]) == True\nassert op_inc_alldistinct([-7, 12, -7]) == False"}
{"id": "op_first3_clamp10", "entry_point": "op_first3_clamp10", "primitives": ["first3", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10.", "solution": "def op_first3_clamp10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_first3_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10([]) == []\nassert op_first3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_first3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_first3_clamp10([10]) == [10]\nassert op_first3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_sortalpha_lower", "entry_point": "op_sortalpha_lower", "primitives": ["sortalpha", "lower"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then lowercase each string.", "solution": "def op_sortalpha_lower(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_sortalpha_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_sortalpha_lower([]) == []\nassert op_sortalpha_lower(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc', 'bc']\nassert op_sortalpha_lower(['one', 'one', 'Two']) == ['two', 'one', 'one']\nassert op_sortalpha_lower(['x']) == ['x']\nassert op_sortalpha_lower(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_pos_first3", "entry_point": "op_pos_first3", "primitives": ["pos", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three.", "solution": "def op_pos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return r", "tests": "assert op_pos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_first3([]) == []\nassert op_pos_first3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_first3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_first3([10]) == [10]\nassert op_pos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_first3([-7, 12, -7]) == [12]"}
{"id": "op_lower_counts", "entry_point": "op_lower_counts", "primitives": ["lower", "counts"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then return how many strings remain.", "solution": "def op_lower_counts(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return len(r)", "tests": "assert op_lower_counts(['Hello', 'world']) == 2\nassert op_lower_counts([]) == 0\nassert op_lower_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_lower_counts(['one', 'one', 'Two']) == 3\nassert op_lower_counts(['x']) == 1\nassert op_lower_counts(['abc', 'de', '']) == 3"}
{"id": "op_double_odds", "entry_point": "op_double_odds", "primitives": ["double", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers.", "solution": "def op_double_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_odds([1, 2, 3, 4]) == []\nassert op_double_odds([]) == []\nassert op_double_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_odds([5, 5, 5]) == []\nassert op_double_odds([3, 1, 2]) == []\nassert op_double_odds([10]) == []\nassert op_double_odds([2, 4, 6]) == []\nassert op_double_odds([-7, 12, -7]) == []"}
{"id": "op_trimends_anyeven", "entry_point": "op_trimends_anyeven", "primitives": ["trimends", "anyeven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return whether any value is even.", "solution": "def op_trimends_anyeven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_trimends_anyeven([1, 2, 3, 4]) == True\nassert op_trimends_anyeven([]) == False\nassert op_trimends_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_trimends_anyeven([5, 5, 5]) == False\nassert op_trimends_anyeven([3, 1, 2]) == False\nassert op_trimends_anyeven([10]) == False\nassert op_trimends_anyeven([2, 4, 6]) == True\nassert op_trimends_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_add10", "entry_point": "op_evens_add10", "primitives": ["evens", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each.", "solution": "def op_evens_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_evens_add10([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10([]) == []\nassert op_evens_add10([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10([5, 5, 5]) == []\nassert op_evens_add10([3, 1, 2]) == [12]\nassert op_evens_add10([10]) == [20]\nassert op_evens_add10([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10([-7, 12, -7]) == [22]"}
{"id": "op_beforezero_neg", "entry_point": "op_beforezero_neg", "primitives": ["beforezero", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers.", "solution": "def op_beforezero_neg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_beforezero_neg([1, 2, 3, 4]) == []\nassert op_beforezero_neg([]) == []\nassert op_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_neg([5, 5, 5]) == []\nassert op_beforezero_neg([3, 1, 2]) == []\nassert op_beforezero_neg([10]) == []\nassert op_beforezero_neg([2, 4, 6]) == []\nassert op_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dec_haszero", "entry_point": "op_dec_haszero", "primitives": ["dec", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return whether the list contains a zero.", "solution": "def op_dec_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_dec_haszero([1, 2, 3, 4]) == True\nassert op_dec_haszero([]) == False\nassert op_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dec_haszero([5, 5, 5]) == False\nassert op_dec_haszero([3, 1, 2]) == True\nassert op_dec_haszero([10]) == False\nassert op_dec_haszero([2, 4, 6]) == False\nassert op_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_names_upper", "entry_point": "op_names_upper", "primitives": ["names", "upper"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then uppercase each string.", "solution": "def op_names_upper(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_names_upper([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['ADA', 'BO']\nassert op_names_upper([]) == []\nassert op_names_upper([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['CY', 'DEE', 'EL']\nassert op_names_upper([{'name': 'Fi', 'age': 41}]) == ['FI']"}
{"id": "op_div3_rev", "entry_point": "op_div3_rev", "primitives": ["div3", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order.", "solution": "def op_div3_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_div3_rev([1, 2, 3, 4]) == [3]\nassert op_div3_rev([]) == []\nassert op_div3_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev([5, 5, 5]) == []\nassert op_div3_rev([3, 1, 2]) == [3]\nassert op_div3_rev([10]) == []\nassert op_div3_rev([2, 4, 6]) == [6]\nassert op_div3_rev([-7, 12, -7]) == [12]"}
{"id": "op_ages_double", "entry_point": "op_ages_double", "primitives": ["ages", "double"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then double each.", "solution": "def op_ages_double(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_ages_double([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [72, 24]\nassert op_ages_double([]) == []\nassert op_ages_double([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [36, 130, 34]\nassert op_ages_double([{'name': 'Fi', 'age': 41}]) == [82]"}
{"id": "op_dropfirst_prod", "entry_point": "op_dropfirst_prod", "primitives": ["dropfirst", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return their product.", "solution": "def op_dropfirst_prod(xs):\n    r = list(xs)\n    r = r[1:]\n    return __import__('math').prod(r)", "tests": "assert op_dropfirst_prod([1, 2, 3, 4]) == 24\nassert op_dropfirst_prod([]) == 1\nassert op_dropfirst_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_prod([5, 5, 5]) == 25\nassert op_dropfirst_prod([3, 1, 2]) == 2\nassert op_dropfirst_prod([10]) == 1\nassert op_dropfirst_prod([2, 4, 6]) == 24\nassert op_dropfirst_prod([-7, 12, -7]) == -84"}
{"id": "op_dropzeros_clamp10", "entry_point": "op_dropzeros_clamp10", "primitives": ["dropzeros", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10.", "solution": "def op_dropzeros_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_clamp10([]) == []\nassert op_dropzeros_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_clamp10([10]) == [10]\nassert op_dropzeros_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_beforezero_len", "entry_point": "op_beforezero_len", "primitives": ["beforezero", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return how many remain.", "solution": "def op_beforezero_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r)", "tests": "assert op_beforezero_len([1, 2, 3, 4]) == 4\nassert op_beforezero_len([]) == 0\nassert op_beforezero_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_len([5, 5, 5]) == 3\nassert op_beforezero_len([3, 1, 2]) == 3\nassert op_beforezero_len([10]) == 1\nassert op_beforezero_len([2, 4, 6]) == 3\nassert op_beforezero_len([-7, 12, -7]) == 3"}
{"id": "op_sortabs_first3", "entry_point": "op_sortabs_first3", "primitives": ["sortabs", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three.", "solution": "def op_sortabs_first3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_sortabs_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_first3([]) == []\nassert op_sortabs_first3([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_sortabs_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_first3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_first3([10]) == [10]\nassert op_sortabs_first3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_first3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_gt5_len", "entry_point": "op_gt5_len", "primitives": ["gt5", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return how many remain.", "solution": "def op_gt5_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_gt5_len([1, 2, 3, 4]) == 0\nassert op_gt5_len([]) == 0\nassert op_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_len([5, 5, 5]) == 0\nassert op_gt5_len([3, 1, 2]) == 0\nassert op_gt5_len([10]) == 1\nassert op_gt5_len([2, 4, 6]) == 1\nassert op_gt5_len([-7, 12, -7]) == 1"}
{"id": "op_evens_takewhilepos", "entry_point": "op_evens_takewhilepos", "primitives": ["evens", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive.", "solution": "def op_evens_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_evens_takewhilepos([]) == []\nassert op_evens_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos([5, 5, 5]) == []\nassert op_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_evens_takewhilepos([10]) == [10]\nassert op_evens_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_negate_firsteven", "entry_point": "op_negate_firsteven", "primitives": ["negate", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then return the first even value (0 if none).", "solution": "def op_negate_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_firsteven([1, 2, 3, 4]) == -2\nassert op_negate_firsteven([]) == 0\nassert op_negate_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_negate_firsteven([5, 5, 5]) == 0\nassert op_negate_firsteven([3, 1, 2]) == -2\nassert op_negate_firsteven([10]) == -10\nassert op_negate_firsteven([2, 4, 6]) == -2\nassert op_negate_firsteven([-7, 12, -7]) == -12"}
{"id": "op_trimends_evens", "entry_point": "op_trimends_evens", "primitives": ["trimends", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers.", "solution": "def op_trimends_evens(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_trimends_evens([1, 2, 3, 4]) == [2]\nassert op_trimends_evens([]) == []\nassert op_trimends_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_evens([5, 5, 5]) == []\nassert op_trimends_evens([3, 1, 2]) == []\nassert op_trimends_evens([10]) == []\nassert op_trimends_evens([2, 4, 6]) == [4]\nassert op_trimends_evens([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_prod", "entry_point": "op_oremptyzero_prod", "primitives": ["oremptyzero", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return their product.", "solution": "def op_oremptyzero_prod(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_oremptyzero_prod([1, 2, 3, 4]) == 24\nassert op_oremptyzero_prod([]) == 0\nassert op_oremptyzero_prod([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_prod([5, 5, 5]) == 125\nassert op_oremptyzero_prod([3, 1, 2]) == 6\nassert op_oremptyzero_prod([10]) == 10\nassert op_oremptyzero_prod([2, 4, 6]) == 48\nassert op_oremptyzero_prod([-7, 12, -7]) == 588"}
{"id": "op_inc_evens", "entry_point": "op_inc_evens", "primitives": ["inc", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers.", "solution": "def op_inc_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_evens([1, 2, 3, 4]) == [2, 4]\nassert op_inc_evens([]) == []\nassert op_inc_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_inc_evens([5, 5, 5]) == [6, 6, 6]\nassert op_inc_evens([3, 1, 2]) == [4, 2]\nassert op_inc_evens([10]) == []\nassert op_inc_evens([2, 4, 6]) == []\nassert op_inc_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_sortd_allpos", "entry_point": "op_sortd_allpos", "primitives": ["sortd", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then return whether all values are positive.", "solution": "def op_sortd_allpos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_sortd_allpos([1, 2, 3, 4]) == True\nassert op_sortd_allpos([]) == True\nassert op_sortd_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortd_allpos([5, 5, 5]) == True\nassert op_sortd_allpos([3, 1, 2]) == True\nassert op_sortd_allpos([10]) == True\nassert op_sortd_allpos([2, 4, 6]) == True\nassert op_sortd_allpos([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_min", "entry_point": "op_takewhilepos_min", "primitives": ["takewhilepos", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_min([]) == 0\nassert op_takewhilepos_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_min([5, 5, 5]) == 5\nassert op_takewhilepos_min([3, 1, 2]) == 1\nassert op_takewhilepos_min([10]) == 10\nassert op_takewhilepos_min([2, 4, 6]) == 2\nassert op_takewhilepos_min([-7, 12, -7]) == 0"}
{"id": "op_upper_lens", "entry_point": "op_upper_lens", "primitives": ["upper", "lens"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then return the total number of characters.", "solution": "def op_upper_lens(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_upper_lens(['Hello', 'world']) == 10\nassert op_upper_lens([]) == 0\nassert op_upper_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_upper_lens(['one', 'one', 'Two']) == 9\nassert op_upper_lens(['x']) == 1\nassert op_upper_lens(['abc', 'de', '']) == 5"}
{"id": "op_negate_sortd", "entry_point": "op_negate_sortd", "primitives": ["negate", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending.", "solution": "def op_negate_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_sortd([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_sortd([]) == []\nassert op_negate_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sortd([10]) == [-10]\nassert op_negate_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sortd([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_negate_double", "entry_point": "op_negate_double", "primitives": ["negate", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each.", "solution": "def op_negate_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_double([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_negate_double([]) == []\nassert op_negate_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_negate_double([5, 5, 5]) == [-10, -10, -10]\nassert op_negate_double([3, 1, 2]) == [-6, -2, -4]\nassert op_negate_double([10]) == [-20]\nassert op_negate_double([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_double([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_pos_firsteven", "entry_point": "op_pos_firsteven", "primitives": ["pos", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then return the first even value (0 if none).", "solution": "def op_pos_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_firsteven([1, 2, 3, 4]) == 2\nassert op_pos_firsteven([]) == 0\nassert op_pos_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_firsteven([5, 5, 5]) == 0\nassert op_pos_firsteven([3, 1, 2]) == 2\nassert op_pos_firsteven([10]) == 10\nassert op_pos_firsteven([2, 4, 6]) == 2\nassert op_pos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_names_strip", "entry_point": "op_names_strip", "primitives": ["names", "strip"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then trim whitespace from each.", "solution": "def op_names_strip(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_names_strip([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_strip([]) == []\nassert op_names_strip([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_strip([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_negate_dropzeros", "entry_point": "op_negate_dropzeros", "primitives": ["negate", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros.", "solution": "def op_negate_dropzeros(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_negate_dropzeros([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_dropzeros([]) == []\nassert op_negate_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_negate_dropzeros([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_dropzeros([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_dropzeros([10]) == [-10]\nassert op_negate_dropzeros([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_dropzeros([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_beforezero_div3", "entry_point": "op_beforezero_div3", "primitives": ["beforezero", "div3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three.", "solution": "def op_beforezero_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_beforezero_div3([]) == []\nassert op_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_div3([5, 5, 5]) == []\nassert op_beforezero_div3([3, 1, 2]) == [3]\nassert op_beforezero_div3([10]) == []\nassert op_beforezero_div3([2, 4, 6]) == [6]\nassert op_beforezero_div3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_max", "entry_point": "op_gt5_max", "primitives": ["gt5", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return the maximum (0 if empty).", "solution": "def op_gt5_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return max(r) if r else 0", "tests": "assert op_gt5_max([1, 2, 3, 4]) == 0\nassert op_gt5_max([]) == 0\nassert op_gt5_max([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_max([5, 5, 5]) == 0\nassert op_gt5_max([3, 1, 2]) == 0\nassert op_gt5_max([10]) == 10\nassert op_gt5_max([2, 4, 6]) == 6\nassert op_gt5_max([-7, 12, -7]) == 12"}
{"id": "op_nonempty_longest", "entry_point": "op_nonempty_longest", "primitives": ["nonempty", "longest"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then return the longest string (empty if none).", "solution": "def op_nonempty_longest(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_nonempty_longest(['Hello', 'world']) == 'Hello'\nassert op_nonempty_longest([]) == ''\nassert op_nonempty_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_nonempty_longest(['one', 'one', 'Two']) == 'one'\nassert op_nonempty_longest(['x']) == 'x'\nassert op_nonempty_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_padto3_prod", "entry_point": "op_padto3_prod", "primitives": ["padto3", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then return their product.", "solution": "def op_padto3_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_padto3_prod([1, 2, 3, 4]) == 24\nassert op_padto3_prod([]) == 0\nassert op_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_prod([5, 5, 5]) == 125\nassert op_padto3_prod([3, 1, 2]) == 6\nassert op_padto3_prod([10]) == 0\nassert op_padto3_prod([2, 4, 6]) == 48\nassert op_padto3_prod([-7, 12, -7]) == 588"}
{"id": "op_rev_negate", "entry_point": "op_rev_negate", "primitives": ["rev", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each.", "solution": "def op_rev_negate(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_rev_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_rev_negate([]) == []\nassert op_rev_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_negate([3, 1, 2]) == [-2, -1, -3]\nassert op_rev_negate([10]) == [-10]\nassert op_rev_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_rev_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sortalpha_maxlen", "entry_point": "op_sortalpha_maxlen", "primitives": ["sortalpha", "maxlen"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then return the length of the longest string (0 if none).", "solution": "def op_sortalpha_maxlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortalpha_maxlen(['Hello', 'world']) == 5\nassert op_sortalpha_maxlen([]) == 0\nassert op_sortalpha_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortalpha_maxlen(['x']) == 1\nassert op_sortalpha_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_dropshort_anyempty", "entry_point": "op_dropshort_anyempty", "primitives": ["dropshort", "anyempty"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then return whether any string is empty.", "solution": "def op_dropshort_anyempty(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return any(s == '' for s in r)", "tests": "assert op_dropshort_anyempty(['Hello', 'world']) == False\nassert op_dropshort_anyempty([]) == False\nassert op_dropshort_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_dropshort_anyempty(['one', 'one', 'Two']) == False\nassert op_dropshort_anyempty(['x']) == False\nassert op_dropshort_anyempty(['abc', 'de', '']) == False"}
{"id": "op_ages_issorted", "entry_point": "op_ages_issorted", "primitives": ["ages", "issorted"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return whether the list is sorted ascending.", "solution": "def op_ages_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return r == sorted(r)", "tests": "assert op_ages_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_issorted([]) == True\nassert op_ages_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_pos_evens", "entry_point": "op_pos_evens", "primitives": ["pos", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers.", "solution": "def op_pos_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_pos_evens([1, 2, 3, 4]) == [2, 4]\nassert op_pos_evens([]) == []\nassert op_pos_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_evens([5, 5, 5]) == []\nassert op_pos_evens([3, 1, 2]) == [2]\nassert op_pos_evens([10]) == [10]\nassert op_pos_evens([2, 4, 6]) == [2, 4, 6]\nassert op_pos_evens([-7, 12, -7]) == [12]"}
{"id": "op_gt5_sorta", "entry_point": "op_gt5_sorta", "primitives": ["gt5", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending.", "solution": "def op_gt5_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_sorta([1, 2, 3, 4]) == []\nassert op_gt5_sorta([]) == []\nassert op_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta([5, 5, 5]) == []\nassert op_gt5_sorta([3, 1, 2]) == []\nassert op_gt5_sorta([10]) == [10]\nassert op_gt5_sorta([2, 4, 6]) == [6]\nassert op_gt5_sorta([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_inc", "entry_point": "op_dropzeros_inc", "primitives": ["dropzeros", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each.", "solution": "def op_dropzeros_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropzeros_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropzeros_inc([]) == []\nassert op_dropzeros_inc([-2, -1, 0, 1, 2]) == [-1, 0, 2, 3]\nassert op_dropzeros_inc([5, 5, 5]) == [6, 6, 6]\nassert op_dropzeros_inc([3, 1, 2]) == [4, 2, 3]\nassert op_dropzeros_inc([10]) == [11]\nassert op_dropzeros_inc([2, 4, 6]) == [3, 5, 7]\nassert op_dropzeros_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortalpha_strip", "entry_point": "op_sortalpha_strip", "primitives": ["sortalpha", "strip"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then trim whitespace from each.", "solution": "def op_sortalpha_strip(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_sortalpha_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_strip([]) == []\nassert op_sortalpha_strip(['  a ', '', 'BC', 'bc']) == ['', 'a', 'BC', 'bc']\nassert op_sortalpha_strip(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_strip(['x']) == ['x']\nassert op_sortalpha_strip(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_absval_rev", "entry_point": "op_absval_rev", "primitives": ["absval", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order.", "solution": "def op_absval_rev(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_absval_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_rev([]) == []\nassert op_absval_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_rev([5, 5, 5]) == [5, 5, 5]\nassert op_absval_rev([3, 1, 2]) == [2, 1, 3]\nassert op_absval_rev([10]) == [10]\nassert op_absval_rev([2, 4, 6]) == [6, 4, 2]\nassert op_absval_rev([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_last3_dropwhileneg", "entry_point": "op_last3_dropwhileneg", "primitives": ["last3", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values.", "solution": "def op_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_dropwhileneg([]) == []\nassert op_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_last3_dropwhileneg([10]) == [10]\nassert op_last3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_last3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_strip_counts", "entry_point": "op_strip_counts", "primitives": ["strip", "counts"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then return how many strings remain.", "solution": "def op_strip_counts(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    return len(r)", "tests": "assert op_strip_counts(['Hello', 'world']) == 2\nassert op_strip_counts([]) == 0\nassert op_strip_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_strip_counts(['one', 'one', 'Two']) == 3\nassert op_strip_counts(['x']) == 1\nassert op_strip_counts(['abc', 'de', '']) == 3"}
{"id": "op_dropfirst_sum", "entry_point": "op_dropfirst_sum", "primitives": ["dropfirst", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return their sum.", "solution": "def op_dropfirst_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    return sum(r)", "tests": "assert op_dropfirst_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_sum([]) == 0\nassert op_dropfirst_sum([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_sum([5, 5, 5]) == 10\nassert op_dropfirst_sum([3, 1, 2]) == 3\nassert op_dropfirst_sum([10]) == 0\nassert op_dropfirst_sum([2, 4, 6]) == 10\nassert op_dropfirst_sum([-7, 12, -7]) == 5"}
{"id": "op_neg_takewhilepos", "entry_point": "op_neg_takewhilepos", "primitives": ["neg", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive.", "solution": "def op_neg_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_neg_takewhilepos([]) == []\nassert op_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_neg_takewhilepos([5, 5, 5]) == []\nassert op_neg_takewhilepos([3, 1, 2]) == []\nassert op_neg_takewhilepos([10]) == []\nassert op_neg_takewhilepos([2, 4, 6]) == []\nassert op_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sorta_uniq", "entry_point": "op_sorta_uniq", "primitives": ["sorta", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence.", "solution": "def op_sorta_uniq(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sorta_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_uniq([]) == []\nassert op_sorta_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_uniq([5, 5, 5]) == [5]\nassert op_sorta_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_uniq([10]) == [10]\nassert op_sorta_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_neg_trimends", "entry_point": "op_neg_trimends", "primitives": ["neg", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements.", "solution": "def op_neg_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_neg_trimends([1, 2, 3, 4]) == []\nassert op_neg_trimends([]) == []\nassert op_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends([5, 5, 5]) == []\nassert op_neg_trimends([3, 1, 2]) == []\nassert op_neg_trimends([10]) == []\nassert op_neg_trimends([2, 4, 6]) == []\nassert op_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_ages_gt5", "entry_point": "op_ages_gt5", "primitives": ["ages", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep values greater than five.", "solution": "def op_ages_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_gt5([]) == []\nassert op_ages_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_gt5([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_square_negate", "entry_point": "op_square_negate", "primitives": ["square", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then negate each.", "solution": "def op_square_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_negate([]) == []\nassert op_square_negate([-2, -1, 0, 1, 2]) == [-4, -1, 0, -1, -4]\nassert op_square_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_square_negate([10]) == [-100]\nassert op_square_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_negate([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_last3_inc", "entry_point": "op_last3_inc", "primitives": ["last3", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each.", "solution": "def op_last3_inc(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_last3_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_last3_inc([]) == []\nassert op_last3_inc([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_last3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_last3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_last3_inc([10]) == [11]\nassert op_last3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_last3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropwhileneg_absval", "entry_point": "op_dropwhileneg_absval", "primitives": ["dropwhileneg", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each.", "solution": "def op_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_absval([]) == []\nassert op_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_absval([10]) == [10]\nassert op_dropwhileneg_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_odds_dec", "entry_point": "op_odds_dec", "primitives": ["odds", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each.", "solution": "def op_odds_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_odds_dec([1, 2, 3, 4]) == [0, 2]\nassert op_odds_dec([]) == []\nassert op_odds_dec([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_odds_dec([5, 5, 5]) == [4, 4, 4]\nassert op_odds_dec([3, 1, 2]) == [2, 0]\nassert op_odds_dec([10]) == []\nassert op_odds_dec([2, 4, 6]) == []\nassert op_odds_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_neg_inc", "entry_point": "op_neg_inc", "primitives": ["neg", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each.", "solution": "def op_neg_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_neg_inc([1, 2, 3, 4]) == []\nassert op_neg_inc([]) == []\nassert op_neg_inc([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_neg_inc([5, 5, 5]) == []\nassert op_neg_inc([3, 1, 2]) == []\nassert op_neg_inc([10]) == []\nassert op_neg_inc([2, 4, 6]) == []\nassert op_neg_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_rev_padto3", "entry_point": "op_rev_padto3", "primitives": ["rev", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements.", "solution": "def op_rev_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_padto3([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_padto3([]) == [0, 0, 0]\nassert op_rev_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_padto3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_padto3([10]) == [10, 0, 0]\nassert op_rev_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_gt5_alldistinct", "entry_point": "op_gt5_alldistinct", "primitives": ["gt5", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then return whether all values are distinct.", "solution": "def op_gt5_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    return len(r) == len(set(r))", "tests": "assert op_gt5_alldistinct([1, 2, 3, 4]) == True\nassert op_gt5_alldistinct([]) == True\nassert op_gt5_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_gt5_alldistinct([5, 5, 5]) == True\nassert op_gt5_alldistinct([3, 1, 2]) == True\nassert op_gt5_alldistinct([10]) == True\nassert op_gt5_alldistinct([2, 4, 6]) == True\nassert op_gt5_alldistinct([-7, 12, -7]) == True"}
{"id": "op_inc_first3", "entry_point": "op_inc_first3", "primitives": ["inc", "first3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three.", "solution": "def op_inc_first3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_inc_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_first3([]) == []\nassert op_inc_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_first3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_first3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_first3([10]) == [11]\nassert op_inc_first3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_first3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_absval_min", "entry_point": "op_absval_min", "primitives": ["absval", "min"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_absval_min(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_absval_min([1, 2, 3, 4]) == 1\nassert op_absval_min([]) == 0\nassert op_absval_min([-2, -1, 0, 1, 2]) == 0\nassert op_absval_min([5, 5, 5]) == 5\nassert op_absval_min([3, 1, 2]) == 1\nassert op_absval_min([10]) == 10\nassert op_absval_min([2, 4, 6]) == 2\nassert op_absval_min([-7, 12, -7]) == 7"}
{"id": "op_absval_firsteven", "entry_point": "op_absval_firsteven", "primitives": ["absval", "firsteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_absval_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_firsteven([]) == 0\nassert op_absval_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_firsteven([5, 5, 5]) == 0\nassert op_absval_firsteven([3, 1, 2]) == 2\nassert op_absval_firsteven([10]) == 10\nassert op_absval_firsteven([2, 4, 6]) == 2\nassert op_absval_firsteven([-7, 12, -7]) == 12"}
{"id": "op_odds_square", "entry_point": "op_odds_square", "primitives": ["odds", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each.", "solution": "def op_odds_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_odds_square([1, 2, 3, 4]) == [1, 9]\nassert op_odds_square([]) == []\nassert op_odds_square([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_square([5, 5, 5]) == [25, 25, 25]\nassert op_odds_square([3, 1, 2]) == [9, 1]\nassert op_odds_square([10]) == []\nassert op_odds_square([2, 4, 6]) == []\nassert op_odds_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_padto3_dropfirst", "entry_point": "op_padto3_dropfirst", "primitives": ["padto3", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element.", "solution": "def op_padto3_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_padto3_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_dropfirst([]) == [0, 0]\nassert op_padto3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_padto3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_padto3_dropfirst([10]) == [0, 0]\nassert op_padto3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_odds_haszero", "entry_point": "op_odds_haszero", "primitives": ["odds", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_odds_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_odds_haszero([1, 2, 3, 4]) == False\nassert op_odds_haszero([]) == False\nassert op_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_odds_haszero([5, 5, 5]) == False\nassert op_odds_haszero([3, 1, 2]) == False\nassert op_odds_haszero([10]) == False\nassert op_odds_haszero([2, 4, 6]) == False\nassert op_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_square_prod", "entry_point": "op_square_prod", "primitives": ["square", "prod"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then return their product.", "solution": "def op_square_prod(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_square_prod([1, 2, 3, 4]) == 576\nassert op_square_prod([]) == 1\nassert op_square_prod([-2, -1, 0, 1, 2]) == 0\nassert op_square_prod([5, 5, 5]) == 15625\nassert op_square_prod([3, 1, 2]) == 36\nassert op_square_prod([10]) == 100\nassert op_square_prod([2, 4, 6]) == 2304\nassert op_square_prod([-7, 12, -7]) == 345744"}
{"id": "op_uniqs_nonempty", "entry_point": "op_uniqs_nonempty", "primitives": ["uniqs", "nonempty"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop empty strings.", "solution": "def op_uniqs_nonempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if s]\n    return r", "tests": "assert op_uniqs_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_nonempty([]) == []\nassert op_uniqs_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ', 'BC', 'bc']\nassert op_uniqs_nonempty(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_nonempty(['x']) == ['x']\nassert op_uniqs_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_ages_alldistinct", "entry_point": "op_ages_alldistinct", "primitives": ["ages", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then return whether all values are distinct.", "solution": "def op_ages_alldistinct(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    return len(r) == len(set(r))", "tests": "assert op_ages_alldistinct([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_alldistinct([]) == True\nassert op_ages_alldistinct([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_alldistinct([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_ages_clamp10", "entry_point": "op_ages_clamp10", "primitives": ["ages", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10.", "solution": "def op_ages_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_clamp10([]) == []\nassert op_ages_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_inc_square", "entry_point": "op_inc_square", "primitives": ["inc", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each.", "solution": "def op_inc_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_square([1, 2, 3, 4]) == [4, 9, 16, 25]\nassert op_inc_square([]) == []\nassert op_inc_square([-2, -1, 0, 1, 2]) == [1, 0, 1, 4, 9]\nassert op_inc_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_square([3, 1, 2]) == [16, 4, 9]\nassert op_inc_square([10]) == [121]\nassert op_inc_square([2, 4, 6]) == [9, 25, 49]\nassert op_inc_square([-7, 12, -7]) == [36, 169, 36]"}
{"id": "op_beforezero_haszero", "entry_point": "op_beforezero_haszero", "primitives": ["beforezero", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return whether the list contains a zero.", "solution": "def op_beforezero_haszero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return 0 in r", "tests": "assert op_beforezero_haszero([1, 2, 3, 4]) == False\nassert op_beforezero_haszero([]) == False\nassert op_beforezero_haszero([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_haszero([5, 5, 5]) == False\nassert op_beforezero_haszero([3, 1, 2]) == False\nassert op_beforezero_haszero([10]) == False\nassert op_beforezero_haszero([2, 4, 6]) == False\nassert op_beforezero_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_clamp10", "entry_point": "op_padto3_clamp10", "primitives": ["padto3", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10.", "solution": "def op_padto3_clamp10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_padto3_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_clamp10([]) == [0, 0, 0]\nassert op_padto3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_clamp10([10]) == [10, 0, 0]\nassert op_padto3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_absval_dropzeros", "entry_point": "op_absval_dropzeros", "primitives": ["absval", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros.", "solution": "def op_absval_dropzeros(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_absval_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_dropzeros([]) == []\nassert op_absval_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_absval_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_absval_dropzeros([10]) == [10]\nassert op_absval_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_absval_dropzeros([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_inc_dropfirst", "entry_point": "op_inc_dropfirst", "primitives": ["inc", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first element.", "solution": "def op_inc_dropfirst(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_inc_dropfirst([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_dropfirst([]) == []\nassert op_inc_dropfirst([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_inc_dropfirst([5, 5, 5]) == [6, 6]\nassert op_inc_dropfirst([3, 1, 2]) == [2, 3]\nassert op_inc_dropfirst([10]) == []\nassert op_inc_dropfirst([2, 4, 6]) == [5, 7]\nassert op_inc_dropfirst([-7, 12, -7]) == [13, -6]"}
{"id": "op_odds_dropfirst", "entry_point": "op_odds_dropfirst", "primitives": ["odds", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element.", "solution": "def op_odds_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_odds_dropfirst([1, 2, 3, 4]) == [3]\nassert op_odds_dropfirst([]) == []\nassert op_odds_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_odds_dropfirst([3, 1, 2]) == [1]\nassert op_odds_dropfirst([10]) == []\nassert op_odds_dropfirst([2, 4, 6]) == []\nassert op_odds_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_neg_padto3", "entry_point": "op_neg_padto3", "primitives": ["neg", "padto3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_neg_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_padto3([]) == [0, 0, 0]\nassert op_neg_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_padto3([10]) == [0, 0, 0]\nassert op_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_padto3_negate", "entry_point": "op_padto3_negate", "primitives": ["padto3", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then negate each.", "solution": "def op_padto3_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_padto3_negate([]) == [0, 0, 0]\nassert op_padto3_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_negate([10]) == [-10, 0, 0]\nassert op_padto3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_takewhilepos_beforezero", "entry_point": "op_takewhilepos_beforezero", "primitives": ["takewhilepos", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero.", "solution": "def op_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_takewhilepos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_beforezero([]) == []\nassert op_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_beforezero([10]) == [10]\nassert op_takewhilepos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_beforezero([-7, 12, -7]) == []"}
{"id": "op_beforezero_oremptyzero", "entry_point": "op_beforezero_oremptyzero", "primitives": ["beforezero", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_beforezero_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_oremptyzero([]) == [0]\nassert op_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_oremptyzero([10]) == [10]\nassert op_beforezero_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_pos_uniq", "entry_point": "op_pos_uniq", "primitives": ["pos", "uniq"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence.", "solution": "def op_pos_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_uniq([]) == []\nassert op_pos_uniq([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_uniq([5, 5, 5]) == [5]\nassert op_pos_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_pos_uniq([10]) == [10]\nassert op_pos_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_pos_uniq([-7, 12, -7]) == [12]"}
{"id": "op_sorta_negate", "entry_point": "op_sorta_negate", "primitives": ["sorta", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each.", "solution": "def op_sorta_negate(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_sorta_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_negate([]) == []\nassert op_sorta_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_negate([10]) == [-10]\nassert op_sorta_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_dec_len", "entry_point": "op_dec_len", "primitives": ["dec", "len"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then return how many remain.", "solution": "def op_dec_len(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    return len(r)", "tests": "assert op_dec_len([1, 2, 3, 4]) == 4\nassert op_dec_len([]) == 0\nassert op_dec_len([-2, -1, 0, 1, 2]) == 5\nassert op_dec_len([5, 5, 5]) == 3\nassert op_dec_len([3, 1, 2]) == 3\nassert op_dec_len([10]) == 1\nassert op_dec_len([2, 4, 6]) == 3\nassert op_dec_len([-7, 12, -7]) == 3"}
{"id": "op_square_dec", "entry_point": "op_square_dec", "primitives": ["square", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each.", "solution": "def op_square_dec(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_square_dec([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_square_dec([]) == []\nassert op_square_dec([-2, -1, 0, 1, 2]) == [3, 0, -1, 0, 3]\nassert op_square_dec([5, 5, 5]) == [24, 24, 24]\nassert op_square_dec([3, 1, 2]) == [8, 0, 3]\nassert op_square_dec([10]) == [99]\nassert op_square_dec([2, 4, 6]) == [3, 15, 35]\nassert op_square_dec([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_neg_negate", "entry_point": "op_neg_negate", "primitives": ["neg", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each.", "solution": "def op_neg_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_negate([1, 2, 3, 4]) == []\nassert op_neg_negate([]) == []\nassert op_neg_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_negate([5, 5, 5]) == []\nassert op_neg_negate([3, 1, 2]) == []\nassert op_neg_negate([10]) == []\nassert op_neg_negate([2, 4, 6]) == []\nassert op_neg_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_last3_dec", "entry_point": "op_last3_dec", "primitives": ["last3", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each.", "solution": "def op_last3_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_dec([]) == []\nassert op_last3_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_last3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_last3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_last3_dec([10]) == [9]\nassert op_last3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_last3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_names_sortlen", "entry_point": "op_names_sortlen", "primitives": ["names", "sortlen"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort by length, shortest first.", "solution": "def op_names_sortlen(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_names_sortlen([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Bo', 'Ada']\nassert op_names_sortlen([]) == []\nassert op_names_sortlen([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'El', 'Dee']\nassert op_names_sortlen([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_negate_beforezero", "entry_point": "op_negate_beforezero", "primitives": ["negate", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero.", "solution": "def op_negate_beforezero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_negate_beforezero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_beforezero([]) == []\nassert op_negate_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_beforezero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_beforezero([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_beforezero([10]) == [-10]\nassert op_negate_beforezero([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_beforezero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_uniqs_lens", "entry_point": "op_uniqs_lens", "primitives": ["uniqs", "lens"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then return the total number of characters.", "solution": "def op_uniqs_lens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return sum(len(s) for s in r)", "tests": "assert op_uniqs_lens(['Hello', 'world']) == 10\nassert op_uniqs_lens([]) == 0\nassert op_uniqs_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_uniqs_lens(['one', 'one', 'Two']) == 6\nassert op_uniqs_lens(['x']) == 1\nassert op_uniqs_lens(['abc', 'de', '']) == 5"}
{"id": "op_sorta_sortd", "entry_point": "op_sorta_sortd", "primitives": ["sorta", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending.", "solution": "def op_sorta_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_sortd([]) == []\nassert op_sorta_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_sortd([10]) == [10]\nassert op_sorta_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_square_counteven", "entry_point": "op_square_counteven", "primitives": ["square", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then return how many values are even.", "solution": "def op_square_counteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_square_counteven([1, 2, 3, 4]) == 2\nassert op_square_counteven([]) == 0\nassert op_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_square_counteven([5, 5, 5]) == 0\nassert op_square_counteven([3, 1, 2]) == 1\nassert op_square_counteven([10]) == 1\nassert op_square_counteven([2, 4, 6]) == 3\nassert op_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_uniq_issorted", "entry_point": "op_uniq_issorted", "primitives": ["uniq", "issorted"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_uniq_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_uniq_issorted([1, 2, 3, 4]) == True\nassert op_uniq_issorted([]) == True\nassert op_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_issorted([5, 5, 5]) == True\nassert op_uniq_issorted([3, 1, 2]) == False\nassert op_uniq_issorted([10]) == True\nassert op_uniq_issorted([2, 4, 6]) == True\nassert op_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_evens_allpos", "entry_point": "op_evens_allpos", "primitives": ["evens", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then return whether all values are positive.", "solution": "def op_evens_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_allpos([1, 2, 3, 4]) == True\nassert op_evens_allpos([]) == True\nassert op_evens_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_allpos([5, 5, 5]) == True\nassert op_evens_allpos([3, 1, 2]) == True\nassert op_evens_allpos([10]) == True\nassert op_evens_allpos([2, 4, 6]) == True\nassert op_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_sortd_max", "entry_point": "op_sortd_max", "primitives": ["sortd", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then return the maximum (0 if empty).", "solution": "def op_sortd_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    return max(r) if r else 0", "tests": "assert op_sortd_max([1, 2, 3, 4]) == 4\nassert op_sortd_max([]) == 0\nassert op_sortd_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_max([5, 5, 5]) == 5\nassert op_sortd_max([3, 1, 2]) == 3\nassert op_sortd_max([10]) == 10\nassert op_sortd_max([2, 4, 6]) == 6\nassert op_sortd_max([-7, 12, -7]) == 12"}
{"id": "op_absval_beforezero", "entry_point": "op_absval_beforezero", "primitives": ["absval", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero.", "solution": "def op_absval_beforezero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_absval_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_beforezero([]) == []\nassert op_absval_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_absval_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_absval_beforezero([10]) == [10]\nassert op_absval_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_absval_beforezero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_lower_lens", "entry_point": "op_lower_lens", "primitives": ["lower", "lens"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then return the total number of characters.", "solution": "def op_lower_lens(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_lower_lens(['Hello', 'world']) == 10\nassert op_lower_lens([]) == 0\nassert op_lower_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_lower_lens(['one', 'one', 'Two']) == 9\nassert op_lower_lens(['x']) == 1\nassert op_lower_lens(['abc', 'de', '']) == 5"}
{"id": "op_dropshort_longest", "entry_point": "op_dropshort_longest", "primitives": ["dropshort", "longest"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then return the longest string (empty if none).", "solution": "def op_dropshort_longest(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    return max(r, key=len) if r else ''", "tests": "assert op_dropshort_longest(['Hello', 'world']) == 'Hello'\nassert op_dropshort_longest([]) == ''\nassert op_dropshort_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_dropshort_longest(['one', 'one', 'Two']) == 'one'\nassert op_dropshort_longest(['x']) == ''\nassert op_dropshort_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_oremptyzero_sum", "entry_point": "op_oremptyzero_sum", "primitives": ["oremptyzero", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return their sum.", "solution": "def op_oremptyzero_sum(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_oremptyzero_sum([]) == 0\nassert op_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_sum([5, 5, 5]) == 15\nassert op_oremptyzero_sum([3, 1, 2]) == 6\nassert op_oremptyzero_sum([10]) == 10\nassert op_oremptyzero_sum([2, 4, 6]) == 12\nassert op_oremptyzero_sum([-7, 12, -7]) == -2"}
{"id": "op_add10_sorta", "entry_point": "op_add10_sorta", "primitives": ["add10", "sorta"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending.", "solution": "def op_add10_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_add10_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_sorta([]) == []\nassert op_add10_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_sorta([10]) == [20]\nassert op_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_square_alldistinct", "entry_point": "op_square_alldistinct", "primitives": ["square", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then return whether all values are distinct.", "solution": "def op_square_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_square_alldistinct([1, 2, 3, 4]) == True\nassert op_square_alldistinct([]) == True\nassert op_square_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_square_alldistinct([5, 5, 5]) == False\nassert op_square_alldistinct([3, 1, 2]) == True\nassert op_square_alldistinct([10]) == True\nassert op_square_alldistinct([2, 4, 6]) == True\nassert op_square_alldistinct([-7, 12, -7]) == False"}
{"id": "op_ages_add10", "entry_point": "op_ages_add10", "primitives": ["ages", "add10"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each.", "solution": "def op_ages_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_add10([]) == []\nassert op_ages_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_clamp10_gt5", "entry_point": "op_clamp10_gt5", "primitives": ["clamp10", "gt5"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five.", "solution": "def op_clamp10_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_gt5([]) == []\nassert op_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_gt5([5, 5, 5]) == []\nassert op_clamp10_gt5([3, 1, 2]) == []\nassert op_clamp10_gt5([10]) == [10]\nassert op_clamp10_gt5([2, 4, 6]) == [6]\nassert op_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_double_absval", "entry_point": "op_double_absval", "primitives": ["double", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each.", "solution": "def op_double_absval(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_double_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_absval([]) == []\nassert op_double_absval([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_double_absval([5, 5, 5]) == [10, 10, 10]\nassert op_double_absval([3, 1, 2]) == [6, 2, 4]\nassert op_double_absval([10]) == [20]\nassert op_double_absval([2, 4, 6]) == [4, 8, 12]\nassert op_double_absval([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_nonempty_lens", "entry_point": "op_nonempty_lens", "primitives": ["nonempty", "lens"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then return the total number of characters.", "solution": "def op_nonempty_lens(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    return sum(len(s) for s in r)", "tests": "assert op_nonempty_lens(['Hello', 'world']) == 10\nassert op_nonempty_lens([]) == 0\nassert op_nonempty_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_nonempty_lens(['one', 'one', 'Two']) == 9\nassert op_nonempty_lens(['x']) == 1\nassert op_nonempty_lens(['abc', 'de', '']) == 5"}
{"id": "op_ages_neg", "entry_point": "op_ages_neg", "primitives": ["ages", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers.", "solution": "def op_ages_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg([]) == []\nassert op_ages_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_add10_last3", "entry_point": "op_add10_last3", "primitives": ["add10", "last3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three.", "solution": "def op_add10_last3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_add10_last3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_last3([]) == []\nassert op_add10_last3([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_add10_last3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_last3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_last3([10]) == [20]\nassert op_add10_last3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_last3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_trimends_sum", "entry_point": "op_trimends_sum", "primitives": ["trimends", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then return their sum.", "solution": "def op_trimends_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    return sum(r)", "tests": "assert op_trimends_sum([1, 2, 3, 4]) == 5\nassert op_trimends_sum([]) == 0\nassert op_trimends_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_sum([5, 5, 5]) == 5\nassert op_trimends_sum([3, 1, 2]) == 1\nassert op_trimends_sum([10]) == 0\nassert op_trimends_sum([2, 4, 6]) == 4\nassert op_trimends_sum([-7, 12, -7]) == 12"}
{"id": "op_first3_neg", "entry_point": "op_first3_neg", "primitives": ["first3", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers.", "solution": "def op_first3_neg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_first3_neg([1, 2, 3, 4]) == []\nassert op_first3_neg([]) == []\nassert op_first3_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_neg([5, 5, 5]) == []\nassert op_first3_neg([3, 1, 2]) == []\nassert op_first3_neg([10]) == []\nassert op_first3_neg([2, 4, 6]) == []\nassert op_first3_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero_pos", "entry_point": "op_oremptyzero_pos", "primitives": ["oremptyzero", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers.", "solution": "def op_oremptyzero_pos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_oremptyzero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_pos([]) == []\nassert op_oremptyzero_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_pos([10]) == [10]\nassert op_oremptyzero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_allpos", "entry_point": "op_sortabs_allpos", "primitives": ["sortabs", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then return whether all values are positive.", "solution": "def op_sortabs_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_allpos([]) == True\nassert op_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_allpos([5, 5, 5]) == True\nassert op_sortabs_allpos([3, 1, 2]) == True\nassert op_sortabs_allpos([10]) == True\nassert op_sortabs_allpos([2, 4, 6]) == True\nassert op_sortabs_allpos([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_sortabs", "entry_point": "op_oremptyzero_sortabs", "primitives": ["oremptyzero", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value.", "solution": "def op_oremptyzero_sortabs(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_oremptyzero_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sortabs([]) == [0]\nassert op_oremptyzero_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_oremptyzero_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sortabs([10]) == [10]\nassert op_oremptyzero_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sorta_evens", "entry_point": "op_sorta_evens", "primitives": ["sorta", "evens"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers.", "solution": "def op_sorta_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_evens([]) == []\nassert op_sorta_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_sorta_evens([5, 5, 5]) == []\nassert op_sorta_evens([3, 1, 2]) == [2]\nassert op_sorta_evens([10]) == [10]\nassert op_sorta_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortd_pos", "entry_point": "op_sortd_pos", "primitives": ["sortd", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers.", "solution": "def op_sortd_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_pos([]) == []\nassert op_sortd_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_pos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_pos([10]) == [10]\nassert op_sortd_pos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_pos([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_neg", "entry_point": "op_takewhilepos_neg", "primitives": ["takewhilepos", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers.", "solution": "def op_takewhilepos_neg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_takewhilepos_neg([1, 2, 3, 4]) == []\nassert op_takewhilepos_neg([]) == []\nassert op_takewhilepos_neg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_neg([5, 5, 5]) == []\nassert op_takewhilepos_neg([3, 1, 2]) == []\nassert op_takewhilepos_neg([10]) == []\nassert op_takewhilepos_neg([2, 4, 6]) == []\nassert op_takewhilepos_neg([-7, 12, -7]) == []"}
{"id": "op_first3_double", "entry_point": "op_first3_double", "primitives": ["first3", "double"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each.", "solution": "def op_first3_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_double([]) == []\nassert op_first3_double([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_first3_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_double([3, 1, 2]) == [6, 2, 4]\nassert op_first3_double([10]) == [20]\nassert op_first3_double([2, 4, 6]) == [4, 8, 12]\nassert op_first3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_takewhilepos_absval", "entry_point": "op_takewhilepos_absval", "primitives": ["takewhilepos", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each.", "solution": "def op_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_absval([]) == []\nassert op_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_absval([10]) == [10]\nassert op_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_div3_clamp10", "entry_point": "op_div3_clamp10", "primitives": ["div3", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10.", "solution": "def op_div3_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_div3_clamp10([]) == []\nassert op_div3_clamp10([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_clamp10([5, 5, 5]) == []\nassert op_div3_clamp10([3, 1, 2]) == [3]\nassert op_div3_clamp10([10]) == []\nassert op_div3_clamp10([2, 4, 6]) == [6]\nassert op_div3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_dropwhileneg_pos", "entry_point": "op_dropwhileneg_pos", "primitives": ["dropwhileneg", "pos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the positive numbers.", "solution": "def op_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropwhileneg_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_pos([]) == []\nassert op_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_pos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_pos([10]) == [10]\nassert op_dropwhileneg_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_pos([-7, 12, -7]) == [12]"}
{"id": "op_names_anyempty", "entry_point": "op_names_anyempty", "primitives": ["names", "anyempty"], "difficulty": 1, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then return whether any string is empty.", "solution": "def op_names_anyempty(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    return any(s == '' for s in r)", "tests": "assert op_names_anyempty([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_names_anyempty([]) == False\nassert op_names_anyempty([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_names_anyempty([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_odds_counteven", "entry_point": "op_odds_counteven", "primitives": ["odds", "counteven"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then return how many values are even.", "solution": "def op_odds_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_odds_counteven([1, 2, 3, 4]) == 0\nassert op_odds_counteven([]) == 0\nassert op_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_counteven([5, 5, 5]) == 0\nassert op_odds_counteven([3, 1, 2]) == 0\nassert op_odds_counteven([10]) == 0\nassert op_odds_counteven([2, 4, 6]) == 0\nassert op_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_dec_dropzeros", "entry_point": "op_dec_dropzeros", "primitives": ["dec", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros.", "solution": "def op_dec_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropzeros([]) == []\nassert op_dec_dropzeros([-2, -1, 0, 1, 2]) == [-3, -2, -1, 1]\nassert op_dec_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dec_dropzeros([10]) == [9]\nassert op_dec_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_inc_dropzeros", "entry_point": "op_inc_dropzeros", "primitives": ["inc", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros.", "solution": "def op_inc_dropzeros(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_inc_dropzeros([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_dropzeros([]) == []\nassert op_inc_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, 2, 3]\nassert op_inc_dropzeros([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropzeros([3, 1, 2]) == [4, 2, 3]\nassert op_inc_dropzeros([10]) == [11]\nassert op_inc_dropzeros([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropzeros([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_double_trimends", "entry_point": "op_double_trimends", "primitives": ["double", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements.", "solution": "def op_double_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_double_trimends([]) == []\nassert op_double_trimends([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_double_trimends([5, 5, 5]) == [10]\nassert op_double_trimends([3, 1, 2]) == [2]\nassert op_double_trimends([10]) == []\nassert op_double_trimends([2, 4, 6]) == [8]\nassert op_double_trimends([-7, 12, -7]) == [24]"}
{"id": "op_neg_sortabs", "entry_point": "op_neg_sortabs", "primitives": ["neg", "sortabs"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value.", "solution": "def op_neg_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_sortabs([1, 2, 3, 4]) == []\nassert op_neg_sortabs([]) == []\nassert op_neg_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_sortabs([5, 5, 5]) == []\nassert op_neg_sortabs([3, 1, 2]) == []\nassert op_neg_sortabs([10]) == []\nassert op_neg_sortabs([2, 4, 6]) == []\nassert op_neg_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_gt5_oremptyzero", "entry_point": "op_gt5_oremptyzero", "primitives": ["gt5", "oremptyzero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero.", "solution": "def op_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_oremptyzero([]) == [0]\nassert op_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_oremptyzero([10]) == [10]\nassert op_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_uniq_sortd", "entry_point": "op_uniq_sortd", "primitives": ["uniq", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_uniq_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_sortd([]) == []\nassert op_uniq_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_sortd([5, 5, 5]) == [5]\nassert op_uniq_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_sortd([10]) == [10]\nassert op_uniq_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_dropwhileneg", "entry_point": "op_padto3_dropwhileneg", "primitives": ["padto3", "dropwhileneg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_dropwhileneg([10]) == [10, 0, 0]\nassert op_padto3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_odds_takewhilepos", "entry_point": "op_odds_takewhilepos", "primitives": ["odds", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take values while they are positive.", "solution": "def op_odds_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_odds_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_takewhilepos([]) == []\nassert op_odds_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_odds_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_odds_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_odds_takewhilepos([10]) == []\nassert op_odds_takewhilepos([2, 4, 6]) == []\nassert op_odds_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_absval_last3", "entry_point": "op_absval_last3", "primitives": ["absval", "last3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three.", "solution": "def op_absval_last3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_absval_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_last3([]) == []\nassert op_absval_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_last3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_last3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_last3([10]) == [10]\nassert op_absval_last3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_last3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_absval_takewhilepos", "entry_point": "op_absval_takewhilepos", "primitives": ["absval", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive.", "solution": "def op_absval_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos([]) == []\nassert op_absval_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_absval_takewhilepos([10]) == [10]\nassert op_absval_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_absval_sum", "entry_point": "op_absval_sum", "primitives": ["absval", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then return their sum.", "solution": "def op_absval_sum(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_absval_sum([1, 2, 3, 4]) == 10\nassert op_absval_sum([]) == 0\nassert op_absval_sum([-2, -1, 0, 1, 2]) == 6\nassert op_absval_sum([5, 5, 5]) == 15\nassert op_absval_sum([3, 1, 2]) == 6\nassert op_absval_sum([10]) == 10\nassert op_absval_sum([2, 4, 6]) == 12\nassert op_absval_sum([-7, 12, -7]) == 26"}
{"id": "op_first3_haszero", "entry_point": "op_first3_haszero", "primitives": ["first3", "haszero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return whether the list contains a zero.", "solution": "def op_first3_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    return 0 in r", "tests": "assert op_first3_haszero([1, 2, 3, 4]) == False\nassert op_first3_haszero([]) == False\nassert op_first3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_first3_haszero([5, 5, 5]) == False\nassert op_first3_haszero([3, 1, 2]) == False\nassert op_first3_haszero([10]) == False\nassert op_first3_haszero([2, 4, 6]) == False\nassert op_first3_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_clamp10", "entry_point": "op_sortd_clamp10", "primitives": ["sortd", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10.", "solution": "def op_sortd_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortd_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_clamp10([]) == []\nassert op_sortd_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_clamp10([10]) == [10]\nassert op_sortd_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_clamp10([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_beforezero_allpos", "entry_point": "op_beforezero_allpos", "primitives": ["beforezero", "allpos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then return whether all values are positive.", "solution": "def op_beforezero_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_allpos([]) == True\nassert op_beforezero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_allpos([5, 5, 5]) == True\nassert op_beforezero_allpos([3, 1, 2]) == True\nassert op_beforezero_allpos([10]) == True\nassert op_beforezero_allpos([2, 4, 6]) == True\nassert op_beforezero_allpos([-7, 12, -7]) == False"}
{"id": "op_clamp10_absval", "entry_point": "op_clamp10_absval", "primitives": ["clamp10", "absval"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each.", "solution": "def op_clamp10_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_absval([]) == []\nassert op_clamp10_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_absval([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_absval([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_absval([10]) == [10]\nassert op_clamp10_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_div3_neg", "entry_point": "op_div3_neg", "primitives": ["div3", "neg"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers.", "solution": "def op_div3_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_div3_neg([1, 2, 3, 4]) == []\nassert op_div3_neg([]) == []\nassert op_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_div3_neg([5, 5, 5]) == []\nassert op_div3_neg([3, 1, 2]) == []\nassert op_div3_neg([10]) == []\nassert op_div3_neg([2, 4, 6]) == []\nassert op_div3_neg([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_alldistinct", "entry_point": "op_oremptyzero_alldistinct", "primitives": ["oremptyzero", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return whether all values are distinct.", "solution": "def op_oremptyzero_alldistinct(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return len(r) == len(set(r))", "tests": "assert op_oremptyzero_alldistinct([1, 2, 3, 4]) == True\nassert op_oremptyzero_alldistinct([]) == True\nassert op_oremptyzero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_alldistinct([5, 5, 5]) == False\nassert op_oremptyzero_alldistinct([3, 1, 2]) == True\nassert op_oremptyzero_alldistinct([10]) == True\nassert op_oremptyzero_alldistinct([2, 4, 6]) == True\nassert op_oremptyzero_alldistinct([-7, 12, -7]) == False"}
{"id": "op_double_takewhilepos", "entry_point": "op_double_takewhilepos", "primitives": ["double", "takewhilepos"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive.", "solution": "def op_double_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_takewhilepos([]) == []\nassert op_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_double_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_takewhilepos([10]) == [20]\nassert op_double_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_trimends_inc", "entry_point": "op_trimends_inc", "primitives": ["trimends", "inc"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each.", "solution": "def op_trimends_inc(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_trimends_inc([1, 2, 3, 4]) == [3, 4]\nassert op_trimends_inc([]) == []\nassert op_trimends_inc([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_trimends_inc([5, 5, 5]) == [6]\nassert op_trimends_inc([3, 1, 2]) == [2]\nassert op_trimends_inc([10]) == []\nassert op_trimends_inc([2, 4, 6]) == [5]\nassert op_trimends_inc([-7, 12, -7]) == [13]"}
{"id": "op_first3_beforezero", "entry_point": "op_first3_beforezero", "primitives": ["first3", "beforezero"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep everything before the first zero.", "solution": "def op_first3_beforezero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_first3_beforezero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_beforezero([]) == []\nassert op_first3_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_beforezero([10]) == [10]\nassert op_first3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_oremptyzero_max", "entry_point": "op_oremptyzero_max", "primitives": ["oremptyzero", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_oremptyzero_max(xs):\n    r = list(xs)\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_oremptyzero_max([]) == 0\nassert op_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_max([5, 5, 5]) == 5\nassert op_oremptyzero_max([3, 1, 2]) == 3\nassert op_oremptyzero_max([10]) == 10\nassert op_oremptyzero_max([2, 4, 6]) == 6\nassert op_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_dropfirst", "entry_point": "op_dropwhileneg_dropfirst", "primitives": ["dropwhileneg", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element.", "solution": "def op_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_dropwhileneg_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_dropfirst([]) == []\nassert op_dropwhileneg_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst([10]) == []\nassert op_dropwhileneg_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropwhileneg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_rev", "entry_point": "op_padto3_rev", "primitives": ["padto3", "rev"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order.", "solution": "def op_padto3_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_rev([]) == [0, 0, 0]\nassert op_padto3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_rev([10]) == [0, 0, 10]\nassert op_padto3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_sum", "entry_point": "op_rev_sum", "primitives": ["rev", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then return their sum.", "solution": "def op_rev_sum(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    return sum(r)", "tests": "assert op_rev_sum([1, 2, 3, 4]) == 10\nassert op_rev_sum([]) == 0\nassert op_rev_sum([-2, -1, 0, 1, 2]) == 0\nassert op_rev_sum([5, 5, 5]) == 15\nassert op_rev_sum([3, 1, 2]) == 6\nassert op_rev_sum([10]) == 10\nassert op_rev_sum([2, 4, 6]) == 12\nassert op_rev_sum([-7, 12, -7]) == -2"}
{"id": "op_dropwhileneg_odds", "entry_point": "op_dropwhileneg_odds", "primitives": ["dropwhileneg", "odds"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers.", "solution": "def op_dropwhileneg_odds(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropwhileneg_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropwhileneg_odds([]) == []\nassert op_dropwhileneg_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_odds([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_odds([3, 1, 2]) == [3, 1]\nassert op_dropwhileneg_odds([10]) == []\nassert op_dropwhileneg_odds([2, 4, 6]) == []\nassert op_dropwhileneg_odds([-7, 12, -7]) == [-7]"}
{"id": "op_lower_strip", "entry_point": "op_lower_strip", "primitives": ["lower", "strip"], "difficulty": 1, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then trim whitespace from each.", "solution": "def op_lower_strip(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_lower_strip(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_strip([]) == []\nassert op_lower_strip(['  a ', '', 'BC', 'bc']) == ['a', '', 'bc', 'bc']\nassert op_lower_strip(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_strip(['x']) == ['x']\nassert op_lower_strip(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_dropwhileneg_clamp10", "entry_point": "op_dropwhileneg_clamp10", "primitives": ["dropwhileneg", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10.", "solution": "def op_dropwhileneg_clamp10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropwhileneg_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_clamp10([]) == []\nassert op_dropwhileneg_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_clamp10([10]) == [10]\nassert op_dropwhileneg_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_clamp10([-7, 12, -7]) == [10, -7]"}
{"id": "op_inc_clamp10", "entry_point": "op_inc_clamp10", "primitives": ["inc", "clamp10"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10.", "solution": "def op_inc_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_clamp10([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_clamp10([]) == []\nassert op_inc_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_clamp10([5, 5, 5]) == [6, 6, 6]\nassert op_inc_clamp10([3, 1, 2]) == [4, 2, 3]\nassert op_inc_clamp10([10]) == [10]\nassert op_inc_clamp10([2, 4, 6]) == [3, 5, 7]\nassert op_inc_clamp10([-7, 12, -7]) == [-6, 10, -6]"}
{"id": "op_first3_alldistinct", "entry_point": "op_first3_alldistinct", "primitives": ["first3", "alldistinct"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then return whether all values are distinct.", "solution": "def op_first3_alldistinct(xs):\n    r = list(xs)\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_first3_alldistinct([]) == True\nassert op_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_first3_alldistinct([5, 5, 5]) == False\nassert op_first3_alldistinct([3, 1, 2]) == True\nassert op_first3_alldistinct([10]) == True\nassert op_first3_alldistinct([2, 4, 6]) == True\nassert op_first3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_last3", "entry_point": "op_dropwhileneg_last3", "primitives": ["dropwhileneg", "last3"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three.", "solution": "def op_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_last3([]) == []\nassert op_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_last3([10]) == [10]\nassert op_dropwhileneg_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_max", "entry_point": "op_dropfirst_max", "primitives": ["dropfirst", "max"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then return the maximum (0 if empty).", "solution": "def op_dropfirst_max(xs):\n    r = list(xs)\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_dropfirst_max([1, 2, 3, 4]) == 4\nassert op_dropfirst_max([]) == 0\nassert op_dropfirst_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_max([5, 5, 5]) == 5\nassert op_dropfirst_max([3, 1, 2]) == 2\nassert op_dropfirst_max([10]) == 0\nassert op_dropfirst_max([2, 4, 6]) == 6\nassert op_dropfirst_max([-7, 12, -7]) == 12"}
{"id": "op_square_trimends", "entry_point": "op_square_trimends", "primitives": ["square", "trimends"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first and last elements.", "solution": "def op_square_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_square_trimends([1, 2, 3, 4]) == [4, 9]\nassert op_square_trimends([]) == []\nassert op_square_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_square_trimends([5, 5, 5]) == [25]\nassert op_square_trimends([3, 1, 2]) == [1]\nassert op_square_trimends([10]) == []\nassert op_square_trimends([2, 4, 6]) == [16]\nassert op_square_trimends([-7, 12, -7]) == [144]"}
{"id": "op_add10_sum", "entry_point": "op_add10_sum", "primitives": ["add10", "sum"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then return their sum.", "solution": "def op_add10_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_add10_sum([1, 2, 3, 4]) == 50\nassert op_add10_sum([]) == 0\nassert op_add10_sum([-2, -1, 0, 1, 2]) == 50\nassert op_add10_sum([5, 5, 5]) == 45\nassert op_add10_sum([3, 1, 2]) == 36\nassert op_add10_sum([10]) == 20\nassert op_add10_sum([2, 4, 6]) == 42\nassert op_add10_sum([-7, 12, -7]) == 28"}
{"id": "op_dropzeros_dropfirst", "entry_point": "op_dropzeros_dropfirst", "primitives": ["dropzeros", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element.", "solution": "def op_dropzeros_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropfirst([]) == []\nassert op_dropzeros_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropzeros_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst([10]) == []\nassert op_dropzeros_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_clamp10_dropfirst", "entry_point": "op_clamp10_dropfirst", "primitives": ["clamp10", "dropfirst"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element.", "solution": "def op_clamp10_dropfirst(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_clamp10_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_dropfirst([]) == []\nassert op_clamp10_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_clamp10_dropfirst([5, 5, 5]) == [5, 5]\nassert op_clamp10_dropfirst([3, 1, 2]) == [1, 2]\nassert op_clamp10_dropfirst([10]) == []\nassert op_clamp10_dropfirst([2, 4, 6]) == [4, 6]\nassert op_clamp10_dropfirst([-7, 12, -7]) == [10, -7]"}
{"id": "op_double_square", "entry_point": "op_double_square", "primitives": ["double", "square"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then square each.", "solution": "def op_double_square(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_double_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_double_square([]) == []\nassert op_double_square([-2, -1, 0, 1, 2]) == [16, 4, 0, 4, 16]\nassert op_double_square([5, 5, 5]) == [100, 100, 100]\nassert op_double_square([3, 1, 2]) == [36, 4, 16]\nassert op_double_square([10]) == [400]\nassert op_double_square([2, 4, 6]) == [16, 64, 144]\nassert op_double_square([-7, 12, -7]) == [196, 576, 196]"}
{"id": "op_double_dropzeros", "entry_point": "op_double_dropzeros", "primitives": ["double", "dropzeros"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros.", "solution": "def op_double_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropzeros([]) == []\nassert op_double_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_double_dropzeros([10]) == [20]\nassert op_double_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_trimends_sortd", "entry_point": "op_trimends_sortd", "primitives": ["trimends", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending.", "solution": "def op_trimends_sortd(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_trimends_sortd([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_sortd([]) == []\nassert op_trimends_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_sortd([5, 5, 5]) == [5]\nassert op_trimends_sortd([3, 1, 2]) == [1]\nassert op_trimends_sortd([10]) == []\nassert op_trimends_sortd([2, 4, 6]) == [4]\nassert op_trimends_sortd([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_dec", "entry_point": "op_dropwhileneg_dec", "primitives": ["dropwhileneg", "dec"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then subtract one from each.", "solution": "def op_dropwhileneg_dec(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropwhileneg_dec([]) == []\nassert op_dropwhileneg_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dropwhileneg_dec([5, 5, 5]) == [4, 4, 4]\nassert op_dropwhileneg_dec([3, 1, 2]) == [2, 0, 1]\nassert op_dropwhileneg_dec([10]) == [9]\nassert op_dropwhileneg_dec([2, 4, 6]) == [1, 3, 5]\nassert op_dropwhileneg_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_dec_sortd", "entry_point": "op_dec_sortd", "primitives": ["dec", "sortd"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort descending.", "solution": "def op_dec_sortd(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dec_sortd([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_sortd([]) == []\nassert op_dec_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_dec_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortd([3, 1, 2]) == [2, 1, 0]\nassert op_dec_sortd([10]) == [9]\nassert op_dec_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_dec_sortd([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_sortd_negate", "entry_point": "op_sortd_negate", "primitives": ["sortd", "negate"], "difficulty": 1, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then negate each.", "solution": "def op_sortd_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sortd_negate([]) == []\nassert op_sortd_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortd_negate([3, 1, 2]) == [-3, -2, -1]\nassert op_sortd_negate([10]) == [-10]\nassert op_sortd_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_sortd_negate([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_first3_uniq_div3", "entry_point": "op_first3_uniq_div3", "primitives": ["first3", "uniq", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then keep multiples of three.", "solution": "def op_first3_uniq_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_uniq_div3([1, 2, 3, 4]) == [3]\nassert op_first3_uniq_div3([]) == []\nassert op_first3_uniq_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_uniq_div3([5, 5, 5]) == []\nassert op_first3_uniq_div3([3, 1, 2]) == [3]\nassert op_first3_uniq_div3([10]) == []\nassert op_first3_uniq_div3([2, 4, 6]) == [6]\nassert op_first3_uniq_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_first3_dropwhileneg", "entry_point": "op_dropzeros_first3_dropwhileneg", "primitives": ["dropzeros", "first3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then drop the leading negative values.", "solution": "def op_dropzeros_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_first3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_first3_dropwhileneg([]) == []\nassert op_dropzeros_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_dropzeros_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_first3_dropwhileneg([10]) == [10]\nassert op_dropzeros_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_first3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_odds_clamp10_sorta", "entry_point": "op_odds_clamp10_sorta", "primitives": ["odds", "clamp10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then sort ascending.", "solution": "def op_odds_clamp10_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_odds_clamp10_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_odds_clamp10_sorta([]) == []\nassert op_odds_clamp10_sorta([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_clamp10_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_odds_clamp10_sorta([3, 1, 2]) == [1, 3]\nassert op_odds_clamp10_sorta([10]) == []\nassert op_odds_clamp10_sorta([2, 4, 6]) == []\nassert op_odds_clamp10_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_rev_padto3_last3", "entry_point": "op_rev_padto3_last3", "primitives": ["rev", "padto3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_rev_padto3_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_rev_padto3_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_padto3_last3([]) == [0, 0, 0]\nassert op_rev_padto3_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_rev_padto3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_padto3_last3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_padto3_last3([10]) == [10, 0, 0]\nassert op_rev_padto3_last3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_padto3_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_beforezero_uniq", "entry_point": "op_rev_beforezero_uniq", "primitives": ["rev", "beforezero", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then drop duplicates keeping first occurrence.", "solution": "def op_rev_beforezero_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_beforezero_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_uniq([]) == []\nassert op_rev_beforezero_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero_uniq([5, 5, 5]) == [5]\nassert op_rev_beforezero_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_uniq([10]) == [10]\nassert op_rev_beforezero_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropfirst_add10_prod", "entry_point": "op_dropfirst_add10_prod", "primitives": ["dropfirst", "add10", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then return their product.", "solution": "def op_dropfirst_add10_prod(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_dropfirst_add10_prod([1, 2, 3, 4]) == 2184\nassert op_dropfirst_add10_prod([]) == 1\nassert op_dropfirst_add10_prod([-2, -1, 0, 1, 2]) == 11880\nassert op_dropfirst_add10_prod([5, 5, 5]) == 225\nassert op_dropfirst_add10_prod([3, 1, 2]) == 132\nassert op_dropfirst_add10_prod([10]) == 1\nassert op_dropfirst_add10_prod([2, 4, 6]) == 224\nassert op_dropfirst_add10_prod([-7, 12, -7]) == 66"}
{"id": "op_beforezero_gt5_oremptyzero", "entry_point": "op_beforezero_gt5_oremptyzero", "primitives": ["beforezero", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_beforezero_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_beforezero_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_beforezero_gt5_oremptyzero([]) == [0]\nassert op_beforezero_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_beforezero_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_beforezero_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_beforezero_gt5_oremptyzero([10]) == [10]\nassert op_beforezero_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_beforezero_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_sortd_trimends_sum", "entry_point": "op_sortd_trimends_sum", "primitives": ["sortd", "trimends", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then return their sum.", "solution": "def op_sortd_trimends_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return sum(r)", "tests": "assert op_sortd_trimends_sum([1, 2, 3, 4]) == 5\nassert op_sortd_trimends_sum([]) == 0\nassert op_sortd_trimends_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_trimends_sum([5, 5, 5]) == 5\nassert op_sortd_trimends_sum([3, 1, 2]) == 2\nassert op_sortd_trimends_sum([10]) == 0\nassert op_sortd_trimends_sum([2, 4, 6]) == 4\nassert op_sortd_trimends_sum([-7, 12, -7]) == -7"}
{"id": "op_sortabs_pos_max", "entry_point": "op_sortabs_pos_max", "primitives": ["sortabs", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_sortabs_pos_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_sortabs_pos_max([1, 2, 3, 4]) == 4\nassert op_sortabs_pos_max([]) == 0\nassert op_sortabs_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_pos_max([5, 5, 5]) == 5\nassert op_sortabs_pos_max([3, 1, 2]) == 3\nassert op_sortabs_pos_max([10]) == 10\nassert op_sortabs_pos_max([2, 4, 6]) == 6\nassert op_sortabs_pos_max([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_trimends_double", "entry_point": "op_oremptyzero_trimends_double", "primitives": ["oremptyzero", "trimends", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then double each.", "solution": "def op_oremptyzero_trimends_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_trimends_double([1, 2, 3, 4]) == [4, 6]\nassert op_oremptyzero_trimends_double([]) == []\nassert op_oremptyzero_trimends_double([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_oremptyzero_trimends_double([5, 5, 5]) == [10]\nassert op_oremptyzero_trimends_double([3, 1, 2]) == [2]\nassert op_oremptyzero_trimends_double([10]) == []\nassert op_oremptyzero_trimends_double([2, 4, 6]) == [8]\nassert op_oremptyzero_trimends_double([-7, 12, -7]) == [24]"}
{"id": "op_square_beforezero_negate", "entry_point": "op_square_beforezero_negate", "primitives": ["square", "beforezero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then negate each.", "solution": "def op_square_beforezero_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_beforezero_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_beforezero_negate([]) == []\nassert op_square_beforezero_negate([-2, -1, 0, 1, 2]) == [-4, -1]\nassert op_square_beforezero_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_beforezero_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_square_beforezero_negate([10]) == [-100]\nassert op_square_beforezero_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_beforezero_negate([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_dropzeros_double_oremptyzero", "entry_point": "op_dropzeros_double_oremptyzero", "primitives": ["dropzeros", "double", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then if empty, use a single zero.", "solution": "def op_dropzeros_double_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_double_oremptyzero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double_oremptyzero([]) == [0]\nassert op_dropzeros_double_oremptyzero([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_dropzeros_double_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double_oremptyzero([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_double_oremptyzero([10]) == [20]\nassert op_dropzeros_double_oremptyzero([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_double_oremptyzero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_trimends_last3_len", "entry_point": "op_trimends_last3_len", "primitives": ["trimends", "last3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then return how many remain.", "solution": "def op_trimends_last3_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return len(r)", "tests": "assert op_trimends_last3_len([1, 2, 3, 4]) == 2\nassert op_trimends_last3_len([]) == 0\nassert op_trimends_last3_len([-2, -1, 0, 1, 2]) == 3\nassert op_trimends_last3_len([5, 5, 5]) == 1\nassert op_trimends_last3_len([3, 1, 2]) == 1\nassert op_trimends_last3_len([10]) == 0\nassert op_trimends_last3_len([2, 4, 6]) == 1\nassert op_trimends_last3_len([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_sortabs_square", "entry_point": "op_dropzeros_sortabs_square", "primitives": ["dropzeros", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then square each.", "solution": "def op_dropzeros_sortabs_square(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropzeros_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropzeros_sortabs_square([]) == []\nassert op_dropzeros_sortabs_square([-2, -1, 0, 1, 2]) == [1, 1, 4, 4]\nassert op_dropzeros_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_dropzeros_sortabs_square([10]) == [100]\nassert op_dropzeros_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_clamp10_neg_gt5", "entry_point": "op_clamp10_neg_gt5", "primitives": ["clamp10", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then keep values greater than five.", "solution": "def op_clamp10_neg_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_neg_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_neg_gt5([]) == []\nassert op_clamp10_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_neg_gt5([5, 5, 5]) == []\nassert op_clamp10_neg_gt5([3, 1, 2]) == []\nassert op_clamp10_neg_gt5([10]) == []\nassert op_clamp10_neg_gt5([2, 4, 6]) == []\nassert op_clamp10_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_sortabs_pos_len", "entry_point": "op_sortabs_pos_len", "primitives": ["sortabs", "pos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then return how many remain.", "solution": "def op_sortabs_pos_len(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return len(r)", "tests": "assert op_sortabs_pos_len([1, 2, 3, 4]) == 4\nassert op_sortabs_pos_len([]) == 0\nassert op_sortabs_pos_len([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_pos_len([5, 5, 5]) == 3\nassert op_sortabs_pos_len([3, 1, 2]) == 3\nassert op_sortabs_pos_len([10]) == 1\nassert op_sortabs_pos_len([2, 4, 6]) == 3\nassert op_sortabs_pos_len([-7, 12, -7]) == 1"}
{"id": "op_rev_pos_sortd", "entry_point": "op_rev_pos_sortd", "primitives": ["rev", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the positive numbers, then sort descending.", "solution": "def op_rev_pos_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_pos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_pos_sortd([]) == []\nassert op_rev_pos_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_pos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_rev_pos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_rev_pos_sortd([10]) == [10]\nassert op_rev_pos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_rev_pos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_uniq_div3_sortd", "entry_point": "op_uniq_div3_sortd", "primitives": ["uniq", "div3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then sort descending.", "solution": "def op_uniq_div3_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_div3_sortd([1, 2, 3, 4]) == [3]\nassert op_uniq_div3_sortd([]) == []\nassert op_uniq_div3_sortd([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_div3_sortd([5, 5, 5]) == []\nassert op_uniq_div3_sortd([3, 1, 2]) == [3]\nassert op_uniq_div3_sortd([10]) == []\nassert op_uniq_div3_sortd([2, 4, 6]) == [6]\nassert op_uniq_div3_sortd([-7, 12, -7]) == [12]"}
{"id": "op_rev_beforezero_counteven", "entry_point": "op_rev_beforezero_counteven", "primitives": ["rev", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then return how many values are even.", "solution": "def op_rev_beforezero_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_beforezero_counteven([1, 2, 3, 4]) == 2\nassert op_rev_beforezero_counteven([]) == 0\nassert op_rev_beforezero_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_rev_beforezero_counteven([5, 5, 5]) == 0\nassert op_rev_beforezero_counteven([3, 1, 2]) == 1\nassert op_rev_beforezero_counteven([10]) == 1\nassert op_rev_beforezero_counteven([2, 4, 6]) == 3\nassert op_rev_beforezero_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_dropfirst_square", "entry_point": "op_clamp10_dropfirst_square", "primitives": ["clamp10", "dropfirst", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element, then square each.", "solution": "def op_clamp10_dropfirst_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_dropfirst_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_clamp10_dropfirst_square([]) == []\nassert op_clamp10_dropfirst_square([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_clamp10_dropfirst_square([5, 5, 5]) == [25, 25]\nassert op_clamp10_dropfirst_square([3, 1, 2]) == [1, 4]\nassert op_clamp10_dropfirst_square([10]) == []\nassert op_clamp10_dropfirst_square([2, 4, 6]) == [16, 36]\nassert op_clamp10_dropfirst_square([-7, 12, -7]) == [100, 49]"}
{"id": "op_inc_uniq_alldistinct", "entry_point": "op_inc_uniq_alldistinct", "primitives": ["inc", "uniq", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_inc_uniq_alldistinct(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_inc_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_inc_uniq_alldistinct([]) == True\nassert op_inc_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_inc_uniq_alldistinct([5, 5, 5]) == True\nassert op_inc_uniq_alldistinct([3, 1, 2]) == True\nassert op_inc_uniq_alldistinct([10]) == True\nassert op_inc_uniq_alldistinct([2, 4, 6]) == True\nassert op_inc_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_ages_neg_sum", "entry_point": "op_ages_neg_sum", "primitives": ["ages", "neg", "sum"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then return their sum.", "solution": "def op_ages_neg_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_ages_neg_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_neg_sum([]) == 0\nassert op_ages_neg_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 0\nassert op_ages_neg_sum([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_rev_inc_min", "entry_point": "op_rev_inc_min", "primitives": ["rev", "inc", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then return the minimum (0 if empty).", "solution": "def op_rev_inc_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_rev_inc_min([1, 2, 3, 4]) == 2\nassert op_rev_inc_min([]) == 0\nassert op_rev_inc_min([-2, -1, 0, 1, 2]) == -1\nassert op_rev_inc_min([5, 5, 5]) == 6\nassert op_rev_inc_min([3, 1, 2]) == 2\nassert op_rev_inc_min([10]) == 11\nassert op_rev_inc_min([2, 4, 6]) == 3\nassert op_rev_inc_min([-7, 12, -7]) == -6"}
{"id": "op_dropzeros_negate_sorta", "entry_point": "op_dropzeros_negate_sorta", "primitives": ["dropzeros", "negate", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then sort ascending.", "solution": "def op_dropzeros_negate_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_negate_sorta([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_dropzeros_negate_sorta([]) == []\nassert op_dropzeros_negate_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_negate_sorta([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_negate_sorta([3, 1, 2]) == [-3, -2, -1]\nassert op_dropzeros_negate_sorta([10]) == [-10]\nassert op_dropzeros_negate_sorta([2, 4, 6]) == [-6, -4, -2]\nassert op_dropzeros_negate_sorta([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_dropzeros_gt5_sortabs", "entry_point": "op_dropzeros_gt5_sortabs", "primitives": ["dropzeros", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five, then sort by absolute value.", "solution": "def op_dropzeros_gt5_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_dropzeros_gt5_sortabs([]) == []\nassert op_dropzeros_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_gt5_sortabs([5, 5, 5]) == []\nassert op_dropzeros_gt5_sortabs([3, 1, 2]) == []\nassert op_dropzeros_gt5_sortabs([10]) == [10]\nassert op_dropzeros_gt5_sortabs([2, 4, 6]) == [6]\nassert op_dropzeros_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_negate_anyeven", "entry_point": "op_beforezero_negate_anyeven", "primitives": ["beforezero", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then return whether any value is even.", "solution": "def op_beforezero_negate_anyeven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_beforezero_negate_anyeven([1, 2, 3, 4]) == True\nassert op_beforezero_negate_anyeven([]) == False\nassert op_beforezero_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_negate_anyeven([5, 5, 5]) == False\nassert op_beforezero_negate_anyeven([3, 1, 2]) == True\nassert op_beforezero_negate_anyeven([10]) == True\nassert op_beforezero_negate_anyeven([2, 4, 6]) == True\nassert op_beforezero_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_oremptyzero_dropzeros", "entry_point": "op_negate_oremptyzero_dropzeros", "primitives": ["negate", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then drop the zeros.", "solution": "def op_negate_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_negate_oremptyzero_dropzeros([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_oremptyzero_dropzeros([]) == []\nassert op_negate_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_negate_oremptyzero_dropzeros([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_oremptyzero_dropzeros([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_oremptyzero_dropzeros([10]) == [-10]\nassert op_negate_oremptyzero_dropzeros([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_oremptyzero_dropzeros([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_ages_clamp10_firsteven", "entry_point": "op_ages_clamp10_firsteven", "primitives": ["ages", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_ages_clamp10_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_clamp10_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 10\nassert op_ages_clamp10_firsteven([]) == 0\nassert op_ages_clamp10_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 10\nassert op_ages_clamp10_firsteven([{'name': 'Fi', 'age': 41}]) == 10"}
{"id": "op_sortalpha_prefixup_uniqs", "entry_point": "op_sortalpha_prefixup_uniqs", "primitives": ["sortalpha", "prefixup", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then prefix each with a hash, then drop duplicate strings keeping the first.", "solution": "def op_sortalpha_prefixup_uniqs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortalpha_prefixup_uniqs(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortalpha_prefixup_uniqs([]) == []\nassert op_sortalpha_prefixup_uniqs(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_sortalpha_prefixup_uniqs(['one', 'one', 'Two']) == ['#Two', '#one']\nassert op_sortalpha_prefixup_uniqs(['x']) == ['#x']\nassert op_sortalpha_prefixup_uniqs(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_clamp10_dropzeros_last3", "entry_point": "op_clamp10_dropzeros_last3", "primitives": ["clamp10", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then keep only the last three.", "solution": "def op_clamp10_dropzeros_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_dropzeros_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_dropzeros_last3([]) == []\nassert op_clamp10_dropzeros_last3([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_clamp10_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropzeros_last3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropzeros_last3([10]) == [10]\nassert op_clamp10_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropzeros_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_sortabs_last3_div3", "entry_point": "op_sortabs_last3_div3", "primitives": ["sortabs", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the last three, then keep multiples of three.", "solution": "def op_sortabs_last3_div3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortabs_last3_div3([1, 2, 3, 4]) == [3]\nassert op_sortabs_last3_div3([]) == []\nassert op_sortabs_last3_div3([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_last3_div3([5, 5, 5]) == []\nassert op_sortabs_last3_div3([3, 1, 2]) == [3]\nassert op_sortabs_last3_div3([10]) == []\nassert op_sortabs_last3_div3([2, 4, 6]) == [6]\nassert op_sortabs_last3_div3([-7, 12, -7]) == [12]"}
{"id": "op_pos_negate_max", "entry_point": "op_pos_negate_max", "primitives": ["pos", "negate", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then return the maximum (0 if empty).", "solution": "def op_pos_negate_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return max(r) if r else 0", "tests": "assert op_pos_negate_max([1, 2, 3, 4]) == -1\nassert op_pos_negate_max([]) == 0\nassert op_pos_negate_max([-2, -1, 0, 1, 2]) == -1\nassert op_pos_negate_max([5, 5, 5]) == -5\nassert op_pos_negate_max([3, 1, 2]) == -1\nassert op_pos_negate_max([10]) == -10\nassert op_pos_negate_max([2, 4, 6]) == -2\nassert op_pos_negate_max([-7, 12, -7]) == -12"}
{"id": "op_dec_inc_clamp10", "entry_point": "op_dec_inc_clamp10", "primitives": ["dec", "inc", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then cap each value at 10.", "solution": "def op_dec_inc_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_inc_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc_clamp10([]) == []\nassert op_dec_inc_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_dec_inc_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc_clamp10([10]) == [10]\nassert op_dec_inc_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_dropwhileneg_odds_trimends", "entry_point": "op_dropwhileneg_odds_trimends", "primitives": ["dropwhileneg", "odds", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_dropwhileneg_odds_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_odds_trimends([1, 2, 3, 4]) == []\nassert op_dropwhileneg_odds_trimends([]) == []\nassert op_dropwhileneg_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_odds_trimends([5, 5, 5]) == [5]\nassert op_dropwhileneg_odds_trimends([3, 1, 2]) == []\nassert op_dropwhileneg_odds_trimends([10]) == []\nassert op_dropwhileneg_odds_trimends([2, 4, 6]) == []\nassert op_dropwhileneg_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_inc_pos_len", "entry_point": "op_inc_pos_len", "primitives": ["inc", "pos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then return how many remain.", "solution": "def op_inc_pos_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return len(r)", "tests": "assert op_inc_pos_len([1, 2, 3, 4]) == 4\nassert op_inc_pos_len([]) == 0\nassert op_inc_pos_len([-2, -1, 0, 1, 2]) == 3\nassert op_inc_pos_len([5, 5, 5]) == 3\nassert op_inc_pos_len([3, 1, 2]) == 3\nassert op_inc_pos_len([10]) == 1\nassert op_inc_pos_len([2, 4, 6]) == 3\nassert op_inc_pos_len([-7, 12, -7]) == 1"}
{"id": "op_dropshort_lower_joinc", "entry_point": "op_dropshort_lower_joinc", "primitives": ["dropshort", "lower", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then lowercase each string, then join them with commas.", "solution": "def op_dropshort_lower_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.lower() for s in r]\n    return ','.join(r)", "tests": "assert op_dropshort_lower_joinc(['Hello', 'world']) == 'hello,world'\nassert op_dropshort_lower_joinc([]) == ''\nassert op_dropshort_lower_joinc(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_dropshort_lower_joinc(['one', 'one', 'Two']) == 'one,one,two'\nassert op_dropshort_lower_joinc(['x']) == ''\nassert op_dropshort_lower_joinc(['abc', 'de', '']) == 'abc'"}
{"id": "op_ages_uniq_rev", "entry_point": "op_ages_uniq_rev", "primitives": ["ages", "uniq", "rev"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_ages_uniq_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_uniq_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_uniq_rev([]) == []\nassert op_ages_uniq_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_uniq_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_neg_odds_padto3", "entry_point": "op_neg_odds_padto3", "primitives": ["neg", "odds", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then pad with zeros to at least three elements.", "solution": "def op_neg_odds_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_odds_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_odds_padto3([]) == [0, 0, 0]\nassert op_neg_odds_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_neg_odds_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_odds_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_odds_padto3([10]) == [0, 0, 0]\nassert op_neg_odds_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_odds_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_uniq_sortabs_prod", "entry_point": "op_uniq_sortabs_prod", "primitives": ["uniq", "sortabs", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value, then return their product.", "solution": "def op_uniq_sortabs_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_uniq_sortabs_prod([1, 2, 3, 4]) == 24\nassert op_uniq_sortabs_prod([]) == 1\nassert op_uniq_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_sortabs_prod([5, 5, 5]) == 5\nassert op_uniq_sortabs_prod([3, 1, 2]) == 6\nassert op_uniq_sortabs_prod([10]) == 10\nassert op_uniq_sortabs_prod([2, 4, 6]) == 48\nassert op_uniq_sortabs_prod([-7, 12, -7]) == -84"}
{"id": "op_takewhilepos_dropzeros_pos", "entry_point": "op_takewhilepos_dropzeros_pos", "primitives": ["takewhilepos", "dropzeros", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then keep the positive numbers.", "solution": "def op_takewhilepos_dropzeros_pos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_takewhilepos_dropzeros_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_dropzeros_pos([]) == []\nassert op_takewhilepos_dropzeros_pos([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropzeros_pos([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropzeros_pos([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropzeros_pos([10]) == [10]\nassert op_takewhilepos_dropzeros_pos([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropzeros_pos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_padto3_sum", "entry_point": "op_dropfirst_padto3_sum", "primitives": ["dropfirst", "padto3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then return their sum.", "solution": "def op_dropfirst_padto3_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(r)", "tests": "assert op_dropfirst_padto3_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_padto3_sum([]) == 0\nassert op_dropfirst_padto3_sum([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_padto3_sum([5, 5, 5]) == 10\nassert op_dropfirst_padto3_sum([3, 1, 2]) == 3\nassert op_dropfirst_padto3_sum([10]) == 0\nassert op_dropfirst_padto3_sum([2, 4, 6]) == 10\nassert op_dropfirst_padto3_sum([-7, 12, -7]) == 5"}
{"id": "op_trimends_first3_alldistinct", "entry_point": "op_trimends_first3_alldistinct", "primitives": ["trimends", "first3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then return whether all values are distinct.", "solution": "def op_trimends_first3_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_trimends_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_first3_alldistinct([]) == True\nassert op_trimends_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_first3_alldistinct([5, 5, 5]) == True\nassert op_trimends_first3_alldistinct([3, 1, 2]) == True\nassert op_trimends_first3_alldistinct([10]) == True\nassert op_trimends_first3_alldistinct([2, 4, 6]) == True\nassert op_trimends_first3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_upper_lower_counts", "entry_point": "op_upper_lower_counts", "primitives": ["upper", "lower", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then lowercase each string, then return how many strings remain.", "solution": "def op_upper_lower_counts(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return len(r)", "tests": "assert op_upper_lower_counts(['Hello', 'world']) == 2\nassert op_upper_lower_counts([]) == 0\nassert op_upper_lower_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_upper_lower_counts(['one', 'one', 'Two']) == 3\nassert op_upper_lower_counts(['x']) == 1\nassert op_upper_lower_counts(['abc', 'de', '']) == 3"}
{"id": "op_evens_square_anyeven", "entry_point": "op_evens_square_anyeven", "primitives": ["evens", "square", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then return whether any value is even.", "solution": "def op_evens_square_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_square_anyeven([1, 2, 3, 4]) == True\nassert op_evens_square_anyeven([]) == False\nassert op_evens_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_evens_square_anyeven([5, 5, 5]) == False\nassert op_evens_square_anyeven([3, 1, 2]) == True\nassert op_evens_square_anyeven([10]) == True\nassert op_evens_square_anyeven([2, 4, 6]) == True\nassert op_evens_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_inc_add10_clamp10", "entry_point": "op_inc_add10_clamp10", "primitives": ["inc", "add10", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then cap each value at 10.", "solution": "def op_inc_add10_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_add10_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_inc_add10_clamp10([]) == []\nassert op_inc_add10_clamp10([-2, -1, 0, 1, 2]) == [9, 10, 10, 10, 10]\nassert op_inc_add10_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_inc_add10_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_inc_add10_clamp10([10]) == [10]\nassert op_inc_add10_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_inc_add10_clamp10([-7, 12, -7]) == [4, 10, 4]"}
{"id": "op_trimends_sortd_allpos", "entry_point": "op_trimends_sortd_allpos", "primitives": ["trimends", "sortd", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending, then return whether all values are positive.", "solution": "def op_trimends_sortd_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_sortd_allpos([1, 2, 3, 4]) == True\nassert op_trimends_sortd_allpos([]) == True\nassert op_trimends_sortd_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_sortd_allpos([5, 5, 5]) == True\nassert op_trimends_sortd_allpos([3, 1, 2]) == True\nassert op_trimends_sortd_allpos([10]) == True\nassert op_trimends_sortd_allpos([2, 4, 6]) == True\nassert op_trimends_sortd_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_add10_takewhilepos", "entry_point": "op_oremptyzero_add10_takewhilepos", "primitives": ["oremptyzero", "add10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then take values while they are positive.", "solution": "def op_oremptyzero_add10_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_add10_takewhilepos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_oremptyzero_add10_takewhilepos([]) == [10]\nassert op_oremptyzero_add10_takewhilepos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_oremptyzero_add10_takewhilepos([5, 5, 5]) == [15, 15, 15]\nassert op_oremptyzero_add10_takewhilepos([3, 1, 2]) == [13, 11, 12]\nassert op_oremptyzero_add10_takewhilepos([10]) == [20]\nassert op_oremptyzero_add10_takewhilepos([2, 4, 6]) == [12, 14, 16]\nassert op_oremptyzero_add10_takewhilepos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_div3_absval_beforezero", "entry_point": "op_div3_absval_beforezero", "primitives": ["div3", "absval", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each, then keep everything before the first zero.", "solution": "def op_div3_absval_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_absval_beforezero([1, 2, 3, 4]) == [3]\nassert op_div3_absval_beforezero([]) == []\nassert op_div3_absval_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_absval_beforezero([5, 5, 5]) == []\nassert op_div3_absval_beforezero([3, 1, 2]) == [3]\nassert op_div3_absval_beforezero([10]) == []\nassert op_div3_absval_beforezero([2, 4, 6]) == [6]\nassert op_div3_absval_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_inc_neg_padto3", "entry_point": "op_inc_neg_padto3", "primitives": ["inc", "neg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_inc_neg_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_inc_neg_padto3([]) == [0, 0, 0]\nassert op_inc_neg_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_inc_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_inc_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_inc_neg_padto3([10]) == [0, 0, 0]\nassert op_inc_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_inc_neg_padto3([-7, 12, -7]) == [-6, -6, 0]"}
{"id": "op_takewhilepos_double_inc", "entry_point": "op_takewhilepos_double_inc", "primitives": ["takewhilepos", "double", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then add one to each.", "solution": "def op_takewhilepos_double_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_double_inc([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_takewhilepos_double_inc([]) == []\nassert op_takewhilepos_double_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double_inc([5, 5, 5]) == [11, 11, 11]\nassert op_takewhilepos_double_inc([3, 1, 2]) == [7, 3, 5]\nassert op_takewhilepos_double_inc([10]) == [21]\nassert op_takewhilepos_double_inc([2, 4, 6]) == [5, 9, 13]\nassert op_takewhilepos_double_inc([-7, 12, -7]) == []"}
{"id": "op_clamp10_absval_sorta", "entry_point": "op_clamp10_absval_sorta", "primitives": ["clamp10", "absval", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then sort ascending.", "solution": "def op_clamp10_absval_sorta(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_clamp10_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_absval_sorta([]) == []\nassert op_clamp10_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_clamp10_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_absval_sorta([10]) == [10]\nassert op_clamp10_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_absval_sorta([-7, 12, -7]) == [7, 7, 10]"}
{"id": "op_gt5_trimends_dropwhileneg", "entry_point": "op_gt5_trimends_dropwhileneg", "primitives": ["gt5", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_gt5_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_gt5_trimends_dropwhileneg([1, 2, 3, 4]) == []\nassert op_gt5_trimends_dropwhileneg([]) == []\nassert op_gt5_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_dropwhileneg([5, 5, 5]) == []\nassert op_gt5_trimends_dropwhileneg([3, 1, 2]) == []\nassert op_gt5_trimends_dropwhileneg([10]) == []\nassert op_gt5_trimends_dropwhileneg([2, 4, 6]) == []\nassert op_gt5_trimends_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_beforezero_sortabs_firsteven", "entry_point": "op_beforezero_sortabs_firsteven", "primitives": ["beforezero", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_beforezero_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_sortabs_firsteven([]) == 0\nassert op_beforezero_sortabs_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_sortabs_firsteven([5, 5, 5]) == 0\nassert op_beforezero_sortabs_firsteven([3, 1, 2]) == 2\nassert op_beforezero_sortabs_firsteven([10]) == 10\nassert op_beforezero_sortabs_firsteven([2, 4, 6]) == 2\nassert op_beforezero_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_last3_dropwhileneg", "entry_point": "op_evens_last3_dropwhileneg", "primitives": ["evens", "last3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then drop the leading negative values.", "solution": "def op_evens_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_evens_last3_dropwhileneg([1, 2, 3, 4]) == [2, 4]\nassert op_evens_last3_dropwhileneg([]) == []\nassert op_evens_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_last3_dropwhileneg([5, 5, 5]) == []\nassert op_evens_last3_dropwhileneg([3, 1, 2]) == [2]\nassert op_evens_last3_dropwhileneg([10]) == [10]\nassert op_evens_last3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_evens_last3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_uniq_double_haszero", "entry_point": "op_uniq_double_haszero", "primitives": ["uniq", "double", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then return whether the list contains a zero.", "solution": "def op_uniq_double_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_uniq_double_haszero([1, 2, 3, 4]) == False\nassert op_uniq_double_haszero([]) == False\nassert op_uniq_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_uniq_double_haszero([5, 5, 5]) == False\nassert op_uniq_double_haszero([3, 1, 2]) == False\nassert op_uniq_double_haszero([10]) == False\nassert op_uniq_double_haszero([2, 4, 6]) == False\nassert op_uniq_double_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_sorta_counteven", "entry_point": "op_trimends_sorta_counteven", "primitives": ["trimends", "sorta", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending, then return how many values are even.", "solution": "def op_trimends_sorta_counteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_trimends_sorta_counteven([1, 2, 3, 4]) == 1\nassert op_trimends_sorta_counteven([]) == 0\nassert op_trimends_sorta_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_sorta_counteven([5, 5, 5]) == 0\nassert op_trimends_sorta_counteven([3, 1, 2]) == 0\nassert op_trimends_sorta_counteven([10]) == 0\nassert op_trimends_sorta_counteven([2, 4, 6]) == 1\nassert op_trimends_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_dropwhileneg_absval", "entry_point": "op_rev_dropwhileneg_absval", "primitives": ["rev", "dropwhileneg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then take the absolute value of each.", "solution": "def op_rev_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_dropwhileneg_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropwhileneg_absval([]) == []\nassert op_rev_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_rev_dropwhileneg_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropwhileneg_absval([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropwhileneg_absval([10]) == [10]\nassert op_rev_dropwhileneg_absval([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropwhileneg_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_absval_rev_len", "entry_point": "op_absval_rev_len", "primitives": ["absval", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then return how many remain.", "solution": "def op_absval_rev_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_absval_rev_len([1, 2, 3, 4]) == 4\nassert op_absval_rev_len([]) == 0\nassert op_absval_rev_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_rev_len([5, 5, 5]) == 3\nassert op_absval_rev_len([3, 1, 2]) == 3\nassert op_absval_rev_len([10]) == 1\nassert op_absval_rev_len([2, 4, 6]) == 3\nassert op_absval_rev_len([-7, 12, -7]) == 3"}
{"id": "op_rev_double_neg", "entry_point": "op_rev_double_neg", "primitives": ["rev", "double", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then keep the negative numbers.", "solution": "def op_rev_double_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_double_neg([1, 2, 3, 4]) == []\nassert op_rev_double_neg([]) == []\nassert op_rev_double_neg([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_rev_double_neg([5, 5, 5]) == []\nassert op_rev_double_neg([3, 1, 2]) == []\nassert op_rev_double_neg([10]) == []\nassert op_rev_double_neg([2, 4, 6]) == []\nassert op_rev_double_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_negate_absval_allpos", "entry_point": "op_negate_absval_allpos", "primitives": ["negate", "absval", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_negate_absval_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_negate_absval_allpos([1, 2, 3, 4]) == True\nassert op_negate_absval_allpos([]) == True\nassert op_negate_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_absval_allpos([5, 5, 5]) == True\nassert op_negate_absval_allpos([3, 1, 2]) == True\nassert op_negate_absval_allpos([10]) == True\nassert op_negate_absval_allpos([2, 4, 6]) == True\nassert op_negate_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_square_double_clamp10", "entry_point": "op_square_double_clamp10", "primitives": ["square", "double", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then cap each value at 10.", "solution": "def op_square_double_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_double_clamp10([1, 2, 3, 4]) == [2, 8, 10, 10]\nassert op_square_double_clamp10([]) == []\nassert op_square_double_clamp10([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_square_double_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_square_double_clamp10([3, 1, 2]) == [10, 2, 8]\nassert op_square_double_clamp10([10]) == [10]\nassert op_square_double_clamp10([2, 4, 6]) == [8, 10, 10]\nassert op_square_double_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_dropwhileneg_inc_neg", "entry_point": "op_dropwhileneg_inc_neg", "primitives": ["dropwhileneg", "inc", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then keep the negative numbers.", "solution": "def op_dropwhileneg_inc_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_inc_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_inc_neg([]) == []\nassert op_dropwhileneg_inc_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_inc_neg([5, 5, 5]) == []\nassert op_dropwhileneg_inc_neg([3, 1, 2]) == []\nassert op_dropwhileneg_inc_neg([10]) == []\nassert op_dropwhileneg_inc_neg([2, 4, 6]) == []\nassert op_dropwhileneg_inc_neg([-7, 12, -7]) == [-6]"}
{"id": "op_odds_dropzeros_dropwhileneg", "entry_point": "op_odds_dropzeros_dropwhileneg", "primitives": ["odds", "dropzeros", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros, then drop the leading negative values.", "solution": "def op_odds_dropzeros_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_odds_dropzeros_dropwhileneg([1, 2, 3, 4]) == [1, 3]\nassert op_odds_dropzeros_dropwhileneg([]) == []\nassert op_odds_dropzeros_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropzeros_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_odds_dropzeros_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_odds_dropzeros_dropwhileneg([10]) == []\nassert op_odds_dropzeros_dropwhileneg([2, 4, 6]) == []\nassert op_odds_dropzeros_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_neg_beforezero_clamp10", "entry_point": "op_neg_beforezero_clamp10", "primitives": ["neg", "beforezero", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_neg_beforezero_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_neg_beforezero_clamp10([1, 2, 3, 4]) == []\nassert op_neg_beforezero_clamp10([]) == []\nassert op_neg_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_beforezero_clamp10([5, 5, 5]) == []\nassert op_neg_beforezero_clamp10([3, 1, 2]) == []\nassert op_neg_beforezero_clamp10([10]) == []\nassert op_neg_beforezero_clamp10([2, 4, 6]) == []\nassert op_neg_beforezero_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_dropfirst_min", "entry_point": "op_sortabs_dropfirst_min", "primitives": ["sortabs", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_sortabs_dropfirst_min(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_sortabs_dropfirst_min([1, 2, 3, 4]) == 2\nassert op_sortabs_dropfirst_min([]) == 0\nassert op_sortabs_dropfirst_min([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_dropfirst_min([5, 5, 5]) == 5\nassert op_sortabs_dropfirst_min([3, 1, 2]) == 2\nassert op_sortabs_dropfirst_min([10]) == 0\nassert op_sortabs_dropfirst_min([2, 4, 6]) == 4\nassert op_sortabs_dropfirst_min([-7, 12, -7]) == -7"}
{"id": "op_oremptyzero_dec_double", "entry_point": "op_oremptyzero_dec_double", "primitives": ["oremptyzero", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then double each.", "solution": "def op_oremptyzero_dec_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_dec_double([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_oremptyzero_dec_double([]) == [-2]\nassert op_oremptyzero_dec_double([-2, -1, 0, 1, 2]) == [-6, -4, -2, 0, 2]\nassert op_oremptyzero_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_oremptyzero_dec_double([3, 1, 2]) == [4, 0, 2]\nassert op_oremptyzero_dec_double([10]) == [18]\nassert op_oremptyzero_dec_double([2, 4, 6]) == [2, 6, 10]\nassert op_oremptyzero_dec_double([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_beforezero_odds_inc", "entry_point": "op_beforezero_odds_inc", "primitives": ["beforezero", "odds", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the odd numbers, then add one to each.", "solution": "def op_beforezero_odds_inc(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_beforezero_odds_inc([1, 2, 3, 4]) == [2, 4]\nassert op_beforezero_odds_inc([]) == []\nassert op_beforezero_odds_inc([-2, -1, 0, 1, 2]) == [0]\nassert op_beforezero_odds_inc([5, 5, 5]) == [6, 6, 6]\nassert op_beforezero_odds_inc([3, 1, 2]) == [4, 2]\nassert op_beforezero_odds_inc([10]) == []\nassert op_beforezero_odds_inc([2, 4, 6]) == []\nassert op_beforezero_odds_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dropzeros_sorta_add10", "entry_point": "op_dropzeros_sorta_add10", "primitives": ["dropzeros", "sorta", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then add ten to each.", "solution": "def op_dropzeros_sorta_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropzeros_sorta_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropzeros_sorta_add10([]) == []\nassert op_dropzeros_sorta_add10([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_dropzeros_sorta_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropzeros_sorta_add10([3, 1, 2]) == [11, 12, 13]\nassert op_dropzeros_sorta_add10([10]) == [20]\nassert op_dropzeros_sorta_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_sorta_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_first3_sortd_max", "entry_point": "op_first3_sortd_max", "primitives": ["first3", "sortd", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then return the maximum (0 if empty).", "solution": "def op_first3_sortd_max(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return max(r) if r else 0", "tests": "assert op_first3_sortd_max([1, 2, 3, 4]) == 3\nassert op_first3_sortd_max([]) == 0\nassert op_first3_sortd_max([-2, -1, 0, 1, 2]) == 0\nassert op_first3_sortd_max([5, 5, 5]) == 5\nassert op_first3_sortd_max([3, 1, 2]) == 3\nassert op_first3_sortd_max([10]) == 10\nassert op_first3_sortd_max([2, 4, 6]) == 6\nassert op_first3_sortd_max([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_absval_first3", "entry_point": "op_dropfirst_absval_first3", "primitives": ["dropfirst", "absval", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then keep only the first three.", "solution": "def op_dropfirst_absval_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_absval_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_absval_first3([]) == []\nassert op_dropfirst_absval_first3([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_dropfirst_absval_first3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_absval_first3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_absval_first3([10]) == []\nassert op_dropfirst_absval_first3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_absval_first3([-7, 12, -7]) == [12, 7]"}
{"id": "op_sorta_beforezero_absval", "entry_point": "op_sorta_beforezero_absval", "primitives": ["sorta", "beforezero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_sorta_beforezero_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_beforezero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_beforezero_absval([]) == []\nassert op_sorta_beforezero_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sorta_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_beforezero_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_beforezero_absval([10]) == [10]\nassert op_sorta_beforezero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_beforezero_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_ages_inc_dropzeros", "entry_point": "op_ages_inc_dropzeros", "primitives": ["ages", "inc", "dropzeros"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add one to each, then drop the zeros.", "solution": "def op_ages_inc_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_inc_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [37, 13]\nassert op_ages_inc_dropzeros([]) == []\nassert op_ages_inc_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [19, 66, 18]\nassert op_ages_inc_dropzeros([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_sortabs_oremptyzero_negate", "entry_point": "op_sortabs_oremptyzero_negate", "primitives": ["sortabs", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then negate each.", "solution": "def op_sortabs_oremptyzero_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_oremptyzero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sortabs_oremptyzero_negate([]) == [0]\nassert op_sortabs_oremptyzero_negate([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortabs_oremptyzero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_oremptyzero_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_oremptyzero_negate([10]) == [-10]\nassert op_sortabs_oremptyzero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_oremptyzero_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_negate_dropfirst_pos", "entry_point": "op_negate_dropfirst_pos", "primitives": ["negate", "dropfirst", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then keep the positive numbers.", "solution": "def op_negate_dropfirst_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_dropfirst_pos([1, 2, 3, 4]) == []\nassert op_negate_dropfirst_pos([]) == []\nassert op_negate_dropfirst_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_negate_dropfirst_pos([5, 5, 5]) == []\nassert op_negate_dropfirst_pos([3, 1, 2]) == []\nassert op_negate_dropfirst_pos([10]) == []\nassert op_negate_dropfirst_pos([2, 4, 6]) == []\nassert op_negate_dropfirst_pos([-7, 12, -7]) == [7]"}
{"id": "op_padto3_sortd_allpos", "entry_point": "op_padto3_sortd_allpos", "primitives": ["padto3", "sortd", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then return whether all values are positive.", "solution": "def op_padto3_sortd_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_sortd_allpos([1, 2, 3, 4]) == True\nassert op_padto3_sortd_allpos([]) == False\nassert op_padto3_sortd_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_sortd_allpos([5, 5, 5]) == True\nassert op_padto3_sortd_allpos([3, 1, 2]) == True\nassert op_padto3_sortd_allpos([10]) == False\nassert op_padto3_sortd_allpos([2, 4, 6]) == True\nassert op_padto3_sortd_allpos([-7, 12, -7]) == False"}
{"id": "op_dropfirst_trimends_div3", "entry_point": "op_dropfirst_trimends_div3", "primitives": ["dropfirst", "trimends", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then keep multiples of three.", "solution": "def op_dropfirst_trimends_div3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropfirst_trimends_div3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_div3([]) == []\nassert op_dropfirst_trimends_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropfirst_trimends_div3([5, 5, 5]) == []\nassert op_dropfirst_trimends_div3([3, 1, 2]) == []\nassert op_dropfirst_trimends_div3([10]) == []\nassert op_dropfirst_trimends_div3([2, 4, 6]) == []\nassert op_dropfirst_trimends_div3([-7, 12, -7]) == []"}
{"id": "op_beforezero_last3_min", "entry_point": "op_beforezero_last3_min", "primitives": ["beforezero", "last3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then return the minimum (0 if empty).", "solution": "def op_beforezero_last3_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return min(r) if r else 0", "tests": "assert op_beforezero_last3_min([1, 2, 3, 4]) == 2\nassert op_beforezero_last3_min([]) == 0\nassert op_beforezero_last3_min([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_last3_min([5, 5, 5]) == 5\nassert op_beforezero_last3_min([3, 1, 2]) == 1\nassert op_beforezero_last3_min([10]) == 10\nassert op_beforezero_last3_min([2, 4, 6]) == 2\nassert op_beforezero_last3_min([-7, 12, -7]) == -7"}
{"id": "op_padto3_dropwhileneg_trimends", "entry_point": "op_padto3_dropwhileneg_trimends", "primitives": ["padto3", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_padto3_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_dropwhileneg_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_dropwhileneg_trimends([]) == [0]\nassert op_padto3_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_padto3_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_padto3_dropwhileneg_trimends([3, 1, 2]) == [1]\nassert op_padto3_dropwhileneg_trimends([10]) == [0]\nassert op_padto3_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_padto3_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_clamp10_takewhilepos_uniq", "entry_point": "op_clamp10_takewhilepos_uniq", "primitives": ["clamp10", "takewhilepos", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_takewhilepos_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_takewhilepos_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_takewhilepos_uniq([]) == []\nassert op_clamp10_takewhilepos_uniq([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_takewhilepos_uniq([5, 5, 5]) == [5]\nassert op_clamp10_takewhilepos_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_takewhilepos_uniq([10]) == [10]\nassert op_clamp10_takewhilepos_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_takewhilepos_uniq([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_clamp10_add10", "entry_point": "op_dropwhileneg_clamp10_add10", "primitives": ["dropwhileneg", "clamp10", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then add ten to each.", "solution": "def op_dropwhileneg_clamp10_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_clamp10_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_clamp10_add10([]) == []\nassert op_dropwhileneg_clamp10_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_clamp10_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_clamp10_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_clamp10_add10([10]) == [20]\nassert op_dropwhileneg_clamp10_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_clamp10_add10([-7, 12, -7]) == [20, 3]"}
{"id": "op_sortabs_double_haszero", "entry_point": "op_sortabs_double_haszero", "primitives": ["sortabs", "double", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then return whether the list contains a zero.", "solution": "def op_sortabs_double_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_sortabs_double_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_double_haszero([]) == False\nassert op_sortabs_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_double_haszero([5, 5, 5]) == False\nassert op_sortabs_double_haszero([3, 1, 2]) == False\nassert op_sortabs_double_haszero([10]) == False\nassert op_sortabs_double_haszero([2, 4, 6]) == False\nassert op_sortabs_double_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_rev_len", "entry_point": "op_odds_rev_len", "primitives": ["odds", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then return how many remain.", "solution": "def op_odds_rev_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_odds_rev_len([1, 2, 3, 4]) == 2\nassert op_odds_rev_len([]) == 0\nassert op_odds_rev_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_rev_len([5, 5, 5]) == 3\nassert op_odds_rev_len([3, 1, 2]) == 2\nassert op_odds_rev_len([10]) == 0\nassert op_odds_rev_len([2, 4, 6]) == 0\nassert op_odds_rev_len([-7, 12, -7]) == 2"}
{"id": "op_gt5_takewhilepos_prod", "entry_point": "op_gt5_takewhilepos_prod", "primitives": ["gt5", "takewhilepos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then return their product.", "solution": "def op_gt5_takewhilepos_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_gt5_takewhilepos_prod([1, 2, 3, 4]) == 1\nassert op_gt5_takewhilepos_prod([]) == 1\nassert op_gt5_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_gt5_takewhilepos_prod([5, 5, 5]) == 1\nassert op_gt5_takewhilepos_prod([3, 1, 2]) == 1\nassert op_gt5_takewhilepos_prod([10]) == 10\nassert op_gt5_takewhilepos_prod([2, 4, 6]) == 6\nassert op_gt5_takewhilepos_prod([-7, 12, -7]) == 12"}
{"id": "op_add10_clamp10_dec", "entry_point": "op_add10_clamp10_dec", "primitives": ["add10", "clamp10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then subtract one from each.", "solution": "def op_add10_clamp10_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_clamp10_dec([1, 2, 3, 4]) == [9, 9, 9, 9]\nassert op_add10_clamp10_dec([]) == []\nassert op_add10_clamp10_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 9, 9]\nassert op_add10_clamp10_dec([5, 5, 5]) == [9, 9, 9]\nassert op_add10_clamp10_dec([3, 1, 2]) == [9, 9, 9]\nassert op_add10_clamp10_dec([10]) == [9]\nassert op_add10_clamp10_dec([2, 4, 6]) == [9, 9, 9]\nassert op_add10_clamp10_dec([-7, 12, -7]) == [2, 9, 2]"}
{"id": "op_dec_odds_allpos", "entry_point": "op_dec_odds_allpos", "primitives": ["dec", "odds", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_dec_odds_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_odds_allpos([1, 2, 3, 4]) == True\nassert op_dec_odds_allpos([]) == True\nassert op_dec_odds_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_odds_allpos([5, 5, 5]) == True\nassert op_dec_odds_allpos([3, 1, 2]) == True\nassert op_dec_odds_allpos([10]) == True\nassert op_dec_odds_allpos([2, 4, 6]) == True\nassert op_dec_odds_allpos([-7, 12, -7]) == True"}
{"id": "op_div3_gt5_sortabs", "entry_point": "op_div3_gt5_sortabs", "primitives": ["div3", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then sort by absolute value.", "solution": "def op_div3_gt5_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_div3_gt5_sortabs([]) == []\nassert op_div3_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_sortabs([5, 5, 5]) == []\nassert op_div3_gt5_sortabs([3, 1, 2]) == []\nassert op_div3_gt5_sortabs([10]) == []\nassert op_div3_gt5_sortabs([2, 4, 6]) == [6]\nassert op_div3_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_sorta_div3", "entry_point": "op_sortabs_sorta_div3", "primitives": ["sortabs", "sorta", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then keep multiples of three.", "solution": "def op_sortabs_sorta_div3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortabs_sorta_div3([1, 2, 3, 4]) == [3]\nassert op_sortabs_sorta_div3([]) == []\nassert op_sortabs_sorta_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortabs_sorta_div3([5, 5, 5]) == []\nassert op_sortabs_sorta_div3([3, 1, 2]) == [3]\nassert op_sortabs_sorta_div3([10]) == []\nassert op_sortabs_sorta_div3([2, 4, 6]) == [6]\nassert op_sortabs_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_uniq_takewhilepos_issorted", "entry_point": "op_uniq_takewhilepos_issorted", "primitives": ["uniq", "takewhilepos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_uniq_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_uniq_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_uniq_takewhilepos_issorted([]) == True\nassert op_uniq_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_takewhilepos_issorted([5, 5, 5]) == True\nassert op_uniq_takewhilepos_issorted([3, 1, 2]) == False\nassert op_uniq_takewhilepos_issorted([10]) == True\nassert op_uniq_takewhilepos_issorted([2, 4, 6]) == True\nassert op_uniq_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_div3_rev_dropfirst", "entry_point": "op_div3_rev_dropfirst", "primitives": ["div3", "rev", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then drop the first element.", "solution": "def op_div3_rev_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = r[1:]\n    return r", "tests": "assert op_div3_rev_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_rev_dropfirst([]) == []\nassert op_div3_rev_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_rev_dropfirst([5, 5, 5]) == []\nassert op_div3_rev_dropfirst([3, 1, 2]) == []\nassert op_div3_rev_dropfirst([10]) == []\nassert op_div3_rev_dropfirst([2, 4, 6]) == []\nassert op_div3_rev_dropfirst([-7, 12, -7]) == []"}
{"id": "op_prefixup_firstchar_longest", "entry_point": "op_prefixup_firstchar_longest", "primitives": ["prefixup", "firstchar", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_prefixup_firstchar_longest(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_prefixup_firstchar_longest(['Hello', 'world']) == '#'\nassert op_prefixup_firstchar_longest([]) == ''\nassert op_prefixup_firstchar_longest(['  a ', '', 'BC', 'bc']) == '#'\nassert op_prefixup_firstchar_longest(['one', 'one', 'Two']) == '#'\nassert op_prefixup_firstchar_longest(['x']) == '#'\nassert op_prefixup_firstchar_longest(['abc', 'de', '']) == '#'"}
{"id": "op_beforezero_dropzeros_first3", "entry_point": "op_beforezero_dropzeros_first3", "primitives": ["beforezero", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then keep only the first three.", "solution": "def op_beforezero_dropzeros_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_dropzeros_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_dropzeros_first3([]) == []\nassert op_beforezero_dropzeros_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_dropzeros_first3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_dropzeros_first3([10]) == [10]\nassert op_beforezero_dropzeros_first3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_dropzeros_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg_div3_allpos", "entry_point": "op_neg_div3_allpos", "primitives": ["neg", "div3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three, then return whether all values are positive.", "solution": "def op_neg_div3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_neg_div3_allpos([1, 2, 3, 4]) == True\nassert op_neg_div3_allpos([]) == True\nassert op_neg_div3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_neg_div3_allpos([5, 5, 5]) == True\nassert op_neg_div3_allpos([3, 1, 2]) == True\nassert op_neg_div3_allpos([10]) == True\nassert op_neg_div3_allpos([2, 4, 6]) == True\nassert op_neg_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_sorta_haszero", "entry_point": "op_oremptyzero_sorta_haszero", "primitives": ["oremptyzero", "sorta", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then return whether the list contains a zero.", "solution": "def op_oremptyzero_sorta_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    return 0 in r", "tests": "assert op_oremptyzero_sorta_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_sorta_haszero([]) == True\nassert op_oremptyzero_sorta_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_sorta_haszero([5, 5, 5]) == False\nassert op_oremptyzero_sorta_haszero([3, 1, 2]) == False\nassert op_oremptyzero_sorta_haszero([10]) == False\nassert op_oremptyzero_sorta_haszero([2, 4, 6]) == False\nassert op_oremptyzero_sorta_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_padto3_trimends", "entry_point": "op_sorta_padto3_trimends", "primitives": ["sorta", "padto3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_sorta_padto3_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_padto3_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_padto3_trimends([]) == [0]\nassert op_sorta_padto3_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sorta_padto3_trimends([5, 5, 5]) == [5]\nassert op_sorta_padto3_trimends([3, 1, 2]) == [2]\nassert op_sorta_padto3_trimends([10]) == [0]\nassert op_sorta_padto3_trimends([2, 4, 6]) == [4]\nassert op_sorta_padto3_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_odds_dropzeros_neg", "entry_point": "op_odds_dropzeros_neg", "primitives": ["odds", "dropzeros", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros, then keep the negative numbers.", "solution": "def op_odds_dropzeros_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_dropzeros_neg([1, 2, 3, 4]) == []\nassert op_odds_dropzeros_neg([]) == []\nassert op_odds_dropzeros_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_dropzeros_neg([5, 5, 5]) == []\nassert op_odds_dropzeros_neg([3, 1, 2]) == []\nassert op_odds_dropzeros_neg([10]) == []\nassert op_odds_dropzeros_neg([2, 4, 6]) == []\nassert op_odds_dropzeros_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_dec_len", "entry_point": "op_pos_dec_len", "primitives": ["pos", "dec", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then return how many remain.", "solution": "def op_pos_dec_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    return len(r)", "tests": "assert op_pos_dec_len([1, 2, 3, 4]) == 4\nassert op_pos_dec_len([]) == 0\nassert op_pos_dec_len([-2, -1, 0, 1, 2]) == 2\nassert op_pos_dec_len([5, 5, 5]) == 3\nassert op_pos_dec_len([3, 1, 2]) == 3\nassert op_pos_dec_len([10]) == 1\nassert op_pos_dec_len([2, 4, 6]) == 3\nassert op_pos_dec_len([-7, 12, -7]) == 1"}
{"id": "op_evens_dropfirst_sortabs", "entry_point": "op_evens_dropfirst_sortabs", "primitives": ["evens", "dropfirst", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then sort by absolute value.", "solution": "def op_evens_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_dropfirst_sortabs([1, 2, 3, 4]) == [4]\nassert op_evens_dropfirst_sortabs([]) == []\nassert op_evens_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropfirst_sortabs([5, 5, 5]) == []\nassert op_evens_dropfirst_sortabs([3, 1, 2]) == []\nassert op_evens_dropfirst_sortabs([10]) == []\nassert op_evens_dropfirst_sortabs([2, 4, 6]) == [4, 6]\nassert op_evens_dropfirst_sortabs([-7, 12, -7]) == []"}
{"id": "op_square_rev_last3", "entry_point": "op_square_rev_last3", "primitives": ["square", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then reverse the order, then keep only the last three.", "solution": "def op_square_rev_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_square_rev_last3([1, 2, 3, 4]) == [9, 4, 1]\nassert op_square_rev_last3([]) == []\nassert op_square_rev_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_square_rev_last3([5, 5, 5]) == [25, 25, 25]\nassert op_square_rev_last3([3, 1, 2]) == [4, 1, 9]\nassert op_square_rev_last3([10]) == [100]\nassert op_square_rev_last3([2, 4, 6]) == [36, 16, 4]\nassert op_square_rev_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_dropwhileneg_gt5_absval", "entry_point": "op_dropwhileneg_gt5_absval", "primitives": ["dropwhileneg", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then take the absolute value of each.", "solution": "def op_dropwhileneg_gt5_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_gt5_absval([1, 2, 3, 4]) == []\nassert op_dropwhileneg_gt5_absval([]) == []\nassert op_dropwhileneg_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_gt5_absval([5, 5, 5]) == []\nassert op_dropwhileneg_gt5_absval([3, 1, 2]) == []\nassert op_dropwhileneg_gt5_absval([10]) == [10]\nassert op_dropwhileneg_gt5_absval([2, 4, 6]) == [6]\nassert op_dropwhileneg_gt5_absval([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_evens_add10", "entry_point": "op_dropwhileneg_evens_add10", "primitives": ["dropwhileneg", "evens", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then add ten to each.", "solution": "def op_dropwhileneg_evens_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_evens_add10([1, 2, 3, 4]) == [12, 14]\nassert op_dropwhileneg_evens_add10([]) == []\nassert op_dropwhileneg_evens_add10([-2, -1, 0, 1, 2]) == [10, 12]\nassert op_dropwhileneg_evens_add10([5, 5, 5]) == []\nassert op_dropwhileneg_evens_add10([3, 1, 2]) == [12]\nassert op_dropwhileneg_evens_add10([10]) == [20]\nassert op_dropwhileneg_evens_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_evens_add10([-7, 12, -7]) == [22]"}
{"id": "op_double_clamp10_neg", "entry_point": "op_double_clamp10_neg", "primitives": ["double", "clamp10", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10, then keep the negative numbers.", "solution": "def op_double_clamp10_neg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_double_clamp10_neg([1, 2, 3, 4]) == []\nassert op_double_clamp10_neg([]) == []\nassert op_double_clamp10_neg([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_clamp10_neg([5, 5, 5]) == []\nassert op_double_clamp10_neg([3, 1, 2]) == []\nassert op_double_clamp10_neg([10]) == []\nassert op_double_clamp10_neg([2, 4, 6]) == []\nassert op_double_clamp10_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_trimends_div3_prod", "entry_point": "op_trimends_div3_prod", "primitives": ["trimends", "div3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep multiples of three, then return their product.", "solution": "def op_trimends_div3_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_trimends_div3_prod([1, 2, 3, 4]) == 3\nassert op_trimends_div3_prod([]) == 1\nassert op_trimends_div3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_div3_prod([5, 5, 5]) == 1\nassert op_trimends_div3_prod([3, 1, 2]) == 1\nassert op_trimends_div3_prod([10]) == 1\nassert op_trimends_div3_prod([2, 4, 6]) == 1\nassert op_trimends_div3_prod([-7, 12, -7]) == 12"}
{"id": "op_evens_uniq_oremptyzero", "entry_point": "op_evens_uniq_oremptyzero", "primitives": ["evens", "uniq", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop duplicates keeping first occurrence, then if empty, use a single zero.", "solution": "def op_evens_uniq_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_uniq_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_uniq_oremptyzero([]) == [0]\nassert op_evens_uniq_oremptyzero([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_uniq_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_uniq_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_uniq_oremptyzero([10]) == [10]\nassert op_evens_uniq_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_uniq_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_first3_oremptyzero_rev", "entry_point": "op_first3_oremptyzero_rev", "primitives": ["first3", "oremptyzero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then reverse the order.", "solution": "def op_first3_oremptyzero_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_oremptyzero_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_oremptyzero_rev([]) == [0]\nassert op_first3_oremptyzero_rev([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_oremptyzero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_first3_oremptyzero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_first3_oremptyzero_rev([10]) == [10]\nassert op_first3_oremptyzero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_first3_oremptyzero_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_absval_takewhilepos_dropzeros", "entry_point": "op_absval_takewhilepos_dropzeros", "primitives": ["absval", "takewhilepos", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then drop the zeros.", "solution": "def op_absval_takewhilepos_dropzeros(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_absval_takewhilepos_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos_dropzeros([]) == []\nassert op_absval_takewhilepos_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_takewhilepos_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_absval_takewhilepos_dropzeros([10]) == [10]\nassert op_absval_takewhilepos_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_dropzeros([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_dropfirst_sortd_absval", "entry_point": "op_dropfirst_sortd_absval", "primitives": ["dropfirst", "sortd", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then take the absolute value of each.", "solution": "def op_dropfirst_sortd_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_sortd_absval([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_sortd_absval([]) == []\nassert op_dropfirst_sortd_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1]\nassert op_dropfirst_sortd_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortd_absval([3, 1, 2]) == [2, 1]\nassert op_dropfirst_sortd_absval([10]) == []\nassert op_dropfirst_sortd_absval([2, 4, 6]) == [6, 4]\nassert op_dropfirst_sortd_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_dropwhileneg_rev_allpos", "entry_point": "op_dropwhileneg_rev_allpos", "primitives": ["dropwhileneg", "rev", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then return whether all values are positive.", "solution": "def op_dropwhileneg_rev_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_rev_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_rev_allpos([]) == True\nassert op_dropwhileneg_rev_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_rev_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_rev_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_rev_allpos([10]) == True\nassert op_dropwhileneg_rev_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_rev_allpos([-7, 12, -7]) == False"}
{"id": "op_dropfirst_uniq_dec", "entry_point": "op_dropfirst_uniq_dec", "primitives": ["dropfirst", "uniq", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then subtract one from each.", "solution": "def op_dropfirst_uniq_dec(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropfirst_uniq_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_uniq_dec([]) == []\nassert op_dropfirst_uniq_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dropfirst_uniq_dec([5, 5, 5]) == [4]\nassert op_dropfirst_uniq_dec([3, 1, 2]) == [0, 1]\nassert op_dropfirst_uniq_dec([10]) == []\nassert op_dropfirst_uniq_dec([2, 4, 6]) == [3, 5]\nassert op_dropfirst_uniq_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_inc_takewhilepos_allpos", "entry_point": "op_inc_takewhilepos_allpos", "primitives": ["inc", "takewhilepos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive, then return whether all values are positive.", "solution": "def op_inc_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_inc_takewhilepos_allpos([]) == True\nassert op_inc_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_inc_takewhilepos_allpos([5, 5, 5]) == True\nassert op_inc_takewhilepos_allpos([3, 1, 2]) == True\nassert op_inc_takewhilepos_allpos([10]) == True\nassert op_inc_takewhilepos_allpos([2, 4, 6]) == True\nassert op_inc_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_add10_gt5", "entry_point": "op_dropwhileneg_add10_gt5", "primitives": ["dropwhileneg", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then keep values greater than five.", "solution": "def op_dropwhileneg_add10_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_add10_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_add10_gt5([]) == []\nassert op_dropwhileneg_add10_gt5([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_add10_gt5([10]) == [20]\nassert op_dropwhileneg_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_add10_dropzeros_oremptyzero", "entry_point": "op_add10_dropzeros_oremptyzero", "primitives": ["add10", "dropzeros", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then if empty, use a single zero.", "solution": "def op_add10_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_dropzeros_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros_oremptyzero([]) == [0]\nassert op_add10_dropzeros_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropzeros_oremptyzero([10]) == [20]\nassert op_add10_dropzeros_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros_oremptyzero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_uniq_neg_negate", "entry_point": "op_uniq_neg_negate", "primitives": ["uniq", "neg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers, then negate each.", "solution": "def op_uniq_neg_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_neg_negate([1, 2, 3, 4]) == []\nassert op_uniq_neg_negate([]) == []\nassert op_uniq_neg_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_uniq_neg_negate([5, 5, 5]) == []\nassert op_uniq_neg_negate([3, 1, 2]) == []\nassert op_uniq_neg_negate([10]) == []\nassert op_uniq_neg_negate([2, 4, 6]) == []\nassert op_uniq_neg_negate([-7, 12, -7]) == [7]"}
{"id": "op_clamp10_beforezero_last3", "entry_point": "op_clamp10_beforezero_last3", "primitives": ["clamp10", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then keep only the last three.", "solution": "def op_clamp10_beforezero_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_beforezero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_beforezero_last3([]) == []\nassert op_clamp10_beforezero_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_beforezero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_beforezero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_beforezero_last3([10]) == [10]\nassert op_clamp10_beforezero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_beforezero_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_padto3_gt5_dropwhileneg", "entry_point": "op_padto3_gt5_dropwhileneg", "primitives": ["padto3", "gt5", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then drop the leading negative values.", "solution": "def op_padto3_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_padto3_gt5_dropwhileneg([]) == []\nassert op_padto3_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_padto3_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_padto3_gt5_dropwhileneg([10]) == [10]\nassert op_padto3_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_padto3_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_pos_sortabs_first3", "entry_point": "op_pos_sortabs_first3", "primitives": ["pos", "sortabs", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then keep only the first three.", "solution": "def op_pos_sortabs_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_pos_sortabs_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_sortabs_first3([]) == []\nassert op_pos_sortabs_first3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_sortabs_first3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_sortabs_first3([3, 1, 2]) == [1, 2, 3]\nassert op_pos_sortabs_first3([10]) == [10]\nassert op_pos_sortabs_first3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_sortabs_first3([-7, 12, -7]) == [12]"}
{"id": "op_sorta_add10_div3", "entry_point": "op_sorta_add10_div3", "primitives": ["sorta", "add10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then keep multiples of three.", "solution": "def op_sorta_add10_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_add10_div3([1, 2, 3, 4]) == [12]\nassert op_sorta_add10_div3([]) == []\nassert op_sorta_add10_div3([-2, -1, 0, 1, 2]) == [9, 12]\nassert op_sorta_add10_div3([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_add10_div3([3, 1, 2]) == [12]\nassert op_sorta_add10_div3([10]) == []\nassert op_sorta_add10_div3([2, 4, 6]) == [12]\nassert op_sorta_add10_div3([-7, 12, -7]) == [3, 3]"}
{"id": "op_negate_square_first3", "entry_point": "op_negate_square_first3", "primitives": ["negate", "square", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then keep only the first three.", "solution": "def op_negate_square_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_negate_square_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_negate_square_first3([]) == []\nassert op_negate_square_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_negate_square_first3([5, 5, 5]) == [25, 25, 25]\nassert op_negate_square_first3([3, 1, 2]) == [9, 1, 4]\nassert op_negate_square_first3([10]) == [100]\nassert op_negate_square_first3([2, 4, 6]) == [4, 16, 36]\nassert op_negate_square_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_gt5_odds_rev", "entry_point": "op_gt5_odds_rev", "primitives": ["gt5", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the odd numbers, then reverse the order.", "solution": "def op_gt5_odds_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_gt5_odds_rev([1, 2, 3, 4]) == []\nassert op_gt5_odds_rev([]) == []\nassert op_gt5_odds_rev([-2, -1, 0, 1, 2]) == []\nassert op_gt5_odds_rev([5, 5, 5]) == []\nassert op_gt5_odds_rev([3, 1, 2]) == []\nassert op_gt5_odds_rev([10]) == []\nassert op_gt5_odds_rev([2, 4, 6]) == []\nassert op_gt5_odds_rev([-7, 12, -7]) == []"}
{"id": "op_gt5_dec_absval", "entry_point": "op_gt5_dec_absval", "primitives": ["gt5", "dec", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then take the absolute value of each.", "solution": "def op_gt5_dec_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_dec_absval([1, 2, 3, 4]) == []\nassert op_gt5_dec_absval([]) == []\nassert op_gt5_dec_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dec_absval([5, 5, 5]) == []\nassert op_gt5_dec_absval([3, 1, 2]) == []\nassert op_gt5_dec_absval([10]) == [9]\nassert op_gt5_dec_absval([2, 4, 6]) == [5]\nassert op_gt5_dec_absval([-7, 12, -7]) == [11]"}
{"id": "op_pos_evens_rev", "entry_point": "op_pos_evens_rev", "primitives": ["pos", "evens", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then reverse the order.", "solution": "def op_pos_evens_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_pos_evens_rev([]) == []\nassert op_pos_evens_rev([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_evens_rev([5, 5, 5]) == []\nassert op_pos_evens_rev([3, 1, 2]) == [2]\nassert op_pos_evens_rev([10]) == [10]\nassert op_pos_evens_rev([2, 4, 6]) == [6, 4, 2]\nassert op_pos_evens_rev([-7, 12, -7]) == [12]"}
{"id": "op_div3_beforezero_prod", "entry_point": "op_div3_beforezero_prod", "primitives": ["div3", "beforezero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then return their product.", "solution": "def op_div3_beforezero_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_div3_beforezero_prod([1, 2, 3, 4]) == 3\nassert op_div3_beforezero_prod([]) == 1\nassert op_div3_beforezero_prod([-2, -1, 0, 1, 2]) == 1\nassert op_div3_beforezero_prod([5, 5, 5]) == 1\nassert op_div3_beforezero_prod([3, 1, 2]) == 3\nassert op_div3_beforezero_prod([10]) == 1\nassert op_div3_beforezero_prod([2, 4, 6]) == 6\nassert op_div3_beforezero_prod([-7, 12, -7]) == 12"}
{"id": "op_beforezero_rev_prod", "entry_point": "op_beforezero_rev_prod", "primitives": ["beforezero", "rev", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then return their product.", "solution": "def op_beforezero_rev_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_rev_prod([1, 2, 3, 4]) == 24\nassert op_beforezero_rev_prod([]) == 1\nassert op_beforezero_rev_prod([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_rev_prod([5, 5, 5]) == 125\nassert op_beforezero_rev_prod([3, 1, 2]) == 6\nassert op_beforezero_rev_prod([10]) == 10\nassert op_beforezero_rev_prod([2, 4, 6]) == 48\nassert op_beforezero_rev_prod([-7, 12, -7]) == 588"}
{"id": "op_rev_sortd_counteven", "entry_point": "op_rev_sortd_counteven", "primitives": ["rev", "sortd", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then return how many values are even.", "solution": "def op_rev_sortd_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_sortd_counteven([1, 2, 3, 4]) == 2\nassert op_rev_sortd_counteven([]) == 0\nassert op_rev_sortd_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_rev_sortd_counteven([5, 5, 5]) == 0\nassert op_rev_sortd_counteven([3, 1, 2]) == 1\nassert op_rev_sortd_counteven([10]) == 1\nassert op_rev_sortd_counteven([2, 4, 6]) == 3\nassert op_rev_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_padto3_inc_counteven", "entry_point": "op_padto3_inc_counteven", "primitives": ["padto3", "inc", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then return how many values are even.", "solution": "def op_padto3_inc_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_inc_counteven([1, 2, 3, 4]) == 2\nassert op_padto3_inc_counteven([]) == 0\nassert op_padto3_inc_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_inc_counteven([5, 5, 5]) == 3\nassert op_padto3_inc_counteven([3, 1, 2]) == 2\nassert op_padto3_inc_counteven([10]) == 0\nassert op_padto3_inc_counteven([2, 4, 6]) == 0\nassert op_padto3_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_div3_dropwhileneg_max", "entry_point": "op_div3_dropwhileneg_max", "primitives": ["div3", "dropwhileneg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_div3_dropwhileneg_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_div3_dropwhileneg_max([1, 2, 3, 4]) == 3\nassert op_div3_dropwhileneg_max([]) == 0\nassert op_div3_dropwhileneg_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_dropwhileneg_max([5, 5, 5]) == 0\nassert op_div3_dropwhileneg_max([3, 1, 2]) == 3\nassert op_div3_dropwhileneg_max([10]) == 0\nassert op_div3_dropwhileneg_max([2, 4, 6]) == 6\nassert op_div3_dropwhileneg_max([-7, 12, -7]) == 12"}
{"id": "op_last3_oremptyzero_min", "entry_point": "op_last3_oremptyzero_min", "primitives": ["last3", "oremptyzero", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_last3_oremptyzero_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_last3_oremptyzero_min([1, 2, 3, 4]) == 2\nassert op_last3_oremptyzero_min([]) == 0\nassert op_last3_oremptyzero_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_oremptyzero_min([5, 5, 5]) == 5\nassert op_last3_oremptyzero_min([3, 1, 2]) == 1\nassert op_last3_oremptyzero_min([10]) == 10\nassert op_last3_oremptyzero_min([2, 4, 6]) == 2\nassert op_last3_oremptyzero_min([-7, 12, -7]) == -7"}
{"id": "op_first3_pos_sortabs", "entry_point": "op_first3_pos_sortabs", "primitives": ["first3", "pos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then sort by absolute value.", "solution": "def op_first3_pos_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_pos_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_pos_sortabs([]) == []\nassert op_first3_pos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_pos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_pos_sortabs([10]) == [10]\nassert op_first3_pos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_last3_double", "entry_point": "op_dropfirst_last3_double", "primitives": ["dropfirst", "last3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then double each.", "solution": "def op_dropfirst_last3_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_last3_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropfirst_last3_double([]) == []\nassert op_dropfirst_last3_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropfirst_last3_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_last3_double([3, 1, 2]) == [2, 4]\nassert op_dropfirst_last3_double([10]) == []\nassert op_dropfirst_last3_double([2, 4, 6]) == [8, 12]\nassert op_dropfirst_last3_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_uniq_first3_neg", "entry_point": "op_uniq_first3_neg", "primitives": ["uniq", "first3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the first three, then keep the negative numbers.", "solution": "def op_uniq_first3_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_first3_neg([1, 2, 3, 4]) == []\nassert op_uniq_first3_neg([]) == []\nassert op_uniq_first3_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_first3_neg([5, 5, 5]) == []\nassert op_uniq_first3_neg([3, 1, 2]) == []\nassert op_uniq_first3_neg([10]) == []\nassert op_uniq_first3_neg([2, 4, 6]) == []\nassert op_uniq_first3_neg([-7, 12, -7]) == [-7]"}
{"id": "op_sortabs_rev_negate", "entry_point": "op_sortabs_rev_negate", "primitives": ["sortabs", "rev", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then negate each.", "solution": "def op_sortabs_rev_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_rev_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sortabs_rev_negate([]) == []\nassert op_sortabs_rev_negate([-2, -1, 0, 1, 2]) == [-2, 2, -1, 1, 0]\nassert op_sortabs_rev_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_rev_negate([3, 1, 2]) == [-3, -2, -1]\nassert op_sortabs_rev_negate([10]) == [-10]\nassert op_sortabs_rev_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_sortabs_rev_negate([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_dropwhileneg_oremptyzero_haszero", "entry_point": "op_dropwhileneg_oremptyzero_haszero", "primitives": ["dropwhileneg", "oremptyzero", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_dropwhileneg_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_oremptyzero_haszero([]) == True\nassert op_dropwhileneg_oremptyzero_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_oremptyzero_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_oremptyzero_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_oremptyzero_haszero([10]) == False\nassert op_dropwhileneg_oremptyzero_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_rev_dropwhileneg", "entry_point": "op_padto3_rev_dropwhileneg", "primitives": ["padto3", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order, then drop the leading negative values.", "solution": "def op_padto3_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_rev_dropwhileneg([]) == [0, 0, 0]\nassert op_padto3_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_rev_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_rev_dropwhileneg([10]) == [0, 0, 10]\nassert op_padto3_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_rev_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_negate_dec_padto3", "entry_point": "op_negate_dec_padto3", "primitives": ["negate", "dec", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_negate_dec_padto3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_negate_dec_padto3([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_negate_dec_padto3([]) == [0, 0, 0]\nassert op_negate_dec_padto3([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_negate_dec_padto3([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_dec_padto3([3, 1, 2]) == [-4, -2, -3]\nassert op_negate_dec_padto3([10]) == [-11, 0, 0]\nassert op_negate_dec_padto3([2, 4, 6]) == [-3, -5, -7]\nassert op_negate_dec_padto3([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_nonempty_upper_prefixup", "entry_point": "op_nonempty_upper_prefixup", "primitives": ["nonempty", "upper", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then uppercase each string, then prefix each with a hash.", "solution": "def op_nonempty_upper_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.upper() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_nonempty_upper_prefixup(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_nonempty_upper_prefixup([]) == []\nassert op_nonempty_upper_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ', '#BC', '#BC']\nassert op_nonempty_upper_prefixup(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_nonempty_upper_prefixup(['x']) == ['#X']\nassert op_nonempty_upper_prefixup(['abc', 'de', '']) == ['#ABC', '#DE']"}
{"id": "op_dropfirst_inc_dropzeros", "entry_point": "op_dropfirst_inc_dropzeros", "primitives": ["dropfirst", "inc", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add one to each, then drop the zeros.", "solution": "def op_dropfirst_inc_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_inc_dropzeros([1, 2, 3, 4]) == [3, 4, 5]\nassert op_dropfirst_inc_dropzeros([]) == []\nassert op_dropfirst_inc_dropzeros([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropfirst_inc_dropzeros([5, 5, 5]) == [6, 6]\nassert op_dropfirst_inc_dropzeros([3, 1, 2]) == [2, 3]\nassert op_dropfirst_inc_dropzeros([10]) == []\nassert op_dropfirst_inc_dropzeros([2, 4, 6]) == [5, 7]\nassert op_dropfirst_inc_dropzeros([-7, 12, -7]) == [13, -6]"}
{"id": "op_evens_trimends_gt5", "entry_point": "op_evens_trimends_gt5", "primitives": ["evens", "trimends", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then keep values greater than five.", "solution": "def op_evens_trimends_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_trimends_gt5([1, 2, 3, 4]) == []\nassert op_evens_trimends_gt5([]) == []\nassert op_evens_trimends_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_trimends_gt5([5, 5, 5]) == []\nassert op_evens_trimends_gt5([3, 1, 2]) == []\nassert op_evens_trimends_gt5([10]) == []\nassert op_evens_trimends_gt5([2, 4, 6]) == []\nassert op_evens_trimends_gt5([-7, 12, -7]) == []"}
{"id": "op_square_padto3_sortabs", "entry_point": "op_square_padto3_sortabs", "primitives": ["square", "padto3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_square_padto3_sortabs(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_square_padto3_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_padto3_sortabs([]) == [0, 0, 0]\nassert op_square_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_square_padto3_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_square_padto3_sortabs([10]) == [0, 0, 100]\nassert op_square_padto3_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_square_padto3_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_oremptyzero_sortd_dropfirst", "entry_point": "op_oremptyzero_sortd_dropfirst", "primitives": ["oremptyzero", "sortd", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending, then drop the first element.", "solution": "def op_oremptyzero_sortd_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_sortd_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_oremptyzero_sortd_dropfirst([]) == []\nassert op_oremptyzero_sortd_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_oremptyzero_sortd_dropfirst([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_sortd_dropfirst([3, 1, 2]) == [2, 1]\nassert op_oremptyzero_sortd_dropfirst([10]) == []\nassert op_oremptyzero_sortd_dropfirst([2, 4, 6]) == [4, 2]\nassert op_oremptyzero_sortd_dropfirst([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_last3_clamp10", "entry_point": "op_pos_last3_clamp10", "primitives": ["pos", "last3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then cap each value at 10.", "solution": "def op_pos_last3_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_last3_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_last3_clamp10([]) == []\nassert op_pos_last3_clamp10([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_last3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_pos_last3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_pos_last3_clamp10([10]) == [10]\nassert op_pos_last3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_pos_last3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_last3_add10_alldistinct", "entry_point": "op_last3_add10_alldistinct", "primitives": ["last3", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then return whether all values are distinct.", "solution": "def op_last3_add10_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_last3_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_add10_alldistinct([]) == True\nassert op_last3_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_add10_alldistinct([5, 5, 5]) == False\nassert op_last3_add10_alldistinct([3, 1, 2]) == True\nassert op_last3_add10_alldistinct([10]) == True\nassert op_last3_add10_alldistinct([2, 4, 6]) == True\nassert op_last3_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_evens_sorta_sortabs", "entry_point": "op_evens_sorta_sortabs", "primitives": ["evens", "sorta", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then sort by absolute value.", "solution": "def op_evens_sorta_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_sorta_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_evens_sorta_sortabs([]) == []\nassert op_evens_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_evens_sorta_sortabs([5, 5, 5]) == []\nassert op_evens_sorta_sortabs([3, 1, 2]) == [2]\nassert op_evens_sorta_sortabs([10]) == [10]\nassert op_evens_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_evens_sorta_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_odds_dropwhileneg_uniq", "entry_point": "op_odds_dropwhileneg_uniq", "primitives": ["odds", "dropwhileneg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_odds_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_odds_dropwhileneg_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_odds_dropwhileneg_uniq([]) == []\nassert op_odds_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropwhileneg_uniq([5, 5, 5]) == [5]\nassert op_odds_dropwhileneg_uniq([3, 1, 2]) == [3, 1]\nassert op_odds_dropwhileneg_uniq([10]) == []\nassert op_odds_dropwhileneg_uniq([2, 4, 6]) == []\nassert op_odds_dropwhileneg_uniq([-7, 12, -7]) == []"}
{"id": "op_dec_last3_rev", "entry_point": "op_dec_last3_rev", "primitives": ["dec", "last3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then reverse the order.", "solution": "def op_dec_last3_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_last3_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dec_last3_rev([]) == []\nassert op_dec_last3_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_dec_last3_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_last3_rev([3, 1, 2]) == [1, 0, 2]\nassert op_dec_last3_rev([10]) == [9]\nassert op_dec_last3_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_last3_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_sortd_first3_takewhilepos", "entry_point": "op_sortd_first3_takewhilepos", "primitives": ["sortd", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the first three, then take values while they are positive.", "solution": "def op_sortd_first3_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_first3_takewhilepos([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortd_first3_takewhilepos([]) == []\nassert op_sortd_first3_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_first3_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_first3_takewhilepos([10]) == [10]\nassert op_sortd_first3_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_first3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dec_add10_dropwhileneg", "entry_point": "op_dec_add10_dropwhileneg", "primitives": ["dec", "add10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then drop the leading negative values.", "solution": "def op_dec_add10_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_add10_dropwhileneg([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_dec_add10_dropwhileneg([]) == []\nassert op_dec_add10_dropwhileneg([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_dec_add10_dropwhileneg([5, 5, 5]) == [14, 14, 14]\nassert op_dec_add10_dropwhileneg([3, 1, 2]) == [12, 10, 11]\nassert op_dec_add10_dropwhileneg([10]) == [19]\nassert op_dec_add10_dropwhileneg([2, 4, 6]) == [11, 13, 15]\nassert op_dec_add10_dropwhileneg([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_dropfirst_first3_uniq", "entry_point": "op_dropfirst_first3_uniq", "primitives": ["dropfirst", "first3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_first3_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_first3_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_first3_uniq([]) == []\nassert op_dropfirst_first3_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dropfirst_first3_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_first3_uniq([3, 1, 2]) == [1, 2]\nassert op_dropfirst_first3_uniq([10]) == []\nassert op_dropfirst_first3_uniq([2, 4, 6]) == [4, 6]\nassert op_dropfirst_first3_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_uniq_last3_prod", "entry_point": "op_uniq_last3_prod", "primitives": ["uniq", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three, then return their product.", "solution": "def op_uniq_last3_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_uniq_last3_prod([1, 2, 3, 4]) == 24\nassert op_uniq_last3_prod([]) == 1\nassert op_uniq_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_last3_prod([5, 5, 5]) == 5\nassert op_uniq_last3_prod([3, 1, 2]) == 6\nassert op_uniq_last3_prod([10]) == 10\nassert op_uniq_last3_prod([2, 4, 6]) == 48\nassert op_uniq_last3_prod([-7, 12, -7]) == -84"}
{"id": "op_dec_pos_evens", "entry_point": "op_dec_pos_evens", "primitives": ["dec", "pos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then keep the even numbers.", "solution": "def op_dec_pos_evens(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dec_pos_evens([1, 2, 3, 4]) == [2]\nassert op_dec_pos_evens([]) == []\nassert op_dec_pos_evens([-2, -1, 0, 1, 2]) == []\nassert op_dec_pos_evens([5, 5, 5]) == [4, 4, 4]\nassert op_dec_pos_evens([3, 1, 2]) == [2]\nassert op_dec_pos_evens([10]) == []\nassert op_dec_pos_evens([2, 4, 6]) == []\nassert op_dec_pos_evens([-7, 12, -7]) == []"}
{"id": "op_inc_div3_counteven", "entry_point": "op_inc_div3_counteven", "primitives": ["inc", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then return how many values are even.", "solution": "def op_inc_div3_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_div3_counteven([1, 2, 3, 4]) == 0\nassert op_inc_div3_counteven([]) == 0\nassert op_inc_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_inc_div3_counteven([5, 5, 5]) == 3\nassert op_inc_div3_counteven([3, 1, 2]) == 0\nassert op_inc_div3_counteven([10]) == 0\nassert op_inc_div3_counteven([2, 4, 6]) == 0\nassert op_inc_div3_counteven([-7, 12, -7]) == 2"}
{"id": "op_pos_clamp10_dropzeros", "entry_point": "op_pos_clamp10_dropzeros", "primitives": ["pos", "clamp10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then drop the zeros.", "solution": "def op_pos_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_clamp10_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_clamp10_dropzeros([]) == []\nassert op_pos_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_clamp10_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_clamp10_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10_dropzeros([10]) == [10]\nassert op_pos_clamp10_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10_dropzeros([-7, 12, -7]) == [10]"}
{"id": "op_oremptyzero_sortd_haszero", "entry_point": "op_oremptyzero_sortd_haszero", "primitives": ["oremptyzero", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending, then return whether the list contains a zero.", "solution": "def op_oremptyzero_sortd_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_oremptyzero_sortd_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_sortd_haszero([]) == True\nassert op_oremptyzero_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_sortd_haszero([5, 5, 5]) == False\nassert op_oremptyzero_sortd_haszero([3, 1, 2]) == False\nassert op_oremptyzero_sortd_haszero([10]) == False\nassert op_oremptyzero_sortd_haszero([2, 4, 6]) == False\nassert op_oremptyzero_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_negate_evens", "entry_point": "op_dec_negate_evens", "primitives": ["dec", "negate", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then keep the even numbers.", "solution": "def op_dec_negate_evens(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dec_negate_evens([1, 2, 3, 4]) == [0, -2]\nassert op_dec_negate_evens([]) == []\nassert op_dec_negate_evens([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dec_negate_evens([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_negate_evens([3, 1, 2]) == [-2, 0]\nassert op_dec_negate_evens([10]) == []\nassert op_dec_negate_evens([2, 4, 6]) == []\nassert op_dec_negate_evens([-7, 12, -7]) == [8, 8]"}
{"id": "op_sortabs_double_trimends", "entry_point": "op_sortabs_double_trimends", "primitives": ["sortabs", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then drop the first and last elements.", "solution": "def op_sortabs_double_trimends(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortabs_double_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_sortabs_double_trimends([]) == []\nassert op_sortabs_double_trimends([-2, -1, 0, 1, 2]) == [-2, 2, -4]\nassert op_sortabs_double_trimends([5, 5, 5]) == [10]\nassert op_sortabs_double_trimends([3, 1, 2]) == [4]\nassert op_sortabs_double_trimends([10]) == []\nassert op_sortabs_double_trimends([2, 4, 6]) == [8]\nassert op_sortabs_double_trimends([-7, 12, -7]) == [-14]"}
{"id": "op_dropwhileneg_absval_first3", "entry_point": "op_dropwhileneg_absval_first3", "primitives": ["dropwhileneg", "absval", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each, then keep only the first three.", "solution": "def op_dropwhileneg_absval_first3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropwhileneg_absval_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropwhileneg_absval_first3([]) == []\nassert op_dropwhileneg_absval_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_absval_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_absval_first3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_absval_first3([10]) == [10]\nassert op_dropwhileneg_absval_first3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_absval_first3([-7, 12, -7]) == [12, 7]"}
{"id": "op_takewhilepos_evens_dropzeros", "entry_point": "op_takewhilepos_evens_dropzeros", "primitives": ["takewhilepos", "evens", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers, then drop the zeros.", "solution": "def op_takewhilepos_evens_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_evens_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_takewhilepos_evens_dropzeros([]) == []\nassert op_takewhilepos_evens_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens_dropzeros([5, 5, 5]) == []\nassert op_takewhilepos_evens_dropzeros([3, 1, 2]) == [2]\nassert op_takewhilepos_evens_dropzeros([10]) == [10]\nassert op_takewhilepos_evens_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_evens_dropzeros([-7, 12, -7]) == []"}
{"id": "op_uniqs_dropshort_sortalpha", "entry_point": "op_uniqs_dropshort_sortalpha", "primitives": ["uniqs", "dropshort", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop strings shorter than three characters, then sort alphabetically.", "solution": "def op_uniqs_dropshort_sortalpha(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r)\n    return r", "tests": "assert op_uniqs_dropshort_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_dropshort_sortalpha([]) == []\nassert op_uniqs_dropshort_sortalpha(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_uniqs_dropshort_sortalpha(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_uniqs_dropshort_sortalpha(['x']) == []\nassert op_uniqs_dropshort_sortalpha(['abc', 'de', '']) == ['abc']"}
{"id": "op_dropzeros_takewhilepos_last3", "entry_point": "op_dropzeros_takewhilepos_last3", "primitives": ["dropzeros", "takewhilepos", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then keep only the last three.", "solution": "def op_dropzeros_takewhilepos_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_takewhilepos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_takewhilepos_last3([]) == []\nassert op_dropzeros_takewhilepos_last3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos_last3([10]) == [10]\nassert op_dropzeros_takewhilepos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos_last3([-7, 12, -7]) == []"}
{"id": "op_gt5_dropfirst_allpos", "entry_point": "op_gt5_dropfirst_allpos", "primitives": ["gt5", "dropfirst", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then return whether all values are positive.", "solution": "def op_gt5_dropfirst_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_gt5_dropfirst_allpos([]) == True\nassert op_gt5_dropfirst_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_dropfirst_allpos([5, 5, 5]) == True\nassert op_gt5_dropfirst_allpos([3, 1, 2]) == True\nassert op_gt5_dropfirst_allpos([10]) == True\nassert op_gt5_dropfirst_allpos([2, 4, 6]) == True\nassert op_gt5_dropfirst_allpos([-7, 12, -7]) == True"}
{"id": "op_add10_oremptyzero_first3", "entry_point": "op_add10_oremptyzero_first3", "primitives": ["add10", "oremptyzero", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then keep only the first three.", "solution": "def op_add10_oremptyzero_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    r = r[:3]\n    return r", "tests": "assert op_add10_oremptyzero_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_oremptyzero_first3([]) == [0]\nassert op_add10_oremptyzero_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_oremptyzero_first3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_oremptyzero_first3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_oremptyzero_first3([10]) == [20]\nassert op_add10_oremptyzero_first3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_oremptyzero_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_add10_clamp10_sortabs", "entry_point": "op_add10_clamp10_sortabs", "primitives": ["add10", "clamp10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then sort by absolute value.", "solution": "def op_add10_clamp10_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_clamp10_sortabs([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_clamp10_sortabs([]) == []\nassert op_add10_clamp10_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_clamp10_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_add10_clamp10_sortabs([3, 1, 2]) == [10, 10, 10]\nassert op_add10_clamp10_sortabs([10]) == [10]\nassert op_add10_clamp10_sortabs([2, 4, 6]) == [10, 10, 10]\nassert op_add10_clamp10_sortabs([-7, 12, -7]) == [3, 3, 10]"}
{"id": "op_absval_padto3_clamp10", "entry_point": "op_absval_padto3_clamp10", "primitives": ["absval", "padto3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then cap each value at 10.", "solution": "def op_absval_padto3_clamp10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_absval_padto3_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_padto3_clamp10([]) == [0, 0, 0]\nassert op_absval_padto3_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_padto3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_absval_padto3_clamp10([10]) == [10, 0, 0]\nassert op_absval_padto3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_absval_padto3_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_upper_lower_strip", "entry_point": "op_upper_lower_strip", "primitives": ["upper", "lower", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then lowercase each string, then trim whitespace from each.", "solution": "def op_upper_lower_strip(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_upper_lower_strip(['Hello', 'world']) == ['hello', 'world']\nassert op_upper_lower_strip([]) == []\nassert op_upper_lower_strip(['  a ', '', 'BC', 'bc']) == ['a', '', 'bc', 'bc']\nassert op_upper_lower_strip(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_upper_lower_strip(['x']) == ['x']\nassert op_upper_lower_strip(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_rev_sortd_pos", "entry_point": "op_rev_sortd_pos", "primitives": ["rev", "sortd", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then keep the positive numbers.", "solution": "def op_rev_sortd_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_sortd_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_sortd_pos([]) == []\nassert op_rev_sortd_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_sortd_pos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortd_pos([3, 1, 2]) == [3, 2, 1]\nassert op_rev_sortd_pos([10]) == [10]\nassert op_rev_sortd_pos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_sortd_pos([-7, 12, -7]) == [12]"}
{"id": "op_absval_clamp10_dropwhileneg", "entry_point": "op_absval_clamp10_dropwhileneg", "primitives": ["absval", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then drop the leading negative values.", "solution": "def op_absval_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_clamp10_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_clamp10_dropwhileneg([]) == []\nassert op_absval_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_clamp10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_clamp10_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_absval_clamp10_dropwhileneg([10]) == [10]\nassert op_absval_clamp10_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_absval_clamp10_dropwhileneg([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_clamp10_evens_first3", "entry_point": "op_clamp10_evens_first3", "primitives": ["clamp10", "evens", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers, then keep only the first three.", "solution": "def op_clamp10_evens_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_evens_first3([1, 2, 3, 4]) == [2, 4]\nassert op_clamp10_evens_first3([]) == []\nassert op_clamp10_evens_first3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_clamp10_evens_first3([5, 5, 5]) == []\nassert op_clamp10_evens_first3([3, 1, 2]) == [2]\nassert op_clamp10_evens_first3([10]) == [10]\nassert op_clamp10_evens_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_evens_first3([-7, 12, -7]) == [10]"}
{"id": "op_odds_absval_trimends", "entry_point": "op_odds_absval_trimends", "primitives": ["odds", "absval", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_odds_absval_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_absval_trimends([1, 2, 3, 4]) == []\nassert op_odds_absval_trimends([]) == []\nassert op_odds_absval_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_absval_trimends([5, 5, 5]) == [5]\nassert op_odds_absval_trimends([3, 1, 2]) == []\nassert op_odds_absval_trimends([10]) == []\nassert op_odds_absval_trimends([2, 4, 6]) == []\nassert op_odds_absval_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_square_neg", "entry_point": "op_add10_square_neg", "primitives": ["add10", "square", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then keep the negative numbers.", "solution": "def op_add10_square_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_square_neg([1, 2, 3, 4]) == []\nassert op_add10_square_neg([]) == []\nassert op_add10_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_square_neg([5, 5, 5]) == []\nassert op_add10_square_neg([3, 1, 2]) == []\nassert op_add10_square_neg([10]) == []\nassert op_add10_square_neg([2, 4, 6]) == []\nassert op_add10_square_neg([-7, 12, -7]) == []"}
{"id": "op_absval_last3_prod", "entry_point": "op_absval_last3_prod", "primitives": ["absval", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then return their product.", "solution": "def op_absval_last3_prod(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_absval_last3_prod([1, 2, 3, 4]) == 24\nassert op_absval_last3_prod([]) == 1\nassert op_absval_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_absval_last3_prod([5, 5, 5]) == 125\nassert op_absval_last3_prod([3, 1, 2]) == 6\nassert op_absval_last3_prod([10]) == 10\nassert op_absval_last3_prod([2, 4, 6]) == 48\nassert op_absval_last3_prod([-7, 12, -7]) == 588"}
{"id": "op_last3_div3_pos", "entry_point": "op_last3_div3_pos", "primitives": ["last3", "div3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then keep the positive numbers.", "solution": "def op_last3_div3_pos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_last3_div3_pos([1, 2, 3, 4]) == [3]\nassert op_last3_div3_pos([]) == []\nassert op_last3_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_last3_div3_pos([5, 5, 5]) == []\nassert op_last3_div3_pos([3, 1, 2]) == [3]\nassert op_last3_div3_pos([10]) == []\nassert op_last3_div3_pos([2, 4, 6]) == [6]\nassert op_last3_div3_pos([-7, 12, -7]) == [12]"}
{"id": "op_neg_uniq_dec", "entry_point": "op_neg_uniq_dec", "primitives": ["neg", "uniq", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then subtract one from each.", "solution": "def op_neg_uniq_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_neg_uniq_dec([1, 2, 3, 4]) == []\nassert op_neg_uniq_dec([]) == []\nassert op_neg_uniq_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_neg_uniq_dec([5, 5, 5]) == []\nassert op_neg_uniq_dec([3, 1, 2]) == []\nassert op_neg_uniq_dec([10]) == []\nassert op_neg_uniq_dec([2, 4, 6]) == []\nassert op_neg_uniq_dec([-7, 12, -7]) == [-8]"}
{"id": "op_last3_double_padto3", "entry_point": "op_last3_double_padto3", "primitives": ["last3", "double", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then double each, then pad with zeros to at least three elements.", "solution": "def op_last3_double_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_double_padto3([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_double_padto3([]) == [0, 0, 0]\nassert op_last3_double_padto3([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_last3_double_padto3([5, 5, 5]) == [10, 10, 10]\nassert op_last3_double_padto3([3, 1, 2]) == [6, 2, 4]\nassert op_last3_double_padto3([10]) == [20, 0, 0]\nassert op_last3_double_padto3([2, 4, 6]) == [4, 8, 12]\nassert op_last3_double_padto3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_neg_evens_anyeven", "entry_point": "op_neg_evens_anyeven", "primitives": ["neg", "evens", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the even numbers, then return whether any value is even.", "solution": "def op_neg_evens_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_neg_evens_anyeven([1, 2, 3, 4]) == False\nassert op_neg_evens_anyeven([]) == False\nassert op_neg_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_neg_evens_anyeven([5, 5, 5]) == False\nassert op_neg_evens_anyeven([3, 1, 2]) == False\nassert op_neg_evens_anyeven([10]) == False\nassert op_neg_evens_anyeven([2, 4, 6]) == False\nassert op_neg_evens_anyeven([-7, 12, -7]) == False"}
{"id": "op_inc_trimends_last3", "entry_point": "op_inc_trimends_last3", "primitives": ["inc", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then keep only the last three.", "solution": "def op_inc_trimends_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_trimends_last3([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends_last3([]) == []\nassert op_inc_trimends_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends_last3([5, 5, 5]) == [6]\nassert op_inc_trimends_last3([3, 1, 2]) == [2]\nassert op_inc_trimends_last3([10]) == []\nassert op_inc_trimends_last3([2, 4, 6]) == [5]\nassert op_inc_trimends_last3([-7, 12, -7]) == [13]"}
{"id": "op_dec_rev_dropwhileneg", "entry_point": "op_dec_rev_dropwhileneg", "primitives": ["dec", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then drop the leading negative values.", "solution": "def op_dec_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_rev_dropwhileneg([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_rev_dropwhileneg([]) == []\nassert op_dec_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_dec_rev_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_dec_rev_dropwhileneg([3, 1, 2]) == [1, 0, 2]\nassert op_dec_rev_dropwhileneg([10]) == [9]\nassert op_dec_rev_dropwhileneg([2, 4, 6]) == [5, 3, 1]\nassert op_dec_rev_dropwhileneg([-7, 12, -7]) == [11, -8]"}
{"id": "op_double_dropfirst_min", "entry_point": "op_double_dropfirst_min", "primitives": ["double", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_double_dropfirst_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_double_dropfirst_min([1, 2, 3, 4]) == 4\nassert op_double_dropfirst_min([]) == 0\nassert op_double_dropfirst_min([-2, -1, 0, 1, 2]) == -2\nassert op_double_dropfirst_min([5, 5, 5]) == 10\nassert op_double_dropfirst_min([3, 1, 2]) == 2\nassert op_double_dropfirst_min([10]) == 0\nassert op_double_dropfirst_min([2, 4, 6]) == 8\nassert op_double_dropfirst_min([-7, 12, -7]) == -14"}
{"id": "op_gt5_inc_last3", "entry_point": "op_gt5_inc_last3", "primitives": ["gt5", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then keep only the last three.", "solution": "def op_gt5_inc_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_gt5_inc_last3([1, 2, 3, 4]) == []\nassert op_gt5_inc_last3([]) == []\nassert op_gt5_inc_last3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_last3([5, 5, 5]) == []\nassert op_gt5_inc_last3([3, 1, 2]) == []\nassert op_gt5_inc_last3([10]) == [11]\nassert op_gt5_inc_last3([2, 4, 6]) == [7]\nassert op_gt5_inc_last3([-7, 12, -7]) == [13]"}
{"id": "op_dec_pos_max", "entry_point": "op_dec_pos_max", "primitives": ["dec", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_dec_pos_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_dec_pos_max([1, 2, 3, 4]) == 3\nassert op_dec_pos_max([]) == 0\nassert op_dec_pos_max([-2, -1, 0, 1, 2]) == 1\nassert op_dec_pos_max([5, 5, 5]) == 4\nassert op_dec_pos_max([3, 1, 2]) == 2\nassert op_dec_pos_max([10]) == 9\nassert op_dec_pos_max([2, 4, 6]) == 5\nassert op_dec_pos_max([-7, 12, -7]) == 11"}
{"id": "op_clamp10_sorta_anyeven", "entry_point": "op_clamp10_sorta_anyeven", "primitives": ["clamp10", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then return whether any value is even.", "solution": "def op_clamp10_sorta_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_sorta_anyeven([]) == False\nassert op_clamp10_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_sorta_anyeven([5, 5, 5]) == False\nassert op_clamp10_sorta_anyeven([3, 1, 2]) == True\nassert op_clamp10_sorta_anyeven([10]) == True\nassert op_clamp10_sorta_anyeven([2, 4, 6]) == True\nassert op_clamp10_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_dropzeros_takewhilepos", "entry_point": "op_last3_dropzeros_takewhilepos", "primitives": ["last3", "dropzeros", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then take values while they are positive.", "solution": "def op_last3_dropzeros_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_dropzeros_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_dropzeros_takewhilepos([]) == []\nassert op_last3_dropzeros_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_dropzeros_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropzeros_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_dropzeros_takewhilepos([10]) == [10]\nassert op_last3_dropzeros_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_dropzeros_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_neg_div3_haszero", "entry_point": "op_neg_div3_haszero", "primitives": ["neg", "div3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three, then return whether the list contains a zero.", "solution": "def op_neg_div3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return 0 in r", "tests": "assert op_neg_div3_haszero([1, 2, 3, 4]) == False\nassert op_neg_div3_haszero([]) == False\nassert op_neg_div3_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_div3_haszero([5, 5, 5]) == False\nassert op_neg_div3_haszero([3, 1, 2]) == False\nassert op_neg_div3_haszero([10]) == False\nassert op_neg_div3_haszero([2, 4, 6]) == False\nassert op_neg_div3_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_dropfirst_negate", "entry_point": "op_dropwhileneg_dropfirst_negate", "primitives": ["dropwhileneg", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then negate each.", "solution": "def op_dropwhileneg_dropfirst_negate(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropwhileneg_dropfirst_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropwhileneg_dropfirst_negate([]) == []\nassert op_dropwhileneg_dropfirst_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_dropwhileneg_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_dropwhileneg_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_dropwhileneg_dropfirst_negate([10]) == []\nassert op_dropwhileneg_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_dropwhileneg_dropfirst_negate([-7, 12, -7]) == [7]"}
{"id": "op_trimends_square_double", "entry_point": "op_trimends_square_double", "primitives": ["trimends", "square", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then double each.", "solution": "def op_trimends_square_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_square_double([1, 2, 3, 4]) == [8, 18]\nassert op_trimends_square_double([]) == []\nassert op_trimends_square_double([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_trimends_square_double([5, 5, 5]) == [50]\nassert op_trimends_square_double([3, 1, 2]) == [2]\nassert op_trimends_square_double([10]) == []\nassert op_trimends_square_double([2, 4, 6]) == [32]\nassert op_trimends_square_double([-7, 12, -7]) == [288]"}
{"id": "op_odds_last3_beforezero", "entry_point": "op_odds_last3_beforezero", "primitives": ["odds", "last3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then keep everything before the first zero.", "solution": "def op_odds_last3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_odds_last3_beforezero([1, 2, 3, 4]) == [1, 3]\nassert op_odds_last3_beforezero([]) == []\nassert op_odds_last3_beforezero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_last3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_odds_last3_beforezero([3, 1, 2]) == [3, 1]\nassert op_odds_last3_beforezero([10]) == []\nassert op_odds_last3_beforezero([2, 4, 6]) == []\nassert op_odds_last3_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_trimends_dropwhileneg_allpos", "entry_point": "op_trimends_dropwhileneg_allpos", "primitives": ["trimends", "dropwhileneg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values, then return whether all values are positive.", "solution": "def op_trimends_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_dropwhileneg_allpos([1, 2, 3, 4]) == True\nassert op_trimends_dropwhileneg_allpos([]) == True\nassert op_trimends_dropwhileneg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_dropwhileneg_allpos([5, 5, 5]) == True\nassert op_trimends_dropwhileneg_allpos([3, 1, 2]) == True\nassert op_trimends_dropwhileneg_allpos([10]) == True\nassert op_trimends_dropwhileneg_allpos([2, 4, 6]) == True\nassert op_trimends_dropwhileneg_allpos([-7, 12, -7]) == True"}
{"id": "op_square_add10_alldistinct", "entry_point": "op_square_add10_alldistinct", "primitives": ["square", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each, then return whether all values are distinct.", "solution": "def op_square_add10_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_square_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_square_add10_alldistinct([]) == True\nassert op_square_add10_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_square_add10_alldistinct([5, 5, 5]) == False\nassert op_square_add10_alldistinct([3, 1, 2]) == True\nassert op_square_add10_alldistinct([10]) == True\nassert op_square_add10_alldistinct([2, 4, 6]) == True\nassert op_square_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sorta_negate_uniq", "entry_point": "op_sorta_negate_uniq", "primitives": ["sorta", "negate", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_sorta_negate_uniq(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sorta_negate_uniq([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_negate_uniq([]) == []\nassert op_sorta_negate_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_negate_uniq([5, 5, 5]) == [-5]\nassert op_sorta_negate_uniq([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_negate_uniq([10]) == [-10]\nassert op_sorta_negate_uniq([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_negate_uniq([-7, 12, -7]) == [7, -12]"}
{"id": "op_neg_takewhilepos_negate", "entry_point": "op_neg_takewhilepos_negate", "primitives": ["neg", "takewhilepos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then negate each.", "solution": "def op_neg_takewhilepos_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_takewhilepos_negate([1, 2, 3, 4]) == []\nassert op_neg_takewhilepos_negate([]) == []\nassert op_neg_takewhilepos_negate([-2, -1, 0, 1, 2]) == []\nassert op_neg_takewhilepos_negate([5, 5, 5]) == []\nassert op_neg_takewhilepos_negate([3, 1, 2]) == []\nassert op_neg_takewhilepos_negate([10]) == []\nassert op_neg_takewhilepos_negate([2, 4, 6]) == []\nassert op_neg_takewhilepos_negate([-7, 12, -7]) == []"}
{"id": "op_firstchar_sortlen_joinc", "entry_point": "op_firstchar_sortlen_joinc", "primitives": ["firstchar", "sortlen", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort by length, shortest first, then join them with commas.", "solution": "def op_firstchar_sortlen_joinc(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r, key=len)\n    return ','.join(r)", "tests": "assert op_firstchar_sortlen_joinc(['Hello', 'world']) == 'H,w'\nassert op_firstchar_sortlen_joinc([]) == ''\nassert op_firstchar_sortlen_joinc(['  a ', '', 'BC', 'bc']) == ' ,B,b'\nassert op_firstchar_sortlen_joinc(['one', 'one', 'Two']) == 'o,o,T'\nassert op_firstchar_sortlen_joinc(['x']) == 'x'\nassert op_firstchar_sortlen_joinc(['abc', 'de', '']) == 'a,d'"}
{"id": "op_sortabs_square_dropzeros", "entry_point": "op_sortabs_square_dropzeros", "primitives": ["sortabs", "square", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then drop the zeros.", "solution": "def op_sortabs_square_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_square_dropzeros([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_square_dropzeros([]) == []\nassert op_sortabs_square_dropzeros([-2, -1, 0, 1, 2]) == [1, 1, 4, 4]\nassert op_sortabs_square_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_square_dropzeros([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_square_dropzeros([10]) == [100]\nassert op_sortabs_square_dropzeros([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_square_dropzeros([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_sorta_uniq_odds", "entry_point": "op_sorta_uniq_odds", "primitives": ["sorta", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_sorta_uniq_odds(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sorta_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sorta_uniq_odds([]) == []\nassert op_sorta_uniq_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sorta_uniq_odds([5, 5, 5]) == [5]\nassert op_sorta_uniq_odds([3, 1, 2]) == [1, 3]\nassert op_sorta_uniq_odds([10]) == []\nassert op_sorta_uniq_odds([2, 4, 6]) == []\nassert op_sorta_uniq_odds([-7, 12, -7]) == [-7]"}
{"id": "op_beforezero_add10_allpos", "entry_point": "op_beforezero_add10_allpos", "primitives": ["beforezero", "add10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then return whether all values are positive.", "solution": "def op_beforezero_add10_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_add10_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_add10_allpos([]) == True\nassert op_beforezero_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_add10_allpos([5, 5, 5]) == True\nassert op_beforezero_add10_allpos([3, 1, 2]) == True\nassert op_beforezero_add10_allpos([10]) == True\nassert op_beforezero_add10_allpos([2, 4, 6]) == True\nassert op_beforezero_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_ages_sorta_div3", "entry_point": "op_ages_sorta_div3", "primitives": ["ages", "sorta", "div3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then keep multiples of three.", "solution": "def op_ages_sorta_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_sorta_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sorta_div3([]) == []\nassert op_ages_sorta_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_sorta_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dropwhileneg_uniq_dropzeros", "entry_point": "op_dropwhileneg_uniq_dropzeros", "primitives": ["dropwhileneg", "uniq", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_dropwhileneg_uniq_dropzeros(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropwhileneg_uniq_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_uniq_dropzeros([]) == []\nassert op_dropwhileneg_uniq_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_dropwhileneg_uniq_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_uniq_dropzeros([10]) == [10]\nassert op_dropwhileneg_uniq_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_uniq_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_takewhilepos_last3_sum", "entry_point": "op_takewhilepos_last3_sum", "primitives": ["takewhilepos", "last3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then return their sum.", "solution": "def op_takewhilepos_last3_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_takewhilepos_last3_sum([1, 2, 3, 4]) == 9\nassert op_takewhilepos_last3_sum([]) == 0\nassert op_takewhilepos_last3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_last3_sum([5, 5, 5]) == 15\nassert op_takewhilepos_last3_sum([3, 1, 2]) == 6\nassert op_takewhilepos_last3_sum([10]) == 10\nassert op_takewhilepos_last3_sum([2, 4, 6]) == 12\nassert op_takewhilepos_last3_sum([-7, 12, -7]) == 0"}
{"id": "op_sortd_neg_len", "entry_point": "op_sortd_neg_len", "primitives": ["sortd", "neg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then return how many remain.", "solution": "def op_sortd_neg_len(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_sortd_neg_len([1, 2, 3, 4]) == 0\nassert op_sortd_neg_len([]) == 0\nassert op_sortd_neg_len([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_neg_len([5, 5, 5]) == 0\nassert op_sortd_neg_len([3, 1, 2]) == 0\nassert op_sortd_neg_len([10]) == 0\nassert op_sortd_neg_len([2, 4, 6]) == 0\nassert op_sortd_neg_len([-7, 12, -7]) == 2"}
{"id": "op_strip_lower_anyempty", "entry_point": "op_strip_lower_anyempty", "primitives": ["strip", "lower", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then lowercase each string, then return whether any string is empty.", "solution": "def op_strip_lower_anyempty(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_strip_lower_anyempty(['Hello', 'world']) == False\nassert op_strip_lower_anyempty([]) == False\nassert op_strip_lower_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_strip_lower_anyempty(['one', 'one', 'Two']) == False\nassert op_strip_lower_anyempty(['x']) == False\nassert op_strip_lower_anyempty(['abc', 'de', '']) == True"}
{"id": "op_add10_odds_sorta", "entry_point": "op_add10_odds_sorta", "primitives": ["add10", "odds", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then sort ascending.", "solution": "def op_add10_odds_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_add10_odds_sorta([1, 2, 3, 4]) == [11, 13]\nassert op_add10_odds_sorta([]) == []\nassert op_add10_odds_sorta([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_add10_odds_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_odds_sorta([3, 1, 2]) == [11, 13]\nassert op_add10_odds_sorta([10]) == []\nassert op_add10_odds_sorta([2, 4, 6]) == []\nassert op_add10_odds_sorta([-7, 12, -7]) == [3, 3]"}
{"id": "op_sortd_oremptyzero_beforezero", "entry_point": "op_sortd_oremptyzero_beforezero", "primitives": ["sortd", "oremptyzero", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then keep everything before the first zero.", "solution": "def op_sortd_oremptyzero_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortd_oremptyzero_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_oremptyzero_beforezero([]) == []\nassert op_sortd_oremptyzero_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_oremptyzero_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_oremptyzero_beforezero([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_oremptyzero_beforezero([10]) == [10]\nassert op_sortd_oremptyzero_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_oremptyzero_beforezero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortd_oremptyzero_max", "entry_point": "op_sortd_oremptyzero_max", "primitives": ["sortd", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_sortd_oremptyzero_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_sortd_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_sortd_oremptyzero_max([]) == 0\nassert op_sortd_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_oremptyzero_max([5, 5, 5]) == 5\nassert op_sortd_oremptyzero_max([3, 1, 2]) == 3\nassert op_sortd_oremptyzero_max([10]) == 10\nassert op_sortd_oremptyzero_max([2, 4, 6]) == 6\nassert op_sortd_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_padto3_odds_allpos", "entry_point": "op_padto3_odds_allpos", "primitives": ["padto3", "odds", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_padto3_odds_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_odds_allpos([1, 2, 3, 4]) == True\nassert op_padto3_odds_allpos([]) == True\nassert op_padto3_odds_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_odds_allpos([5, 5, 5]) == True\nassert op_padto3_odds_allpos([3, 1, 2]) == True\nassert op_padto3_odds_allpos([10]) == True\nassert op_padto3_odds_allpos([2, 4, 6]) == True\nassert op_padto3_odds_allpos([-7, 12, -7]) == False"}
{"id": "op_padto3_double_prod", "entry_point": "op_padto3_double_prod", "primitives": ["padto3", "double", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then return their product.", "solution": "def op_padto3_double_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_padto3_double_prod([1, 2, 3, 4]) == 384\nassert op_padto3_double_prod([]) == 0\nassert op_padto3_double_prod([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_double_prod([5, 5, 5]) == 1000\nassert op_padto3_double_prod([3, 1, 2]) == 48\nassert op_padto3_double_prod([10]) == 0\nassert op_padto3_double_prod([2, 4, 6]) == 384\nassert op_padto3_double_prod([-7, 12, -7]) == 4704"}
{"id": "op_rev_dropfirst_min", "entry_point": "op_rev_dropfirst_min", "primitives": ["rev", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_rev_dropfirst_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_rev_dropfirst_min([1, 2, 3, 4]) == 1\nassert op_rev_dropfirst_min([]) == 0\nassert op_rev_dropfirst_min([-2, -1, 0, 1, 2]) == -2\nassert op_rev_dropfirst_min([5, 5, 5]) == 5\nassert op_rev_dropfirst_min([3, 1, 2]) == 1\nassert op_rev_dropfirst_min([10]) == 0\nassert op_rev_dropfirst_min([2, 4, 6]) == 2\nassert op_rev_dropfirst_min([-7, 12, -7]) == -7"}
{"id": "op_takewhilepos_first3_counteven", "entry_point": "op_takewhilepos_first3_counteven", "primitives": ["takewhilepos", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then return how many values are even.", "solution": "def op_takewhilepos_first3_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_first3_counteven([1, 2, 3, 4]) == 1\nassert op_takewhilepos_first3_counteven([]) == 0\nassert op_takewhilepos_first3_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_first3_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_first3_counteven([3, 1, 2]) == 1\nassert op_takewhilepos_first3_counteven([10]) == 1\nassert op_takewhilepos_first3_counteven([2, 4, 6]) == 3\nassert op_takewhilepos_first3_counteven([-7, 12, -7]) == 0"}
{"id": "op_pos_beforezero_firsteven", "entry_point": "op_pos_beforezero_firsteven", "primitives": ["pos", "beforezero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_pos_beforezero_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_pos_beforezero_firsteven([]) == 0\nassert op_pos_beforezero_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_beforezero_firsteven([5, 5, 5]) == 0\nassert op_pos_beforezero_firsteven([3, 1, 2]) == 2\nassert op_pos_beforezero_firsteven([10]) == 10\nassert op_pos_beforezero_firsteven([2, 4, 6]) == 2\nassert op_pos_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_absval_evens_sortabs", "entry_point": "op_absval_evens_sortabs", "primitives": ["absval", "evens", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then sort by absolute value.", "solution": "def op_absval_evens_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_absval_evens_sortabs([]) == []\nassert op_absval_evens_sortabs([-2, -1, 0, 1, 2]) == [0, 2, 2]\nassert op_absval_evens_sortabs([5, 5, 5]) == []\nassert op_absval_evens_sortabs([3, 1, 2]) == [2]\nassert op_absval_evens_sortabs([10]) == [10]\nassert op_absval_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_absval_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_first3_dropwhileneg_negate", "entry_point": "op_first3_dropwhileneg_negate", "primitives": ["first3", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values, then negate each.", "solution": "def op_first3_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_first3_dropwhileneg_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_first3_dropwhileneg_negate([]) == []\nassert op_first3_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_first3_dropwhileneg_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_first3_dropwhileneg_negate([10]) == [-10]\nassert op_first3_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_first3_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_dropwhileneg_sortabs_alldistinct", "entry_point": "op_dropwhileneg_sortabs_alldistinct", "primitives": ["dropwhileneg", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_dropwhileneg_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_sortabs_alldistinct([]) == True\nassert op_dropwhileneg_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_sortabs_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_sortabs_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_sortabs_alldistinct([10]) == True\nassert op_dropwhileneg_sortabs_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_sortabs_alldistinct([-7, 12, -7]) == True"}
{"id": "op_uniq_div3_sum", "entry_point": "op_uniq_div3_sum", "primitives": ["uniq", "div3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then return their sum.", "solution": "def op_uniq_div3_sum(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return sum(r)", "tests": "assert op_uniq_div3_sum([1, 2, 3, 4]) == 3\nassert op_uniq_div3_sum([]) == 0\nassert op_uniq_div3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_div3_sum([5, 5, 5]) == 0\nassert op_uniq_div3_sum([3, 1, 2]) == 3\nassert op_uniq_div3_sum([10]) == 0\nassert op_uniq_div3_sum([2, 4, 6]) == 6\nassert op_uniq_div3_sum([-7, 12, -7]) == 12"}
{"id": "op_gt5_sortd_padto3", "entry_point": "op_gt5_sortd_padto3", "primitives": ["gt5", "sortd", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then pad with zeros to at least three elements.", "solution": "def op_gt5_sortd_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_gt5_sortd_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_sortd_padto3([]) == [0, 0, 0]\nassert op_gt5_sortd_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_sortd_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_sortd_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_sortd_padto3([10]) == [10, 0, 0]\nassert op_gt5_sortd_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_gt5_sortd_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_padto3_last3_allpos", "entry_point": "op_padto3_last3_allpos", "primitives": ["padto3", "last3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then return whether all values are positive.", "solution": "def op_padto3_last3_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_last3_allpos([1, 2, 3, 4]) == True\nassert op_padto3_last3_allpos([]) == False\nassert op_padto3_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_last3_allpos([5, 5, 5]) == True\nassert op_padto3_last3_allpos([3, 1, 2]) == True\nassert op_padto3_last3_allpos([10]) == False\nassert op_padto3_last3_allpos([2, 4, 6]) == True\nassert op_padto3_last3_allpos([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_add10_firsteven", "entry_point": "op_oremptyzero_add10_firsteven", "primitives": ["oremptyzero", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then return the first even value (0 if none).", "solution": "def op_oremptyzero_add10_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_oremptyzero_add10_firsteven([]) == 10\nassert op_oremptyzero_add10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_oremptyzero_add10_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_add10_firsteven([3, 1, 2]) == 12\nassert op_oremptyzero_add10_firsteven([10]) == 20\nassert op_oremptyzero_add10_firsteven([2, 4, 6]) == 12\nassert op_oremptyzero_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_oremptyzero_last3_dec", "entry_point": "op_oremptyzero_last3_dec", "primitives": ["oremptyzero", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then subtract one from each.", "solution": "def op_oremptyzero_last3_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_last3_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_last3_dec([]) == [-1]\nassert op_oremptyzero_last3_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_oremptyzero_last3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_oremptyzero_last3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_oremptyzero_last3_dec([10]) == [9]\nassert op_oremptyzero_last3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_oremptyzero_last3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropfirst_negate_takewhilepos", "entry_point": "op_dropfirst_negate_takewhilepos", "primitives": ["dropfirst", "negate", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then take values while they are positive.", "solution": "def op_dropfirst_negate_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_negate_takewhilepos([1, 2, 3, 4]) == []\nassert op_dropfirst_negate_takewhilepos([]) == []\nassert op_dropfirst_negate_takewhilepos([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_negate_takewhilepos([5, 5, 5]) == []\nassert op_dropfirst_negate_takewhilepos([3, 1, 2]) == []\nassert op_dropfirst_negate_takewhilepos([10]) == []\nassert op_dropfirst_negate_takewhilepos([2, 4, 6]) == []\nassert op_dropfirst_negate_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_div3_trimends_takewhilepos", "entry_point": "op_div3_trimends_takewhilepos", "primitives": ["div3", "trimends", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then take values while they are positive.", "solution": "def op_div3_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_trimends_takewhilepos([1, 2, 3, 4]) == []\nassert op_div3_trimends_takewhilepos([]) == []\nassert op_div3_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends_takewhilepos([5, 5, 5]) == []\nassert op_div3_trimends_takewhilepos([3, 1, 2]) == []\nassert op_div3_trimends_takewhilepos([10]) == []\nassert op_div3_trimends_takewhilepos([2, 4, 6]) == []\nassert op_div3_trimends_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sorta_negate", "entry_point": "op_takewhilepos_sorta_negate", "primitives": ["takewhilepos", "sorta", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending, then negate each.", "solution": "def op_takewhilepos_sorta_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_sorta_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_sorta_negate([]) == []\nassert op_takewhilepos_sorta_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sorta_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_sorta_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_takewhilepos_sorta_negate([10]) == [-10]\nassert op_takewhilepos_sorta_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_sorta_negate([-7, 12, -7]) == []"}
{"id": "op_neg_add10_max", "entry_point": "op_neg_add10_max", "primitives": ["neg", "add10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then return the maximum (0 if empty).", "solution": "def op_neg_add10_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return max(r) if r else 0", "tests": "assert op_neg_add10_max([1, 2, 3, 4]) == 0\nassert op_neg_add10_max([]) == 0\nassert op_neg_add10_max([-2, -1, 0, 1, 2]) == 9\nassert op_neg_add10_max([5, 5, 5]) == 0\nassert op_neg_add10_max([3, 1, 2]) == 0\nassert op_neg_add10_max([10]) == 0\nassert op_neg_add10_max([2, 4, 6]) == 0\nassert op_neg_add10_max([-7, 12, -7]) == 3"}
{"id": "op_negate_beforezero_alldistinct", "entry_point": "op_negate_beforezero_alldistinct", "primitives": ["negate", "beforezero", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then return whether all values are distinct.", "solution": "def op_negate_beforezero_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r) == len(set(r))", "tests": "assert op_negate_beforezero_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_beforezero_alldistinct([]) == True\nassert op_negate_beforezero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_beforezero_alldistinct([5, 5, 5]) == False\nassert op_negate_beforezero_alldistinct([3, 1, 2]) == True\nassert op_negate_beforezero_alldistinct([10]) == True\nassert op_negate_beforezero_alldistinct([2, 4, 6]) == True\nassert op_negate_beforezero_alldistinct([-7, 12, -7]) == False"}
{"id": "op_trimends_last3_rev", "entry_point": "op_trimends_last3_rev", "primitives": ["trimends", "last3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then reverse the order.", "solution": "def op_trimends_last3_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_last3_rev([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_last3_rev([]) == []\nassert op_trimends_last3_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_last3_rev([5, 5, 5]) == [5]\nassert op_trimends_last3_rev([3, 1, 2]) == [1]\nassert op_trimends_last3_rev([10]) == []\nassert op_trimends_last3_rev([2, 4, 6]) == [4]\nassert op_trimends_last3_rev([-7, 12, -7]) == [12]"}
{"id": "op_div3_add10_padto3", "entry_point": "op_div3_add10_padto3", "primitives": ["div3", "add10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_div3_add10_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_add10_padto3([1, 2, 3, 4]) == [13, 0, 0]\nassert op_div3_add10_padto3([]) == [0, 0, 0]\nassert op_div3_add10_padto3([-2, -1, 0, 1, 2]) == [10, 0, 0]\nassert op_div3_add10_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_add10_padto3([3, 1, 2]) == [13, 0, 0]\nassert op_div3_add10_padto3([10]) == [0, 0, 0]\nassert op_div3_add10_padto3([2, 4, 6]) == [16, 0, 0]\nassert op_div3_add10_padto3([-7, 12, -7]) == [22, 0, 0]"}
{"id": "op_absval_square_first3", "entry_point": "op_absval_square_first3", "primitives": ["absval", "square", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each, then keep only the first three.", "solution": "def op_absval_square_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_absval_square_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_absval_square_first3([]) == []\nassert op_absval_square_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_absval_square_first3([5, 5, 5]) == [25, 25, 25]\nassert op_absval_square_first3([3, 1, 2]) == [9, 1, 4]\nassert op_absval_square_first3([10]) == [100]\nassert op_absval_square_first3([2, 4, 6]) == [4, 16, 36]\nassert op_absval_square_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_padto3_uniq_min", "entry_point": "op_padto3_uniq_min", "primitives": ["padto3", "uniq", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_padto3_uniq_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_padto3_uniq_min([1, 2, 3, 4]) == 1\nassert op_padto3_uniq_min([]) == 0\nassert op_padto3_uniq_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_uniq_min([5, 5, 5]) == 5\nassert op_padto3_uniq_min([3, 1, 2]) == 1\nassert op_padto3_uniq_min([10]) == 0\nassert op_padto3_uniq_min([2, 4, 6]) == 2\nassert op_padto3_uniq_min([-7, 12, -7]) == -7"}
{"id": "op_pos_first3_dropzeros", "entry_point": "op_pos_first3_dropzeros", "primitives": ["pos", "first3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then drop the zeros.", "solution": "def op_pos_first3_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_first3_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_first3_dropzeros([]) == []\nassert op_pos_first3_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_first3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_first3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_first3_dropzeros([10]) == [10]\nassert op_pos_first3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_first3_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_odds_add10", "entry_point": "op_beforezero_odds_add10", "primitives": ["beforezero", "odds", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the odd numbers, then add ten to each.", "solution": "def op_beforezero_odds_add10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_beforezero_odds_add10([1, 2, 3, 4]) == [11, 13]\nassert op_beforezero_odds_add10([]) == []\nassert op_beforezero_odds_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_beforezero_odds_add10([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_odds_add10([3, 1, 2]) == [13, 11]\nassert op_beforezero_odds_add10([10]) == []\nassert op_beforezero_odds_add10([2, 4, 6]) == []\nassert op_beforezero_odds_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_rev_sorta_gt5", "entry_point": "op_rev_sorta_gt5", "primitives": ["rev", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then keep values greater than five.", "solution": "def op_rev_sorta_gt5(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_rev_sorta_gt5([1, 2, 3, 4]) == []\nassert op_rev_sorta_gt5([]) == []\nassert op_rev_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_rev_sorta_gt5([5, 5, 5]) == []\nassert op_rev_sorta_gt5([3, 1, 2]) == []\nassert op_rev_sorta_gt5([10]) == [10]\nassert op_rev_sorta_gt5([2, 4, 6]) == [6]\nassert op_rev_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_uniq_firsteven", "entry_point": "op_dropzeros_uniq_firsteven", "primitives": ["dropzeros", "uniq", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_dropzeros_uniq_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_uniq_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_uniq_firsteven([]) == 0\nassert op_dropzeros_uniq_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_uniq_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_uniq_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_uniq_firsteven([10]) == 10\nassert op_dropzeros_uniq_firsteven([2, 4, 6]) == 2\nassert op_dropzeros_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sorta_last3_anyeven", "entry_point": "op_sorta_last3_anyeven", "primitives": ["sorta", "last3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the last three, then return whether any value is even.", "solution": "def op_sorta_last3_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_last3_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_last3_anyeven([]) == False\nassert op_sorta_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_last3_anyeven([5, 5, 5]) == False\nassert op_sorta_last3_anyeven([3, 1, 2]) == True\nassert op_sorta_last3_anyeven([10]) == True\nassert op_sorta_last3_anyeven([2, 4, 6]) == True\nassert op_sorta_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_beforezero_max", "entry_point": "op_sortd_beforezero_max", "primitives": ["sortd", "beforezero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_sortd_beforezero_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_sortd_beforezero_max([1, 2, 3, 4]) == 4\nassert op_sortd_beforezero_max([]) == 0\nassert op_sortd_beforezero_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_beforezero_max([5, 5, 5]) == 5\nassert op_sortd_beforezero_max([3, 1, 2]) == 3\nassert op_sortd_beforezero_max([10]) == 10\nassert op_sortd_beforezero_max([2, 4, 6]) == 6\nassert op_sortd_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_sortabs_len", "entry_point": "op_takewhilepos_sortabs_len", "primitives": ["takewhilepos", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then return how many remain.", "solution": "def op_takewhilepos_sortabs_len(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_takewhilepos_sortabs_len([1, 2, 3, 4]) == 4\nassert op_takewhilepos_sortabs_len([]) == 0\nassert op_takewhilepos_sortabs_len([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sortabs_len([5, 5, 5]) == 3\nassert op_takewhilepos_sortabs_len([3, 1, 2]) == 3\nassert op_takewhilepos_sortabs_len([10]) == 1\nassert op_takewhilepos_sortabs_len([2, 4, 6]) == 3\nassert op_takewhilepos_sortabs_len([-7, 12, -7]) == 0"}
{"id": "op_add10_sortabs_alldistinct", "entry_point": "op_add10_sortabs_alldistinct", "primitives": ["add10", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_add10_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_add10_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_add10_sortabs_alldistinct([]) == True\nassert op_add10_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_add10_sortabs_alldistinct([5, 5, 5]) == False\nassert op_add10_sortabs_alldistinct([3, 1, 2]) == True\nassert op_add10_sortabs_alldistinct([10]) == True\nassert op_add10_sortabs_alldistinct([2, 4, 6]) == True\nassert op_add10_sortabs_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_evens_rev", "entry_point": "op_dropzeros_evens_rev", "primitives": ["dropzeros", "evens", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then reverse the order.", "solution": "def op_dropzeros_evens_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropzeros_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_dropzeros_evens_rev([]) == []\nassert op_dropzeros_evens_rev([-2, -1, 0, 1, 2]) == [2, -2]\nassert op_dropzeros_evens_rev([5, 5, 5]) == []\nassert op_dropzeros_evens_rev([3, 1, 2]) == [2]\nassert op_dropzeros_evens_rev([10]) == [10]\nassert op_dropzeros_evens_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_evens_rev([-7, 12, -7]) == [12]"}
{"id": "op_evens_dropzeros_anyeven", "entry_point": "op_evens_dropzeros_anyeven", "primitives": ["evens", "dropzeros", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then return whether any value is even.", "solution": "def op_evens_dropzeros_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_dropzeros_anyeven([1, 2, 3, 4]) == True\nassert op_evens_dropzeros_anyeven([]) == False\nassert op_evens_dropzeros_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_evens_dropzeros_anyeven([5, 5, 5]) == False\nassert op_evens_dropzeros_anyeven([3, 1, 2]) == True\nassert op_evens_dropzeros_anyeven([10]) == True\nassert op_evens_dropzeros_anyeven([2, 4, 6]) == True\nassert op_evens_dropzeros_anyeven([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_pos_negate", "entry_point": "op_takewhilepos_pos_negate", "primitives": ["takewhilepos", "pos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then negate each.", "solution": "def op_takewhilepos_pos_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_pos_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_pos_negate([]) == []\nassert op_takewhilepos_pos_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_pos_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_pos_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_takewhilepos_pos_negate([10]) == [-10]\nassert op_takewhilepos_pos_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_pos_negate([-7, 12, -7]) == []"}
{"id": "op_negate_dec_min", "entry_point": "op_negate_dec_min", "primitives": ["negate", "dec", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_negate_dec_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_negate_dec_min([1, 2, 3, 4]) == -5\nassert op_negate_dec_min([]) == 0\nassert op_negate_dec_min([-2, -1, 0, 1, 2]) == -3\nassert op_negate_dec_min([5, 5, 5]) == -6\nassert op_negate_dec_min([3, 1, 2]) == -4\nassert op_negate_dec_min([10]) == -11\nassert op_negate_dec_min([2, 4, 6]) == -7\nassert op_negate_dec_min([-7, 12, -7]) == -13"}
{"id": "op_dropfirst_uniq_alldistinct", "entry_point": "op_dropfirst_uniq_alldistinct", "primitives": ["dropfirst", "uniq", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_dropfirst_uniq_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_uniq_alldistinct([]) == True\nassert op_dropfirst_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_uniq_alldistinct([5, 5, 5]) == True\nassert op_dropfirst_uniq_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_uniq_alldistinct([10]) == True\nassert op_dropfirst_uniq_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_square_beforezero_alldistinct", "entry_point": "op_square_beforezero_alldistinct", "primitives": ["square", "beforezero", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then return whether all values are distinct.", "solution": "def op_square_beforezero_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r) == len(set(r))", "tests": "assert op_square_beforezero_alldistinct([1, 2, 3, 4]) == True\nassert op_square_beforezero_alldistinct([]) == True\nassert op_square_beforezero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_square_beforezero_alldistinct([5, 5, 5]) == False\nassert op_square_beforezero_alldistinct([3, 1, 2]) == True\nassert op_square_beforezero_alldistinct([10]) == True\nassert op_square_beforezero_alldistinct([2, 4, 6]) == True\nassert op_square_beforezero_alldistinct([-7, 12, -7]) == False"}
{"id": "op_rev_last3_counteven", "entry_point": "op_rev_last3_counteven", "primitives": ["rev", "last3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then return how many values are even.", "solution": "def op_rev_last3_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_last3_counteven([1, 2, 3, 4]) == 1\nassert op_rev_last3_counteven([]) == 0\nassert op_rev_last3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_rev_last3_counteven([5, 5, 5]) == 0\nassert op_rev_last3_counteven([3, 1, 2]) == 1\nassert op_rev_last3_counteven([10]) == 1\nassert op_rev_last3_counteven([2, 4, 6]) == 3\nassert op_rev_last3_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropwhileneg_beforezero_add10", "entry_point": "op_dropwhileneg_beforezero_add10", "primitives": ["dropwhileneg", "beforezero", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero, then add ten to each.", "solution": "def op_dropwhileneg_beforezero_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_beforezero_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_beforezero_add10([]) == []\nassert op_dropwhileneg_beforezero_add10([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_beforezero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_beforezero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_beforezero_add10([10]) == [20]\nassert op_dropwhileneg_beforezero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_beforezero_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_nonempty_uniqs_firstchar", "entry_point": "op_nonempty_uniqs_firstchar", "primitives": ["nonempty", "uniqs", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop duplicate strings keeping the first, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_uniqs_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = list(dict.fromkeys(r))\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_uniqs_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_nonempty_uniqs_firstchar([]) == []\nassert op_nonempty_uniqs_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_nonempty_uniqs_firstchar(['one', 'one', 'Two']) == ['o', 'T']\nassert op_nonempty_uniqs_firstchar(['x']) == ['x']\nassert op_nonempty_uniqs_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_double_oremptyzero_uniq", "entry_point": "op_double_oremptyzero_uniq", "primitives": ["double", "oremptyzero", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_double_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_oremptyzero_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_uniq([]) == [0]\nassert op_double_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_oremptyzero_uniq([5, 5, 5]) == [10]\nassert op_double_oremptyzero_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_uniq([10]) == [20]\nassert op_double_oremptyzero_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_add10_negate_first3", "entry_point": "op_add10_negate_first3", "primitives": ["add10", "negate", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each, then keep only the first three.", "solution": "def op_add10_negate_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_add10_negate_first3([1, 2, 3, 4]) == [-11, -12, -13]\nassert op_add10_negate_first3([]) == []\nassert op_add10_negate_first3([-2, -1, 0, 1, 2]) == [-8, -9, -10]\nassert op_add10_negate_first3([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_negate_first3([3, 1, 2]) == [-13, -11, -12]\nassert op_add10_negate_first3([10]) == [-20]\nassert op_add10_negate_first3([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_negate_first3([-7, 12, -7]) == [-3, -22, -3]"}
{"id": "op_dropzeros_negate_oremptyzero", "entry_point": "op_dropzeros_negate_oremptyzero", "primitives": ["dropzeros", "negate", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then if empty, use a single zero.", "solution": "def op_dropzeros_negate_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_negate_oremptyzero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropzeros_negate_oremptyzero([]) == [0]\nassert op_dropzeros_negate_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_negate_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_negate_oremptyzero([3, 1, 2]) == [-3, -1, -2]\nassert op_dropzeros_negate_oremptyzero([10]) == [-10]\nassert op_dropzeros_negate_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_negate_oremptyzero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_ages_sortd_last3", "entry_point": "op_ages_sortd_last3", "primitives": ["ages", "sortd", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then keep only the last three.", "solution": "def op_ages_sortd_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return r", "tests": "assert op_ages_sortd_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_sortd_last3([]) == []\nassert op_ages_sortd_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 18, 17]\nassert op_ages_sortd_last3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortalpha_uniqs_sortlen", "entry_point": "op_sortalpha_uniqs_sortlen", "primitives": ["sortalpha", "uniqs", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then sort by length, shortest first.", "solution": "def op_sortalpha_uniqs_sortlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_sortalpha_uniqs_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_uniqs_sortlen([]) == []\nassert op_sortalpha_uniqs_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_sortalpha_uniqs_sortlen(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_sortalpha_uniqs_sortlen(['x']) == ['x']\nassert op_sortalpha_uniqs_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_clamp10_double_rev", "entry_point": "op_clamp10_double_rev", "primitives": ["clamp10", "double", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then reverse the order.", "solution": "def op_clamp10_double_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_double_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_clamp10_double_rev([]) == []\nassert op_clamp10_double_rev([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_clamp10_double_rev([5, 5, 5]) == [10, 10, 10]\nassert op_clamp10_double_rev([3, 1, 2]) == [4, 2, 6]\nassert op_clamp10_double_rev([10]) == [20]\nassert op_clamp10_double_rev([2, 4, 6]) == [12, 8, 4]\nassert op_clamp10_double_rev([-7, 12, -7]) == [-14, 20, -14]"}
{"id": "op_uniq_sortabs_last3", "entry_point": "op_uniq_sortabs_last3", "primitives": ["uniq", "sortabs", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value, then keep only the last three.", "solution": "def op_uniq_sortabs_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_sortabs_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_sortabs_last3([]) == []\nassert op_uniq_sortabs_last3([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_uniq_sortabs_last3([5, 5, 5]) == [5]\nassert op_uniq_sortabs_last3([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sortabs_last3([10]) == [10]\nassert op_uniq_sortabs_last3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sortabs_last3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_ages_pos_takewhilepos", "entry_point": "op_ages_pos_takewhilepos", "primitives": ["ages", "pos", "takewhilepos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers, then take values while they are positive.", "solution": "def op_ages_pos_takewhilepos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_ages_pos_takewhilepos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_pos_takewhilepos([]) == []\nassert op_ages_pos_takewhilepos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_pos_takewhilepos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_lower_dropshort_joinc", "entry_point": "op_lower_dropshort_joinc", "primitives": ["lower", "dropshort", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop strings shorter than three characters, then join them with commas.", "solution": "def op_lower_dropshort_joinc(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return ','.join(r)", "tests": "assert op_lower_dropshort_joinc(['Hello', 'world']) == 'hello,world'\nassert op_lower_dropshort_joinc([]) == ''\nassert op_lower_dropshort_joinc(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_lower_dropshort_joinc(['one', 'one', 'Two']) == 'one,one,two'\nassert op_lower_dropshort_joinc(['x']) == ''\nassert op_lower_dropshort_joinc(['abc', 'de', '']) == 'abc'"}
{"id": "op_dropfirst_beforezero_dec", "entry_point": "op_dropfirst_beforezero_dec", "primitives": ["dropfirst", "beforezero", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then subtract one from each.", "solution": "def op_dropfirst_beforezero_dec(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropfirst_beforezero_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_beforezero_dec([]) == []\nassert op_dropfirst_beforezero_dec([-2, -1, 0, 1, 2]) == [-2]\nassert op_dropfirst_beforezero_dec([5, 5, 5]) == [4, 4]\nassert op_dropfirst_beforezero_dec([3, 1, 2]) == [0, 1]\nassert op_dropfirst_beforezero_dec([10]) == []\nassert op_dropfirst_beforezero_dec([2, 4, 6]) == [3, 5]\nassert op_dropfirst_beforezero_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_dropwhileneg_odds_sortd", "entry_point": "op_dropwhileneg_odds_sortd", "primitives": ["dropwhileneg", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then sort descending.", "solution": "def op_dropwhileneg_odds_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_dropwhileneg_odds_sortd([]) == []\nassert op_dropwhileneg_odds_sortd([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_dropwhileneg_odds_sortd([10]) == []\nassert op_dropwhileneg_odds_sortd([2, 4, 6]) == []\nassert op_dropwhileneg_odds_sortd([-7, 12, -7]) == [-7]"}
{"id": "op_oremptyzero_pos_haszero", "entry_point": "op_oremptyzero_pos_haszero", "primitives": ["oremptyzero", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_oremptyzero_pos_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_oremptyzero_pos_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_pos_haszero([]) == False\nassert op_oremptyzero_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_pos_haszero([5, 5, 5]) == False\nassert op_oremptyzero_pos_haszero([3, 1, 2]) == False\nassert op_oremptyzero_pos_haszero([10]) == False\nassert op_oremptyzero_pos_haszero([2, 4, 6]) == False\nassert op_oremptyzero_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_neg_firsteven", "entry_point": "op_div3_neg_firsteven", "primitives": ["div3", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_div3_neg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_neg_firsteven([]) == 0\nassert op_div3_neg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_neg_firsteven([5, 5, 5]) == 0\nassert op_div3_neg_firsteven([3, 1, 2]) == 0\nassert op_div3_neg_firsteven([10]) == 0\nassert op_div3_neg_firsteven([2, 4, 6]) == 0\nassert op_div3_neg_firsteven([-7, 12, -7]) == 0"}
{"id": "op_upper_nonempty_uniqs", "entry_point": "op_upper_nonempty_uniqs", "primitives": ["upper", "nonempty", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop empty strings, then drop duplicate strings keeping the first.", "solution": "def op_upper_nonempty_uniqs(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_upper_nonempty_uniqs(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_nonempty_uniqs([]) == []\nassert op_upper_nonempty_uniqs(['  a ', '', 'BC', 'bc']) == ['  A ', 'BC']\nassert op_upper_nonempty_uniqs(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_upper_nonempty_uniqs(['x']) == ['X']\nassert op_upper_nonempty_uniqs(['abc', 'de', '']) == ['ABC', 'DE']"}
{"id": "op_upper_strip_joinc", "entry_point": "op_upper_strip_joinc", "primitives": ["upper", "strip", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then trim whitespace from each, then join them with commas.", "solution": "def op_upper_strip_joinc(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.strip() for s in r]\n    return ','.join(r)", "tests": "assert op_upper_strip_joinc(['Hello', 'world']) == 'HELLO,WORLD'\nassert op_upper_strip_joinc([]) == ''\nassert op_upper_strip_joinc(['  a ', '', 'BC', 'bc']) == 'A,,BC,BC'\nassert op_upper_strip_joinc(['one', 'one', 'Two']) == 'ONE,ONE,TWO'\nassert op_upper_strip_joinc(['x']) == 'X'\nassert op_upper_strip_joinc(['abc', 'de', '']) == 'ABC,DE,'"}
{"id": "op_double_div3_len", "entry_point": "op_double_div3_len", "primitives": ["double", "div3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then return how many remain.", "solution": "def op_double_div3_len(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_double_div3_len([1, 2, 3, 4]) == 1\nassert op_double_div3_len([]) == 0\nassert op_double_div3_len([-2, -1, 0, 1, 2]) == 1\nassert op_double_div3_len([5, 5, 5]) == 0\nassert op_double_div3_len([3, 1, 2]) == 1\nassert op_double_div3_len([10]) == 0\nassert op_double_div3_len([2, 4, 6]) == 1\nassert op_double_div3_len([-7, 12, -7]) == 1"}
{"id": "op_double_absval_inc", "entry_point": "op_double_absval_inc", "primitives": ["double", "absval", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then add one to each.", "solution": "def op_double_absval_inc(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_double_absval_inc([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_double_absval_inc([]) == []\nassert op_double_absval_inc([-2, -1, 0, 1, 2]) == [5, 3, 1, 3, 5]\nassert op_double_absval_inc([5, 5, 5]) == [11, 11, 11]\nassert op_double_absval_inc([3, 1, 2]) == [7, 3, 5]\nassert op_double_absval_inc([10]) == [21]\nassert op_double_absval_inc([2, 4, 6]) == [5, 9, 13]\nassert op_double_absval_inc([-7, 12, -7]) == [15, 25, 15]"}
{"id": "op_beforezero_evens_odds", "entry_point": "op_beforezero_evens_odds", "primitives": ["beforezero", "evens", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then keep the odd numbers.", "solution": "def op_beforezero_evens_odds(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_beforezero_evens_odds([1, 2, 3, 4]) == []\nassert op_beforezero_evens_odds([]) == []\nassert op_beforezero_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_evens_odds([5, 5, 5]) == []\nassert op_beforezero_evens_odds([3, 1, 2]) == []\nassert op_beforezero_evens_odds([10]) == []\nassert op_beforezero_evens_odds([2, 4, 6]) == []\nassert op_beforezero_evens_odds([-7, 12, -7]) == []"}
{"id": "op_sortd_beforezero_sum", "entry_point": "op_sortd_beforezero_sum", "primitives": ["sortd", "beforezero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then return their sum.", "solution": "def op_sortd_beforezero_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(r)", "tests": "assert op_sortd_beforezero_sum([1, 2, 3, 4]) == 10\nassert op_sortd_beforezero_sum([]) == 0\nassert op_sortd_beforezero_sum([-2, -1, 0, 1, 2]) == 3\nassert op_sortd_beforezero_sum([5, 5, 5]) == 15\nassert op_sortd_beforezero_sum([3, 1, 2]) == 6\nassert op_sortd_beforezero_sum([10]) == 10\nassert op_sortd_beforezero_sum([2, 4, 6]) == 12\nassert op_sortd_beforezero_sum([-7, 12, -7]) == -2"}
{"id": "op_add10_rev_clamp10", "entry_point": "op_add10_rev_clamp10", "primitives": ["add10", "rev", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then cap each value at 10.", "solution": "def op_add10_rev_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_rev_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_rev_clamp10([]) == []\nassert op_add10_rev_clamp10([-2, -1, 0, 1, 2]) == [10, 10, 10, 9, 8]\nassert op_add10_rev_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_add10_rev_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_add10_rev_clamp10([10]) == [10]\nassert op_add10_rev_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_add10_rev_clamp10([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_sortabs_pos_alldistinct", "entry_point": "op_sortabs_pos_alldistinct", "primitives": ["sortabs", "pos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then return whether all values are distinct.", "solution": "def op_sortabs_pos_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_pos_alldistinct([]) == True\nassert op_sortabs_pos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_pos_alldistinct([5, 5, 5]) == False\nassert op_sortabs_pos_alldistinct([3, 1, 2]) == True\nassert op_sortabs_pos_alldistinct([10]) == True\nassert op_sortabs_pos_alldistinct([2, 4, 6]) == True\nassert op_sortabs_pos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_padto3_uniq_sum", "entry_point": "op_padto3_uniq_sum", "primitives": ["padto3", "uniq", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_padto3_uniq_sum(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_padto3_uniq_sum([1, 2, 3, 4]) == 10\nassert op_padto3_uniq_sum([]) == 0\nassert op_padto3_uniq_sum([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_uniq_sum([5, 5, 5]) == 5\nassert op_padto3_uniq_sum([3, 1, 2]) == 6\nassert op_padto3_uniq_sum([10]) == 10\nassert op_padto3_uniq_sum([2, 4, 6]) == 12\nassert op_padto3_uniq_sum([-7, 12, -7]) == 5"}
{"id": "op_clamp10_inc_haszero", "entry_point": "op_clamp10_inc_haszero", "primitives": ["clamp10", "inc", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then return whether the list contains a zero.", "solution": "def op_clamp10_inc_haszero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_clamp10_inc_haszero([1, 2, 3, 4]) == False\nassert op_clamp10_inc_haszero([]) == False\nassert op_clamp10_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_inc_haszero([5, 5, 5]) == False\nassert op_clamp10_inc_haszero([3, 1, 2]) == False\nassert op_clamp10_inc_haszero([10]) == False\nassert op_clamp10_inc_haszero([2, 4, 6]) == False\nassert op_clamp10_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_pos_evens_dropwhileneg", "entry_point": "op_pos_evens_dropwhileneg", "primitives": ["pos", "evens", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then drop the leading negative values.", "solution": "def op_pos_evens_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_pos_evens_dropwhileneg([1, 2, 3, 4]) == [2, 4]\nassert op_pos_evens_dropwhileneg([]) == []\nassert op_pos_evens_dropwhileneg([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_evens_dropwhileneg([5, 5, 5]) == []\nassert op_pos_evens_dropwhileneg([3, 1, 2]) == [2]\nassert op_pos_evens_dropwhileneg([10]) == [10]\nassert op_pos_evens_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_pos_evens_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_oremptyzero_neg", "entry_point": "op_dropwhileneg_oremptyzero_neg", "primitives": ["dropwhileneg", "oremptyzero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then keep the negative numbers.", "solution": "def op_dropwhileneg_oremptyzero_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_oremptyzero_neg([]) == []\nassert op_dropwhileneg_oremptyzero_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_oremptyzero_neg([5, 5, 5]) == []\nassert op_dropwhileneg_oremptyzero_neg([3, 1, 2]) == []\nassert op_dropwhileneg_oremptyzero_neg([10]) == []\nassert op_dropwhileneg_oremptyzero_neg([2, 4, 6]) == []\nassert op_dropwhileneg_oremptyzero_neg([-7, 12, -7]) == [-7]"}
{"id": "op_last3_neg_inc", "entry_point": "op_last3_neg_inc", "primitives": ["last3", "neg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then add one to each.", "solution": "def op_last3_neg_inc(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_last3_neg_inc([1, 2, 3, 4]) == []\nassert op_last3_neg_inc([]) == []\nassert op_last3_neg_inc([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_inc([5, 5, 5]) == []\nassert op_last3_neg_inc([3, 1, 2]) == []\nassert op_last3_neg_inc([10]) == []\nassert op_last3_neg_inc([2, 4, 6]) == []\nassert op_last3_neg_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dec_double_sum", "entry_point": "op_dec_double_sum", "primitives": ["dec", "double", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then return their sum.", "solution": "def op_dec_double_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return sum(r)", "tests": "assert op_dec_double_sum([1, 2, 3, 4]) == 12\nassert op_dec_double_sum([]) == 0\nassert op_dec_double_sum([-2, -1, 0, 1, 2]) == -10\nassert op_dec_double_sum([5, 5, 5]) == 24\nassert op_dec_double_sum([3, 1, 2]) == 6\nassert op_dec_double_sum([10]) == 18\nassert op_dec_double_sum([2, 4, 6]) == 18\nassert op_dec_double_sum([-7, 12, -7]) == -10"}
{"id": "op_takewhilepos_odds_absval", "entry_point": "op_takewhilepos_odds_absval", "primitives": ["takewhilepos", "odds", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then take the absolute value of each.", "solution": "def op_takewhilepos_odds_absval(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_takewhilepos_odds_absval([1, 2, 3, 4]) == [1, 3]\nassert op_takewhilepos_odds_absval([]) == []\nassert op_takewhilepos_odds_absval([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_odds_absval([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_odds_absval([3, 1, 2]) == [3, 1]\nassert op_takewhilepos_odds_absval([10]) == []\nassert op_takewhilepos_odds_absval([2, 4, 6]) == []\nassert op_takewhilepos_odds_absval([-7, 12, -7]) == []"}
{"id": "op_neg_rev_padto3", "entry_point": "op_neg_rev_padto3", "primitives": ["neg", "rev", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then pad with zeros to at least three elements.", "solution": "def op_neg_rev_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_rev_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_rev_padto3([]) == [0, 0, 0]\nassert op_neg_rev_padto3([-2, -1, 0, 1, 2]) == [-1, -2, 0]\nassert op_neg_rev_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_rev_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_rev_padto3([10]) == [0, 0, 0]\nassert op_neg_rev_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_rev_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_add10_last3_max", "entry_point": "op_add10_last3_max", "primitives": ["add10", "last3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_add10_last3_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_add10_last3_max([1, 2, 3, 4]) == 14\nassert op_add10_last3_max([]) == 0\nassert op_add10_last3_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_last3_max([5, 5, 5]) == 15\nassert op_add10_last3_max([3, 1, 2]) == 13\nassert op_add10_last3_max([10]) == 20\nassert op_add10_last3_max([2, 4, 6]) == 16\nassert op_add10_last3_max([-7, 12, -7]) == 22"}
{"id": "op_negate_dropwhileneg_pos", "entry_point": "op_negate_dropwhileneg_pos", "primitives": ["negate", "dropwhileneg", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_negate_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_dropwhileneg_pos([1, 2, 3, 4]) == []\nassert op_negate_dropwhileneg_pos([]) == []\nassert op_negate_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_dropwhileneg_pos([5, 5, 5]) == []\nassert op_negate_dropwhileneg_pos([3, 1, 2]) == []\nassert op_negate_dropwhileneg_pos([10]) == []\nassert op_negate_dropwhileneg_pos([2, 4, 6]) == []\nassert op_negate_dropwhileneg_pos([-7, 12, -7]) == [7, 7]"}
{"id": "op_last3_dec_add10", "entry_point": "op_last3_dec_add10", "primitives": ["last3", "dec", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then add ten to each.", "solution": "def op_last3_dec_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_dec_add10([1, 2, 3, 4]) == [11, 12, 13]\nassert op_last3_dec_add10([]) == []\nassert op_last3_dec_add10([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_last3_dec_add10([5, 5, 5]) == [14, 14, 14]\nassert op_last3_dec_add10([3, 1, 2]) == [12, 10, 11]\nassert op_last3_dec_add10([10]) == [19]\nassert op_last3_dec_add10([2, 4, 6]) == [11, 13, 15]\nassert op_last3_dec_add10([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_dec_inc_haszero", "entry_point": "op_dec_inc_haszero", "primitives": ["dec", "inc", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then return whether the list contains a zero.", "solution": "def op_dec_inc_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_dec_inc_haszero([1, 2, 3, 4]) == False\nassert op_dec_inc_haszero([]) == False\nassert op_dec_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dec_inc_haszero([5, 5, 5]) == False\nassert op_dec_inc_haszero([3, 1, 2]) == False\nassert op_dec_inc_haszero([10]) == False\nassert op_dec_inc_haszero([2, 4, 6]) == False\nassert op_dec_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_dropzeros_sorta_sortabs", "entry_point": "op_dropzeros_sorta_sortabs", "primitives": ["dropzeros", "sorta", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then sort by absolute value.", "solution": "def op_dropzeros_sorta_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_sorta_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sorta_sortabs([]) == []\nassert op_dropzeros_sorta_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_dropzeros_sorta_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sorta_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sorta_sortabs([10]) == [10]\nassert op_dropzeros_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sorta_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_ages_neg_padto3", "entry_point": "op_ages_neg_padto3", "primitives": ["ages", "neg", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_ages_neg_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_neg_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [0, 0, 0]\nassert op_ages_neg_padto3([]) == [0, 0, 0]\nassert op_ages_neg_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [0, 0, 0]\nassert op_ages_neg_padto3([{'name': 'Fi', 'age': 41}]) == [0, 0, 0]"}
{"id": "op_div3_add10_dec", "entry_point": "op_div3_add10_dec", "primitives": ["div3", "add10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each, then subtract one from each.", "solution": "def op_div3_add10_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_add10_dec([1, 2, 3, 4]) == [12]\nassert op_div3_add10_dec([]) == []\nassert op_div3_add10_dec([-2, -1, 0, 1, 2]) == [9]\nassert op_div3_add10_dec([5, 5, 5]) == []\nassert op_div3_add10_dec([3, 1, 2]) == [12]\nassert op_div3_add10_dec([10]) == []\nassert op_div3_add10_dec([2, 4, 6]) == [15]\nassert op_div3_add10_dec([-7, 12, -7]) == [21]"}
{"id": "op_pos_clamp10_uniq", "entry_point": "op_pos_clamp10_uniq", "primitives": ["pos", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_pos_clamp10_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_clamp10_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_clamp10_uniq([]) == []\nassert op_pos_clamp10_uniq([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_clamp10_uniq([5, 5, 5]) == [5]\nassert op_pos_clamp10_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10_uniq([10]) == [10]\nassert op_pos_clamp10_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10_uniq([-7, 12, -7]) == [10]"}
{"id": "op_takewhilepos_clamp10_div3", "entry_point": "op_takewhilepos_clamp10_div3", "primitives": ["takewhilepos", "clamp10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then keep multiples of three.", "solution": "def op_takewhilepos_clamp10_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_clamp10_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_clamp10_div3([]) == []\nassert op_takewhilepos_clamp10_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10_div3([5, 5, 5]) == []\nassert op_takewhilepos_clamp10_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_clamp10_div3([10]) == []\nassert op_takewhilepos_clamp10_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_clamp10_div3([-7, 12, -7]) == []"}
{"id": "op_negate_sorta_absval", "entry_point": "op_negate_sorta_absval", "primitives": ["negate", "sorta", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then take the absolute value of each.", "solution": "def op_negate_sorta_absval(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_negate_sorta_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_negate_sorta_absval([]) == []\nassert op_negate_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_negate_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_negate_sorta_absval([3, 1, 2]) == [3, 2, 1]\nassert op_negate_sorta_absval([10]) == [10]\nassert op_negate_sorta_absval([2, 4, 6]) == [6, 4, 2]\nassert op_negate_sorta_absval([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_first3_oremptyzero_gt5", "entry_point": "op_first3_oremptyzero_gt5", "primitives": ["first3", "oremptyzero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then keep values greater than five.", "solution": "def op_first3_oremptyzero_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_oremptyzero_gt5([1, 2, 3, 4]) == []\nassert op_first3_oremptyzero_gt5([]) == []\nassert op_first3_oremptyzero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_oremptyzero_gt5([5, 5, 5]) == []\nassert op_first3_oremptyzero_gt5([3, 1, 2]) == []\nassert op_first3_oremptyzero_gt5([10]) == [10]\nassert op_first3_oremptyzero_gt5([2, 4, 6]) == [6]\nassert op_first3_oremptyzero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_ages_add10_haszero", "entry_point": "op_ages_add10_haszero", "primitives": ["ages", "add10", "haszero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then return whether the list contains a zero.", "solution": "def op_ages_add10_haszero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    return 0 in r", "tests": "assert op_ages_add10_haszero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_add10_haszero([]) == False\nassert op_ages_add10_haszero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_add10_haszero([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_odds_clamp10_first3", "entry_point": "op_odds_clamp10_first3", "primitives": ["odds", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then keep only the first three.", "solution": "def op_odds_clamp10_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_odds_clamp10_first3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_clamp10_first3([]) == []\nassert op_odds_clamp10_first3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_clamp10_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_clamp10_first3([3, 1, 2]) == [3, 1]\nassert op_odds_clamp10_first3([10]) == []\nassert op_odds_clamp10_first3([2, 4, 6]) == []\nassert op_odds_clamp10_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_odds_neg_anyeven", "entry_point": "op_odds_neg_anyeven", "primitives": ["odds", "neg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then return whether any value is even.", "solution": "def op_odds_neg_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_odds_neg_anyeven([1, 2, 3, 4]) == False\nassert op_odds_neg_anyeven([]) == False\nassert op_odds_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_odds_neg_anyeven([5, 5, 5]) == False\nassert op_odds_neg_anyeven([3, 1, 2]) == False\nassert op_odds_neg_anyeven([10]) == False\nassert op_odds_neg_anyeven([2, 4, 6]) == False\nassert op_odds_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_dec_square_padto3", "entry_point": "op_dec_square_padto3", "primitives": ["dec", "square", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then pad with zeros to at least three elements.", "solution": "def op_dec_square_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_square_padto3([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_dec_square_padto3([]) == [0, 0, 0]\nassert op_dec_square_padto3([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_dec_square_padto3([5, 5, 5]) == [16, 16, 16]\nassert op_dec_square_padto3([3, 1, 2]) == [4, 0, 1]\nassert op_dec_square_padto3([10]) == [81, 0, 0]\nassert op_dec_square_padto3([2, 4, 6]) == [1, 9, 25]\nassert op_dec_square_padto3([-7, 12, -7]) == [64, 121, 64]"}
{"id": "op_double_rev_dec", "entry_point": "op_double_rev_dec", "primitives": ["double", "rev", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then subtract one from each.", "solution": "def op_double_rev_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_rev_dec([1, 2, 3, 4]) == [7, 5, 3, 1]\nassert op_double_rev_dec([]) == []\nassert op_double_rev_dec([-2, -1, 0, 1, 2]) == [3, 1, -1, -3, -5]\nassert op_double_rev_dec([5, 5, 5]) == [9, 9, 9]\nassert op_double_rev_dec([3, 1, 2]) == [3, 1, 5]\nassert op_double_rev_dec([10]) == [19]\nassert op_double_rev_dec([2, 4, 6]) == [11, 7, 3]\nassert op_double_rev_dec([-7, 12, -7]) == [-15, 23, -15]"}
{"id": "op_rev_neg_min", "entry_point": "op_rev_neg_min", "primitives": ["rev", "neg", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_rev_neg_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_rev_neg_min([1, 2, 3, 4]) == 0\nassert op_rev_neg_min([]) == 0\nassert op_rev_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_rev_neg_min([5, 5, 5]) == 0\nassert op_rev_neg_min([3, 1, 2]) == 0\nassert op_rev_neg_min([10]) == 0\nassert op_rev_neg_min([2, 4, 6]) == 0\nassert op_rev_neg_min([-7, 12, -7]) == -7"}
{"id": "op_dropzeros_clamp10_rev", "entry_point": "op_dropzeros_clamp10_rev", "primitives": ["dropzeros", "clamp10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then reverse the order.", "solution": "def op_dropzeros_clamp10_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropzeros_clamp10_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_clamp10_rev([]) == []\nassert op_dropzeros_clamp10_rev([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_clamp10_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_clamp10_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropzeros_clamp10_rev([10]) == [10]\nassert op_dropzeros_clamp10_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_clamp10_rev([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_oremptyzero_clamp10_last3", "entry_point": "op_oremptyzero_clamp10_last3", "primitives": ["oremptyzero", "clamp10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then keep only the last three.", "solution": "def op_oremptyzero_clamp10_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_clamp10_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_clamp10_last3([]) == [0]\nassert op_oremptyzero_clamp10_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_clamp10_last3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_clamp10_last3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_clamp10_last3([10]) == [10]\nassert op_oremptyzero_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_beforezero_dropfirst_negate", "entry_point": "op_beforezero_dropfirst_negate", "primitives": ["beforezero", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then negate each.", "solution": "def op_beforezero_dropfirst_negate(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_beforezero_dropfirst_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_beforezero_dropfirst_negate([]) == []\nassert op_beforezero_dropfirst_negate([-2, -1, 0, 1, 2]) == [1]\nassert op_beforezero_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_beforezero_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_beforezero_dropfirst_negate([10]) == []\nassert op_beforezero_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_beforezero_dropfirst_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_uniqs_nonempty_counts", "entry_point": "op_uniqs_nonempty_counts", "primitives": ["uniqs", "nonempty", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop empty strings, then return how many strings remain.", "solution": "def op_uniqs_nonempty_counts(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if s]\n    return len(r)", "tests": "assert op_uniqs_nonempty_counts(['Hello', 'world']) == 2\nassert op_uniqs_nonempty_counts([]) == 0\nassert op_uniqs_nonempty_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_uniqs_nonempty_counts(['one', 'one', 'Two']) == 2\nassert op_uniqs_nonempty_counts(['x']) == 1\nassert op_uniqs_nonempty_counts(['abc', 'de', '']) == 2"}
{"id": "op_clamp10_neg_add10", "entry_point": "op_clamp10_neg_add10", "primitives": ["clamp10", "neg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then add ten to each.", "solution": "def op_clamp10_neg_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_neg_add10([1, 2, 3, 4]) == []\nassert op_clamp10_neg_add10([]) == []\nassert op_clamp10_neg_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_clamp10_neg_add10([5, 5, 5]) == []\nassert op_clamp10_neg_add10([3, 1, 2]) == []\nassert op_clamp10_neg_add10([10]) == []\nassert op_clamp10_neg_add10([2, 4, 6]) == []\nassert op_clamp10_neg_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_dropzeros_square_dropwhileneg", "entry_point": "op_dropzeros_square_dropwhileneg", "primitives": ["dropzeros", "square", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each, then drop the leading negative values.", "solution": "def op_dropzeros_square_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_square_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropzeros_square_dropwhileneg([]) == []\nassert op_dropzeros_square_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_dropzeros_square_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_square_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_dropzeros_square_dropwhileneg([10]) == [100]\nassert op_dropzeros_square_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_square_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_first3_uniq_padto3", "entry_point": "op_first3_uniq_padto3", "primitives": ["first3", "uniq", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_first3_uniq_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_uniq_padto3([]) == [0, 0, 0]\nassert op_first3_uniq_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_first3_uniq_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_uniq_padto3([10]) == [10, 0, 0]\nassert op_first3_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_uniq_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_ages_negate_dec", "entry_point": "op_ages_negate_dec", "primitives": ["ages", "negate", "dec"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then subtract one from each.", "solution": "def op_ages_negate_dec(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_ages_negate_dec([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-37, -13]\nassert op_ages_negate_dec([]) == []\nassert op_ages_negate_dec([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-19, -66, -18]\nassert op_ages_negate_dec([{'name': 'Fi', 'age': 41}]) == [-42]"}
{"id": "op_double_odds_allpos", "entry_point": "op_double_odds_allpos", "primitives": ["double", "odds", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_double_odds_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_double_odds_allpos([1, 2, 3, 4]) == True\nassert op_double_odds_allpos([]) == True\nassert op_double_odds_allpos([-2, -1, 0, 1, 2]) == True\nassert op_double_odds_allpos([5, 5, 5]) == True\nassert op_double_odds_allpos([3, 1, 2]) == True\nassert op_double_odds_allpos([10]) == True\nassert op_double_odds_allpos([2, 4, 6]) == True\nassert op_double_odds_allpos([-7, 12, -7]) == True"}
{"id": "op_padto3_add10_sorta", "entry_point": "op_padto3_add10_sorta", "primitives": ["padto3", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then sort ascending.", "solution": "def op_padto3_add10_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_add10_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_padto3_add10_sorta([]) == [10, 10, 10]\nassert op_padto3_add10_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_padto3_add10_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_padto3_add10_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_padto3_add10_sorta([10]) == [10, 10, 20]\nassert op_padto3_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_padto3_add10_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_add10_div3_pos", "entry_point": "op_add10_div3_pos", "primitives": ["add10", "div3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then keep the positive numbers.", "solution": "def op_add10_div3_pos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_add10_div3_pos([1, 2, 3, 4]) == [12]\nassert op_add10_div3_pos([]) == []\nassert op_add10_div3_pos([-2, -1, 0, 1, 2]) == [9, 12]\nassert op_add10_div3_pos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_div3_pos([3, 1, 2]) == [12]\nassert op_add10_div3_pos([10]) == []\nassert op_add10_div3_pos([2, 4, 6]) == [12]\nassert op_add10_div3_pos([-7, 12, -7]) == [3, 3]"}
{"id": "op_padto3_clamp10_haszero", "entry_point": "op_padto3_clamp10_haszero", "primitives": ["padto3", "clamp10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10, then return whether the list contains a zero.", "solution": "def op_padto3_clamp10_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_padto3_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_padto3_clamp10_haszero([]) == True\nassert op_padto3_clamp10_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_clamp10_haszero([5, 5, 5]) == False\nassert op_padto3_clamp10_haszero([3, 1, 2]) == False\nassert op_padto3_clamp10_haszero([10]) == True\nassert op_padto3_clamp10_haszero([2, 4, 6]) == False\nassert op_padto3_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_clamp10_dropwhileneg", "entry_point": "op_gt5_clamp10_dropwhileneg", "primitives": ["gt5", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then drop the leading negative values.", "solution": "def op_gt5_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_gt5_clamp10_dropwhileneg([1, 2, 3, 4]) == []\nassert op_gt5_clamp10_dropwhileneg([]) == []\nassert op_gt5_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_clamp10_dropwhileneg([5, 5, 5]) == []\nassert op_gt5_clamp10_dropwhileneg([3, 1, 2]) == []\nassert op_gt5_clamp10_dropwhileneg([10]) == [10]\nassert op_gt5_clamp10_dropwhileneg([2, 4, 6]) == [6]\nassert op_gt5_clamp10_dropwhileneg([-7, 12, -7]) == [10]"}
{"id": "op_sorta_sortabs_square", "entry_point": "op_sorta_sortabs_square", "primitives": ["sorta", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then square each.", "solution": "def op_sorta_sortabs_square(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sorta_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sorta_sortabs_square([]) == []\nassert op_sorta_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sorta_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_sorta_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_sorta_sortabs_square([10]) == [100]\nassert op_sorta_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_sorta_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dec_double_oremptyzero", "entry_point": "op_dec_double_oremptyzero", "primitives": ["dec", "double", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then if empty, use a single zero.", "solution": "def op_dec_double_oremptyzero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dec_double_oremptyzero([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_dec_double_oremptyzero([]) == [0]\nassert op_dec_double_oremptyzero([-2, -1, 0, 1, 2]) == [-6, -4, -2, 0, 2]\nassert op_dec_double_oremptyzero([5, 5, 5]) == [8, 8, 8]\nassert op_dec_double_oremptyzero([3, 1, 2]) == [4, 0, 2]\nassert op_dec_double_oremptyzero([10]) == [18]\nassert op_dec_double_oremptyzero([2, 4, 6]) == [2, 6, 10]\nassert op_dec_double_oremptyzero([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_absval_dropzeros_trimends", "entry_point": "op_absval_dropzeros_trimends", "primitives": ["absval", "dropzeros", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then drop the first and last elements.", "solution": "def op_absval_dropzeros_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_dropzeros_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_absval_dropzeros_trimends([]) == []\nassert op_absval_dropzeros_trimends([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_dropzeros_trimends([5, 5, 5]) == [5]\nassert op_absval_dropzeros_trimends([3, 1, 2]) == [1]\nassert op_absval_dropzeros_trimends([10]) == []\nassert op_absval_dropzeros_trimends([2, 4, 6]) == [4]\nassert op_absval_dropzeros_trimends([-7, 12, -7]) == [12]"}
{"id": "op_pos_neg_dec", "entry_point": "op_pos_neg_dec", "primitives": ["pos", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the negative numbers, then subtract one from each.", "solution": "def op_pos_neg_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_pos_neg_dec([1, 2, 3, 4]) == []\nassert op_pos_neg_dec([]) == []\nassert op_pos_neg_dec([-2, -1, 0, 1, 2]) == []\nassert op_pos_neg_dec([5, 5, 5]) == []\nassert op_pos_neg_dec([3, 1, 2]) == []\nassert op_pos_neg_dec([10]) == []\nassert op_pos_neg_dec([2, 4, 6]) == []\nassert op_pos_neg_dec([-7, 12, -7]) == []"}
{"id": "op_absval_sorta_neg", "entry_point": "op_absval_sorta_neg", "primitives": ["absval", "sorta", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then keep the negative numbers.", "solution": "def op_absval_sorta_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_sorta_neg([1, 2, 3, 4]) == []\nassert op_absval_sorta_neg([]) == []\nassert op_absval_sorta_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_sorta_neg([5, 5, 5]) == []\nassert op_absval_sorta_neg([3, 1, 2]) == []\nassert op_absval_sorta_neg([10]) == []\nassert op_absval_sorta_neg([2, 4, 6]) == []\nassert op_absval_sorta_neg([-7, 12, -7]) == []"}
{"id": "op_trimends_neg_last3", "entry_point": "op_trimends_neg_last3", "primitives": ["trimends", "neg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then keep only the last three.", "solution": "def op_trimends_neg_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_neg_last3([1, 2, 3, 4]) == []\nassert op_trimends_neg_last3([]) == []\nassert op_trimends_neg_last3([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_neg_last3([5, 5, 5]) == []\nassert op_trimends_neg_last3([3, 1, 2]) == []\nassert op_trimends_neg_last3([10]) == []\nassert op_trimends_neg_last3([2, 4, 6]) == []\nassert op_trimends_neg_last3([-7, 12, -7]) == []"}
{"id": "op_pos_sortd_div3", "entry_point": "op_pos_sortd_div3", "primitives": ["pos", "sortd", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then keep multiples of three.", "solution": "def op_pos_sortd_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_pos_sortd_div3([1, 2, 3, 4]) == [3]\nassert op_pos_sortd_div3([]) == []\nassert op_pos_sortd_div3([-2, -1, 0, 1, 2]) == []\nassert op_pos_sortd_div3([5, 5, 5]) == []\nassert op_pos_sortd_div3([3, 1, 2]) == [3]\nassert op_pos_sortd_div3([10]) == []\nassert op_pos_sortd_div3([2, 4, 6]) == [6]\nassert op_pos_sortd_div3([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_absval_pos", "entry_point": "op_beforezero_absval_pos", "primitives": ["beforezero", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_beforezero_absval_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_absval_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_absval_pos([]) == []\nassert op_beforezero_absval_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_absval_pos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_absval_pos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_absval_pos([10]) == [10]\nassert op_beforezero_absval_pos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_absval_pos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_neg_sortabs_anyeven", "entry_point": "op_neg_sortabs_anyeven", "primitives": ["neg", "sortabs", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then return whether any value is even.", "solution": "def op_neg_sortabs_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_neg_sortabs_anyeven([1, 2, 3, 4]) == False\nassert op_neg_sortabs_anyeven([]) == False\nassert op_neg_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_neg_sortabs_anyeven([5, 5, 5]) == False\nassert op_neg_sortabs_anyeven([3, 1, 2]) == False\nassert op_neg_sortabs_anyeven([10]) == False\nassert op_neg_sortabs_anyeven([2, 4, 6]) == False\nassert op_neg_sortabs_anyeven([-7, 12, -7]) == False"}
{"id": "op_clamp10_sortd_rev", "entry_point": "op_clamp10_sortd_rev", "primitives": ["clamp10", "sortd", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then reverse the order.", "solution": "def op_clamp10_sortd_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_sortd_rev([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sortd_rev([]) == []\nassert op_clamp10_sortd_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_sortd_rev([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortd_rev([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sortd_rev([10]) == [10]\nassert op_clamp10_sortd_rev([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sortd_rev([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_pos_rev_dropzeros", "entry_point": "op_pos_rev_dropzeros", "primitives": ["pos", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then drop the zeros.", "solution": "def op_pos_rev_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_rev_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_rev_dropzeros([]) == []\nassert op_pos_rev_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_rev_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_rev_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_pos_rev_dropzeros([10]) == [10]\nassert op_pos_rev_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_pos_rev_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_odds_sortd_dropfirst", "entry_point": "op_odds_sortd_dropfirst", "primitives": ["odds", "sortd", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort descending, then drop the first element.", "solution": "def op_odds_sortd_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return r", "tests": "assert op_odds_sortd_dropfirst([1, 2, 3, 4]) == [1]\nassert op_odds_sortd_dropfirst([]) == []\nassert op_odds_sortd_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_sortd_dropfirst([5, 5, 5]) == [5, 5]\nassert op_odds_sortd_dropfirst([3, 1, 2]) == [1]\nassert op_odds_sortd_dropfirst([10]) == []\nassert op_odds_sortd_dropfirst([2, 4, 6]) == []\nassert op_odds_sortd_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_gt5_square_sum", "entry_point": "op_gt5_square_sum", "primitives": ["gt5", "square", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then square each, then return their sum.", "solution": "def op_gt5_square_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_gt5_square_sum([1, 2, 3, 4]) == 0\nassert op_gt5_square_sum([]) == 0\nassert op_gt5_square_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_square_sum([5, 5, 5]) == 0\nassert op_gt5_square_sum([3, 1, 2]) == 0\nassert op_gt5_square_sum([10]) == 100\nassert op_gt5_square_sum([2, 4, 6]) == 36\nassert op_gt5_square_sum([-7, 12, -7]) == 144"}
{"id": "op_neg_negate_inc", "entry_point": "op_neg_negate_inc", "primitives": ["neg", "negate", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then add one to each.", "solution": "def op_neg_negate_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_neg_negate_inc([1, 2, 3, 4]) == []\nassert op_neg_negate_inc([]) == []\nassert op_neg_negate_inc([-2, -1, 0, 1, 2]) == [3, 2]\nassert op_neg_negate_inc([5, 5, 5]) == []\nassert op_neg_negate_inc([3, 1, 2]) == []\nassert op_neg_negate_inc([10]) == []\nassert op_neg_negate_inc([2, 4, 6]) == []\nassert op_neg_negate_inc([-7, 12, -7]) == [8, 8]"}
{"id": "op_padto3_takewhilepos_sortabs", "entry_point": "op_padto3_takewhilepos_sortabs", "primitives": ["padto3", "takewhilepos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then sort by absolute value.", "solution": "def op_padto3_takewhilepos_sortabs(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_padto3_takewhilepos_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_takewhilepos_sortabs([]) == []\nassert op_padto3_takewhilepos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_takewhilepos_sortabs([10]) == [10]\nassert op_padto3_takewhilepos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_sortabs([-7, 12, -7]) == []"}
{"id": "op_ages_dropfirst_div3", "entry_point": "op_ages_dropfirst_div3", "primitives": ["ages", "dropfirst", "div3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then keep multiples of three.", "solution": "def op_ages_dropfirst_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_dropfirst_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst_div3([]) == []\nassert op_ages_dropfirst_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_dropfirst_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_neg_takewhilepos_padto3", "entry_point": "op_neg_takewhilepos_padto3", "primitives": ["neg", "takewhilepos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_neg_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_takewhilepos_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([10]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_takewhilepos_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_strip_sortlen_lens", "entry_point": "op_strip_sortlen_lens", "primitives": ["strip", "sortlen", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first, then return the total number of characters.", "solution": "def op_strip_sortlen_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return sum(len(s) for s in r)", "tests": "assert op_strip_sortlen_lens(['Hello', 'world']) == 10\nassert op_strip_sortlen_lens([]) == 0\nassert op_strip_sortlen_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_strip_sortlen_lens(['one', 'one', 'Two']) == 9\nassert op_strip_sortlen_lens(['x']) == 1\nassert op_strip_sortlen_lens(['abc', 'de', '']) == 5"}
{"id": "op_add10_dropwhileneg_double", "entry_point": "op_add10_dropwhileneg_double", "primitives": ["add10", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then double each.", "solution": "def op_add10_dropwhileneg_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_dropwhileneg_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_add10_dropwhileneg_double([]) == []\nassert op_add10_dropwhileneg_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_add10_dropwhileneg_double([5, 5, 5]) == [30, 30, 30]\nassert op_add10_dropwhileneg_double([3, 1, 2]) == [26, 22, 24]\nassert op_add10_dropwhileneg_double([10]) == [40]\nassert op_add10_dropwhileneg_double([2, 4, 6]) == [24, 28, 32]\nassert op_add10_dropwhileneg_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_ages_dec_dropwhileneg", "entry_point": "op_ages_dec_dropwhileneg", "primitives": ["ages", "dec", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then drop the leading negative values.", "solution": "def op_ages_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_dec_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11]\nassert op_ages_dec_dropwhileneg([]) == []\nassert op_ages_dec_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 64, 16]\nassert op_ages_dec_dropwhileneg([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_inc_trimends_anyeven", "entry_point": "op_inc_trimends_anyeven", "primitives": ["inc", "trimends", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then return whether any value is even.", "solution": "def op_inc_trimends_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_trimends_anyeven([1, 2, 3, 4]) == True\nassert op_inc_trimends_anyeven([]) == False\nassert op_inc_trimends_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_trimends_anyeven([5, 5, 5]) == True\nassert op_inc_trimends_anyeven([3, 1, 2]) == True\nassert op_inc_trimends_anyeven([10]) == False\nassert op_inc_trimends_anyeven([2, 4, 6]) == False\nassert op_inc_trimends_anyeven([-7, 12, -7]) == False"}
{"id": "op_pos_sortabs_double", "entry_point": "op_pos_sortabs_double", "primitives": ["pos", "sortabs", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then double each.", "solution": "def op_pos_sortabs_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_sortabs_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_sortabs_double([]) == []\nassert op_pos_sortabs_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_sortabs_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_sortabs_double([3, 1, 2]) == [2, 4, 6]\nassert op_pos_sortabs_double([10]) == [20]\nassert op_pos_sortabs_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_sortabs_double([-7, 12, -7]) == [24]"}
{"id": "op_sorta_dropzeros_counteven", "entry_point": "op_sorta_dropzeros_counteven", "primitives": ["sorta", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then return how many values are even.", "solution": "def op_sorta_dropzeros_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_dropzeros_counteven([]) == 0\nassert op_sorta_dropzeros_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_dropzeros_counteven([5, 5, 5]) == 0\nassert op_sorta_dropzeros_counteven([3, 1, 2]) == 1\nassert op_sorta_dropzeros_counteven([10]) == 1\nassert op_sorta_dropzeros_counteven([2, 4, 6]) == 3\nassert op_sorta_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_ages_dropwhileneg_gt5", "entry_point": "op_ages_dropwhileneg_gt5", "primitives": ["ages", "dropwhileneg", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then keep values greater than five.", "solution": "def op_ages_dropwhileneg_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_dropwhileneg_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropwhileneg_gt5([]) == []\nassert op_ages_dropwhileneg_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropwhileneg_gt5([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropzeros_sortabs_absval", "entry_point": "op_dropzeros_sortabs_absval", "primitives": ["dropzeros", "sortabs", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then take the absolute value of each.", "solution": "def op_dropzeros_sortabs_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_sortabs_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sortabs_absval([]) == []\nassert op_dropzeros_sortabs_absval([-2, -1, 0, 1, 2]) == [1, 1, 2, 2]\nassert op_dropzeros_sortabs_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortabs_absval([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sortabs_absval([10]) == [10]\nassert op_dropzeros_sortabs_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sortabs_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_double_gt5_min", "entry_point": "op_double_gt5_min", "primitives": ["double", "gt5", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_double_gt5_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_double_gt5_min([1, 2, 3, 4]) == 6\nassert op_double_gt5_min([]) == 0\nassert op_double_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_double_gt5_min([5, 5, 5]) == 10\nassert op_double_gt5_min([3, 1, 2]) == 6\nassert op_double_gt5_min([10]) == 20\nassert op_double_gt5_min([2, 4, 6]) == 8\nassert op_double_gt5_min([-7, 12, -7]) == 24"}
{"id": "op_dec_padto3_negate", "entry_point": "op_dec_padto3_negate", "primitives": ["dec", "padto3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then negate each.", "solution": "def op_dec_padto3_negate(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_dec_padto3_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_dec_padto3_negate([]) == [0, 0, 0]\nassert op_dec_padto3_negate([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_dec_padto3_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_padto3_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_dec_padto3_negate([10]) == [-9, 0, 0]\nassert op_dec_padto3_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_padto3_negate([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_ages_beforezero_first3", "entry_point": "op_ages_beforezero_first3", "primitives": ["ages", "beforezero", "first3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then keep only the first three.", "solution": "def op_ages_beforezero_first3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return r", "tests": "assert op_ages_beforezero_first3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_beforezero_first3([]) == []\nassert op_ages_beforezero_first3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_beforezero_first3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_ages_negate_gt5", "entry_point": "op_ages_negate_gt5", "primitives": ["ages", "negate", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then keep values greater than five.", "solution": "def op_ages_negate_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_negate_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_negate_gt5([]) == []\nassert op_ages_negate_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_negate_gt5([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_evens_dropfirst_padto3", "entry_point": "op_evens_dropfirst_padto3", "primitives": ["evens", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_evens_dropfirst_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_evens_dropfirst_padto3([1, 2, 3, 4]) == [4, 0, 0]\nassert op_evens_dropfirst_padto3([]) == [0, 0, 0]\nassert op_evens_dropfirst_padto3([-2, -1, 0, 1, 2]) == [0, 2, 0]\nassert op_evens_dropfirst_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_evens_dropfirst_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_evens_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_evens_dropfirst_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_evens_dropfirst_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_dropfirst_gt5_negate", "entry_point": "op_dropfirst_gt5_negate", "primitives": ["dropfirst", "gt5", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep values greater than five, then negate each.", "solution": "def op_dropfirst_gt5_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_gt5_negate([1, 2, 3, 4]) == []\nassert op_dropfirst_gt5_negate([]) == []\nassert op_dropfirst_gt5_negate([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_gt5_negate([5, 5, 5]) == []\nassert op_dropfirst_gt5_negate([3, 1, 2]) == []\nassert op_dropfirst_gt5_negate([10]) == []\nassert op_dropfirst_gt5_negate([2, 4, 6]) == [-6]\nassert op_dropfirst_gt5_negate([-7, 12, -7]) == [-12]"}
{"id": "op_first3_absval_padto3", "entry_point": "op_first3_absval_padto3", "primitives": ["first3", "absval", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_first3_absval_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_absval_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_absval_padto3([]) == [0, 0, 0]\nassert op_first3_absval_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_first3_absval_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_absval_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_absval_padto3([10]) == [10, 0, 0]\nassert op_first3_absval_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_absval_padto3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_first3_add10_trimends", "entry_point": "op_first3_add10_trimends", "primitives": ["first3", "add10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then drop the first and last elements.", "solution": "def op_first3_add10_trimends(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_first3_add10_trimends([1, 2, 3, 4]) == [12]\nassert op_first3_add10_trimends([]) == []\nassert op_first3_add10_trimends([-2, -1, 0, 1, 2]) == [9]\nassert op_first3_add10_trimends([5, 5, 5]) == [15]\nassert op_first3_add10_trimends([3, 1, 2]) == [11]\nassert op_first3_add10_trimends([10]) == []\nassert op_first3_add10_trimends([2, 4, 6]) == [14]\nassert op_first3_add10_trimends([-7, 12, -7]) == [22]"}
{"id": "op_sortd_neg_sorta", "entry_point": "op_sortd_neg_sorta", "primitives": ["sortd", "neg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then sort ascending.", "solution": "def op_sortd_neg_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_neg_sorta([1, 2, 3, 4]) == []\nassert op_sortd_neg_sorta([]) == []\nassert op_sortd_neg_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sortd_neg_sorta([5, 5, 5]) == []\nassert op_sortd_neg_sorta([3, 1, 2]) == []\nassert op_sortd_neg_sorta([10]) == []\nassert op_sortd_neg_sorta([2, 4, 6]) == []\nassert op_sortd_neg_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dec_first3_issorted", "entry_point": "op_dec_first3_issorted", "primitives": ["dec", "first3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_dec_first3_issorted(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_dec_first3_issorted([1, 2, 3, 4]) == True\nassert op_dec_first3_issorted([]) == True\nassert op_dec_first3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dec_first3_issorted([5, 5, 5]) == True\nassert op_dec_first3_issorted([3, 1, 2]) == False\nassert op_dec_first3_issorted([10]) == True\nassert op_dec_first3_issorted([2, 4, 6]) == True\nassert op_dec_first3_issorted([-7, 12, -7]) == False"}
{"id": "op_ages_first3_issorted", "entry_point": "op_ages_first3_issorted", "primitives": ["ages", "first3", "issorted"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_ages_first3_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_ages_first3_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_first3_issorted([]) == True\nassert op_ages_first3_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_first3_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_negate_beforezero_trimends", "entry_point": "op_negate_beforezero_trimends", "primitives": ["negate", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_negate_beforezero_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_beforezero_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_negate_beforezero_trimends([]) == []\nassert op_negate_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_negate_beforezero_trimends([5, 5, 5]) == [-5]\nassert op_negate_beforezero_trimends([3, 1, 2]) == [-1]\nassert op_negate_beforezero_trimends([10]) == []\nassert op_negate_beforezero_trimends([2, 4, 6]) == [-4]\nassert op_negate_beforezero_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_neg_dec_firsteven", "entry_point": "op_neg_dec_firsteven", "primitives": ["neg", "dec", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then return the first even value (0 if none).", "solution": "def op_neg_dec_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_dec_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_dec_firsteven([]) == 0\nassert op_neg_dec_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_neg_dec_firsteven([5, 5, 5]) == 0\nassert op_neg_dec_firsteven([3, 1, 2]) == 0\nassert op_neg_dec_firsteven([10]) == 0\nassert op_neg_dec_firsteven([2, 4, 6]) == 0\nassert op_neg_dec_firsteven([-7, 12, -7]) == -8"}
{"id": "op_pos_first3_min", "entry_point": "op_pos_first3_min", "primitives": ["pos", "first3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_pos_first3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_pos_first3_min([1, 2, 3, 4]) == 1\nassert op_pos_first3_min([]) == 0\nassert op_pos_first3_min([-2, -1, 0, 1, 2]) == 1\nassert op_pos_first3_min([5, 5, 5]) == 5\nassert op_pos_first3_min([3, 1, 2]) == 1\nassert op_pos_first3_min([10]) == 10\nassert op_pos_first3_min([2, 4, 6]) == 2\nassert op_pos_first3_min([-7, 12, -7]) == 12"}
{"id": "op_uniq_dropfirst_gt5", "entry_point": "op_uniq_dropfirst_gt5", "primitives": ["uniq", "dropfirst", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then keep values greater than five.", "solution": "def op_uniq_dropfirst_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_dropfirst_gt5([1, 2, 3, 4]) == []\nassert op_uniq_dropfirst_gt5([]) == []\nassert op_uniq_dropfirst_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_dropfirst_gt5([5, 5, 5]) == []\nassert op_uniq_dropfirst_gt5([3, 1, 2]) == []\nassert op_uniq_dropfirst_gt5([10]) == []\nassert op_uniq_dropfirst_gt5([2, 4, 6]) == [6]\nassert op_uniq_dropfirst_gt5([-7, 12, -7]) == [12]"}
{"id": "op_absval_gt5_dec", "entry_point": "op_absval_gt5_dec", "primitives": ["absval", "gt5", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then subtract one from each.", "solution": "def op_absval_gt5_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_gt5_dec([1, 2, 3, 4]) == []\nassert op_absval_gt5_dec([]) == []\nassert op_absval_gt5_dec([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_dec([5, 5, 5]) == []\nassert op_absval_gt5_dec([3, 1, 2]) == []\nassert op_absval_gt5_dec([10]) == [9]\nassert op_absval_gt5_dec([2, 4, 6]) == [5]\nassert op_absval_gt5_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_negate_inc_counteven", "entry_point": "op_negate_inc_counteven", "primitives": ["negate", "inc", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then return how many values are even.", "solution": "def op_negate_inc_counteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_negate_inc_counteven([1, 2, 3, 4]) == 2\nassert op_negate_inc_counteven([]) == 0\nassert op_negate_inc_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_negate_inc_counteven([5, 5, 5]) == 3\nassert op_negate_inc_counteven([3, 1, 2]) == 2\nassert op_negate_inc_counteven([10]) == 0\nassert op_negate_inc_counteven([2, 4, 6]) == 0\nassert op_negate_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_dropfirst_odds_evens", "entry_point": "op_dropfirst_odds_evens", "primitives": ["dropfirst", "odds", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then keep the even numbers.", "solution": "def op_dropfirst_odds_evens(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropfirst_odds_evens([1, 2, 3, 4]) == []\nassert op_dropfirst_odds_evens([]) == []\nassert op_dropfirst_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_odds_evens([5, 5, 5]) == []\nassert op_dropfirst_odds_evens([3, 1, 2]) == []\nassert op_dropfirst_odds_evens([10]) == []\nassert op_dropfirst_odds_evens([2, 4, 6]) == []\nassert op_dropfirst_odds_evens([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_first3_add10", "entry_point": "op_dropwhileneg_first3_add10", "primitives": ["dropwhileneg", "first3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then add ten to each.", "solution": "def op_dropwhileneg_first3_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_first3_add10([1, 2, 3, 4]) == [11, 12, 13]\nassert op_dropwhileneg_first3_add10([]) == []\nassert op_dropwhileneg_first3_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_first3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_first3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_first3_add10([10]) == [20]\nassert op_dropwhileneg_first3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_first3_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_odds_pos_negate", "entry_point": "op_odds_pos_negate", "primitives": ["odds", "pos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then negate each.", "solution": "def op_odds_pos_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_pos_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_pos_negate([]) == []\nassert op_odds_pos_negate([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_pos_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_pos_negate([3, 1, 2]) == [-3, -1]\nassert op_odds_pos_negate([10]) == []\nassert op_odds_pos_negate([2, 4, 6]) == []\nassert op_odds_pos_negate([-7, 12, -7]) == []"}
{"id": "op_beforezero_trimends_clamp10", "entry_point": "op_beforezero_trimends_clamp10", "primitives": ["beforezero", "trimends", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then cap each value at 10.", "solution": "def op_beforezero_trimends_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_trimends_clamp10([1, 2, 3, 4]) == [2, 3]\nassert op_beforezero_trimends_clamp10([]) == []\nassert op_beforezero_trimends_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_trimends_clamp10([5, 5, 5]) == [5]\nassert op_beforezero_trimends_clamp10([3, 1, 2]) == [1]\nassert op_beforezero_trimends_clamp10([10]) == []\nassert op_beforezero_trimends_clamp10([2, 4, 6]) == [4]\nassert op_beforezero_trimends_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_first3_inc_rev", "entry_point": "op_first3_inc_rev", "primitives": ["first3", "inc", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then reverse the order.", "solution": "def op_first3_inc_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_inc_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_first3_inc_rev([]) == []\nassert op_first3_inc_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_first3_inc_rev([5, 5, 5]) == [6, 6, 6]\nassert op_first3_inc_rev([3, 1, 2]) == [3, 2, 4]\nassert op_first3_inc_rev([10]) == [11]\nassert op_first3_inc_rev([2, 4, 6]) == [7, 5, 3]\nassert op_first3_inc_rev([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_beforezero_trimends_max", "entry_point": "op_beforezero_trimends_max", "primitives": ["beforezero", "trimends", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_beforezero_trimends_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_beforezero_trimends_max([1, 2, 3, 4]) == 3\nassert op_beforezero_trimends_max([]) == 0\nassert op_beforezero_trimends_max([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_trimends_max([5, 5, 5]) == 5\nassert op_beforezero_trimends_max([3, 1, 2]) == 1\nassert op_beforezero_trimends_max([10]) == 0\nassert op_beforezero_trimends_max([2, 4, 6]) == 4\nassert op_beforezero_trimends_max([-7, 12, -7]) == 12"}
{"id": "op_sorta_neg_sortabs", "entry_point": "op_sorta_neg_sortabs", "primitives": ["sorta", "neg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers, then sort by absolute value.", "solution": "def op_sorta_neg_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_neg_sortabs([1, 2, 3, 4]) == []\nassert op_sorta_neg_sortabs([]) == []\nassert op_sorta_neg_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sorta_neg_sortabs([5, 5, 5]) == []\nassert op_sorta_neg_sortabs([3, 1, 2]) == []\nassert op_sorta_neg_sortabs([10]) == []\nassert op_sorta_neg_sortabs([2, 4, 6]) == []\nassert op_sorta_neg_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_uniq_square", "entry_point": "op_clamp10_uniq_square", "primitives": ["clamp10", "uniq", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then square each.", "solution": "def op_clamp10_uniq_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_uniq_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_uniq_square([]) == []\nassert op_clamp10_uniq_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_clamp10_uniq_square([5, 5, 5]) == [25]\nassert op_clamp10_uniq_square([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_uniq_square([10]) == [100]\nassert op_clamp10_uniq_square([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_uniq_square([-7, 12, -7]) == [49, 100]"}
{"id": "op_rev_last3_dec", "entry_point": "op_rev_last3_dec", "primitives": ["rev", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then subtract one from each.", "solution": "def op_rev_last3_dec(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_rev_last3_dec([1, 2, 3, 4]) == [2, 1, 0]\nassert op_rev_last3_dec([]) == []\nassert op_rev_last3_dec([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_rev_last3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_rev_last3_dec([3, 1, 2]) == [1, 0, 2]\nassert op_rev_last3_dec([10]) == [9]\nassert op_rev_last3_dec([2, 4, 6]) == [5, 3, 1]\nassert op_rev_last3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropwhileneg_negate_div3", "entry_point": "op_dropwhileneg_negate_div3", "primitives": ["dropwhileneg", "negate", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then keep multiples of three.", "solution": "def op_dropwhileneg_negate_div3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropwhileneg_negate_div3([1, 2, 3, 4]) == [-3]\nassert op_dropwhileneg_negate_div3([]) == []\nassert op_dropwhileneg_negate_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_negate_div3([5, 5, 5]) == []\nassert op_dropwhileneg_negate_div3([3, 1, 2]) == [-3]\nassert op_dropwhileneg_negate_div3([10]) == []\nassert op_dropwhileneg_negate_div3([2, 4, 6]) == [-6]\nassert op_dropwhileneg_negate_div3([-7, 12, -7]) == [-12]"}
{"id": "op_sorta_absval_issorted", "entry_point": "op_sorta_absval_issorted", "primitives": ["sorta", "absval", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_sorta_absval_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_sorta_absval_issorted([1, 2, 3, 4]) == True\nassert op_sorta_absval_issorted([]) == True\nassert op_sorta_absval_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sorta_absval_issorted([5, 5, 5]) == True\nassert op_sorta_absval_issorted([3, 1, 2]) == True\nassert op_sorta_absval_issorted([10]) == True\nassert op_sorta_absval_issorted([2, 4, 6]) == True\nassert op_sorta_absval_issorted([-7, 12, -7]) == True"}
{"id": "op_square_evens_trimends", "entry_point": "op_square_evens_trimends", "primitives": ["square", "evens", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then drop the first and last elements.", "solution": "def op_square_evens_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_square_evens_trimends([1, 2, 3, 4]) == []\nassert op_square_evens_trimends([]) == []\nassert op_square_evens_trimends([-2, -1, 0, 1, 2]) == [0]\nassert op_square_evens_trimends([5, 5, 5]) == []\nassert op_square_evens_trimends([3, 1, 2]) == []\nassert op_square_evens_trimends([10]) == []\nassert op_square_evens_trimends([2, 4, 6]) == [16]\nassert op_square_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_first3_sorta_absval", "entry_point": "op_first3_sorta_absval", "primitives": ["first3", "sorta", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then take the absolute value of each.", "solution": "def op_first3_sorta_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_sorta_absval([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta_absval([]) == []\nassert op_first3_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_first3_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta_absval([10]) == [10]\nassert op_first3_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_dropzeros_beforezero_counteven", "entry_point": "op_dropzeros_beforezero_counteven", "primitives": ["dropzeros", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then return how many values are even.", "solution": "def op_dropzeros_beforezero_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_beforezero_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_beforezero_counteven([]) == 0\nassert op_dropzeros_beforezero_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_beforezero_counteven([5, 5, 5]) == 0\nassert op_dropzeros_beforezero_counteven([3, 1, 2]) == 1\nassert op_dropzeros_beforezero_counteven([10]) == 1\nassert op_dropzeros_beforezero_counteven([2, 4, 6]) == 3\nassert op_dropzeros_beforezero_counteven([-7, 12, -7]) == 1"}
{"id": "op_padto3_sortabs_gt5", "entry_point": "op_padto3_sortabs_gt5", "primitives": ["padto3", "sortabs", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then keep values greater than five.", "solution": "def op_padto3_sortabs_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_sortabs_gt5([1, 2, 3, 4]) == []\nassert op_padto3_sortabs_gt5([]) == []\nassert op_padto3_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_sortabs_gt5([5, 5, 5]) == []\nassert op_padto3_sortabs_gt5([3, 1, 2]) == []\nassert op_padto3_sortabs_gt5([10]) == [10]\nassert op_padto3_sortabs_gt5([2, 4, 6]) == [6]\nassert op_padto3_sortabs_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_inc_allpos", "entry_point": "op_sortabs_inc_allpos", "primitives": ["sortabs", "inc", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then return whether all values are positive.", "solution": "def op_sortabs_inc_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_inc_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_inc_allpos([]) == True\nassert op_sortabs_inc_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_inc_allpos([5, 5, 5]) == True\nassert op_sortabs_inc_allpos([3, 1, 2]) == True\nassert op_sortabs_inc_allpos([10]) == True\nassert op_sortabs_inc_allpos([2, 4, 6]) == True\nassert op_sortabs_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_absval_oremptyzero_inc", "entry_point": "op_absval_oremptyzero_inc", "primitives": ["absval", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then if empty, use a single zero, then add one to each.", "solution": "def op_absval_oremptyzero_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_oremptyzero_inc([]) == [1]\nassert op_absval_oremptyzero_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 2, 3]\nassert op_absval_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_absval_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_absval_oremptyzero_inc([10]) == [11]\nassert op_absval_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_absval_oremptyzero_inc([-7, 12, -7]) == [8, 13, 8]"}
{"id": "op_first3_dec_trimends", "entry_point": "op_first3_dec_trimends", "primitives": ["first3", "dec", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then drop the first and last elements.", "solution": "def op_first3_dec_trimends(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_first3_dec_trimends([1, 2, 3, 4]) == [1]\nassert op_first3_dec_trimends([]) == []\nassert op_first3_dec_trimends([-2, -1, 0, 1, 2]) == [-2]\nassert op_first3_dec_trimends([5, 5, 5]) == [4]\nassert op_first3_dec_trimends([3, 1, 2]) == [0]\nassert op_first3_dec_trimends([10]) == []\nassert op_first3_dec_trimends([2, 4, 6]) == [3]\nassert op_first3_dec_trimends([-7, 12, -7]) == [11]"}
{"id": "op_ages_dropwhileneg_allpos", "entry_point": "op_ages_dropwhileneg_allpos", "primitives": ["ages", "dropwhileneg", "allpos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then return whether all values are positive.", "solution": "def op_ages_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_ages_dropwhileneg_allpos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_dropwhileneg_allpos([]) == True\nassert op_ages_dropwhileneg_allpos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_dropwhileneg_allpos([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_gt5_dropzeros_sortabs", "entry_point": "op_gt5_dropzeros_sortabs", "primitives": ["gt5", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros, then sort by absolute value.", "solution": "def op_gt5_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_dropzeros_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_dropzeros_sortabs([]) == []\nassert op_gt5_dropzeros_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropzeros_sortabs([5, 5, 5]) == []\nassert op_gt5_dropzeros_sortabs([3, 1, 2]) == []\nassert op_gt5_dropzeros_sortabs([10]) == [10]\nassert op_gt5_dropzeros_sortabs([2, 4, 6]) == [6]\nassert op_gt5_dropzeros_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_negate_odds_sortabs", "entry_point": "op_negate_odds_sortabs", "primitives": ["negate", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then sort by absolute value.", "solution": "def op_negate_odds_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_odds_sortabs([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_odds_sortabs([]) == []\nassert op_negate_odds_sortabs([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_odds_sortabs([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_odds_sortabs([3, 1, 2]) == [-1, -3]\nassert op_negate_odds_sortabs([10]) == []\nassert op_negate_odds_sortabs([2, 4, 6]) == []\nassert op_negate_odds_sortabs([-7, 12, -7]) == [7, 7]"}
{"id": "op_pos_double_firsteven", "entry_point": "op_pos_double_firsteven", "primitives": ["pos", "double", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then return the first even value (0 if none).", "solution": "def op_pos_double_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_double_firsteven([1, 2, 3, 4]) == 2\nassert op_pos_double_firsteven([]) == 0\nassert op_pos_double_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_double_firsteven([5, 5, 5]) == 10\nassert op_pos_double_firsteven([3, 1, 2]) == 6\nassert op_pos_double_firsteven([10]) == 20\nassert op_pos_double_firsteven([2, 4, 6]) == 4\nassert op_pos_double_firsteven([-7, 12, -7]) == 24"}
{"id": "op_dropwhileneg_negate_issorted", "entry_point": "op_dropwhileneg_negate_issorted", "primitives": ["dropwhileneg", "negate", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_negate_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_negate_issorted([1, 2, 3, 4]) == False\nassert op_dropwhileneg_negate_issorted([]) == True\nassert op_dropwhileneg_negate_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_negate_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_negate_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_negate_issorted([10]) == True\nassert op_dropwhileneg_negate_issorted([2, 4, 6]) == False\nassert op_dropwhileneg_negate_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_trimends_oremptyzero", "entry_point": "op_sorta_trimends_oremptyzero", "primitives": ["sorta", "trimends", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then if empty, use a single zero.", "solution": "def op_sorta_trimends_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_trimends_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_trimends_oremptyzero([]) == [0]\nassert op_sorta_trimends_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sorta_trimends_oremptyzero([5, 5, 5]) == [5]\nassert op_sorta_trimends_oremptyzero([3, 1, 2]) == [2]\nassert op_sorta_trimends_oremptyzero([10]) == [0]\nassert op_sorta_trimends_oremptyzero([2, 4, 6]) == [4]\nassert op_sorta_trimends_oremptyzero([-7, 12, -7]) == [-7]"}
{"id": "op_absval_sortabs_first3", "entry_point": "op_absval_sortabs_first3", "primitives": ["absval", "sortabs", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then keep only the first three.", "solution": "def op_absval_sortabs_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_absval_sortabs_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_sortabs_first3([]) == []\nassert op_absval_sortabs_first3([-2, -1, 0, 1, 2]) == [0, 1, 1]\nassert op_absval_sortabs_first3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortabs_first3([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortabs_first3([10]) == [10]\nassert op_absval_sortabs_first3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortabs_first3([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_padto3_uniq_haszero", "entry_point": "op_padto3_uniq_haszero", "primitives": ["padto3", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_padto3_uniq_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_padto3_uniq_haszero([1, 2, 3, 4]) == False\nassert op_padto3_uniq_haszero([]) == True\nassert op_padto3_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_uniq_haszero([5, 5, 5]) == False\nassert op_padto3_uniq_haszero([3, 1, 2]) == False\nassert op_padto3_uniq_haszero([10]) == True\nassert op_padto3_uniq_haszero([2, 4, 6]) == False\nassert op_padto3_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_first3_allpos", "entry_point": "op_gt5_first3_allpos", "primitives": ["gt5", "first3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the first three, then return whether all values are positive.", "solution": "def op_gt5_first3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_first3_allpos([1, 2, 3, 4]) == True\nassert op_gt5_first3_allpos([]) == True\nassert op_gt5_first3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_first3_allpos([5, 5, 5]) == True\nassert op_gt5_first3_allpos([3, 1, 2]) == True\nassert op_gt5_first3_allpos([10]) == True\nassert op_gt5_first3_allpos([2, 4, 6]) == True\nassert op_gt5_first3_allpos([-7, 12, -7]) == True"}
{"id": "op_absval_sorta_double", "entry_point": "op_absval_sorta_double", "primitives": ["absval", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then double each.", "solution": "def op_absval_sorta_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_sorta_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_absval_sorta_double([]) == []\nassert op_absval_sorta_double([-2, -1, 0, 1, 2]) == [0, 2, 2, 4, 4]\nassert op_absval_sorta_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_sorta_double([3, 1, 2]) == [2, 4, 6]\nassert op_absval_sorta_double([10]) == [20]\nassert op_absval_sorta_double([2, 4, 6]) == [4, 8, 12]\nassert op_absval_sorta_double([-7, 12, -7]) == [14, 14, 24]"}
{"id": "op_uniq_sorta_beforezero", "entry_point": "op_uniq_sorta_beforezero", "primitives": ["uniq", "sorta", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then keep everything before the first zero.", "solution": "def op_uniq_sorta_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_sorta_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sorta_beforezero([]) == []\nassert op_uniq_sorta_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_sorta_beforezero([5, 5, 5]) == [5]\nassert op_uniq_sorta_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sorta_beforezero([10]) == [10]\nassert op_uniq_sorta_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sorta_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropfirst_sorta_last3", "entry_point": "op_dropfirst_sorta_last3", "primitives": ["dropfirst", "sorta", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then keep only the last three.", "solution": "def op_dropfirst_sorta_last3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    r = r[-3:]\n    return r", "tests": "assert op_dropfirst_sorta_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sorta_last3([]) == []\nassert op_dropfirst_sorta_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_sorta_last3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sorta_last3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sorta_last3([10]) == []\nassert op_dropfirst_sorta_last3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sorta_last3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sorta_first3_dropfirst", "entry_point": "op_sorta_first3_dropfirst", "primitives": ["sorta", "first3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then drop the first element.", "solution": "def op_sorta_first3_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    r = r[1:]\n    return r", "tests": "assert op_sorta_first3_dropfirst([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_first3_dropfirst([]) == []\nassert op_sorta_first3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_sorta_first3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sorta_first3_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sorta_first3_dropfirst([10]) == []\nassert op_sorta_first3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sorta_first3_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_rev_double_min", "entry_point": "op_rev_double_min", "primitives": ["rev", "double", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then return the minimum (0 if empty).", "solution": "def op_rev_double_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_rev_double_min([1, 2, 3, 4]) == 2\nassert op_rev_double_min([]) == 0\nassert op_rev_double_min([-2, -1, 0, 1, 2]) == -4\nassert op_rev_double_min([5, 5, 5]) == 10\nassert op_rev_double_min([3, 1, 2]) == 2\nassert op_rev_double_min([10]) == 20\nassert op_rev_double_min([2, 4, 6]) == 4\nassert op_rev_double_min([-7, 12, -7]) == -14"}
{"id": "op_padto3_takewhilepos_allpos", "entry_point": "op_padto3_takewhilepos_allpos", "primitives": ["padto3", "takewhilepos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then return whether all values are positive.", "solution": "def op_padto3_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_padto3_takewhilepos_allpos([]) == True\nassert op_padto3_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_padto3_takewhilepos_allpos([5, 5, 5]) == True\nassert op_padto3_takewhilepos_allpos([3, 1, 2]) == True\nassert op_padto3_takewhilepos_allpos([10]) == True\nassert op_padto3_takewhilepos_allpos([2, 4, 6]) == True\nassert op_padto3_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_absval_dec_uniq", "entry_point": "op_absval_dec_uniq", "primitives": ["absval", "dec", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then drop duplicates keeping first occurrence.", "solution": "def op_absval_dec_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_dec_uniq([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_absval_dec_uniq([]) == []\nassert op_absval_dec_uniq([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_absval_dec_uniq([5, 5, 5]) == [4]\nassert op_absval_dec_uniq([3, 1, 2]) == [2, 0, 1]\nassert op_absval_dec_uniq([10]) == [9]\nassert op_absval_dec_uniq([2, 4, 6]) == [1, 3, 5]\nassert op_absval_dec_uniq([-7, 12, -7]) == [6, 11]"}
{"id": "op_ages_evens_allpos", "entry_point": "op_ages_evens_allpos", "primitives": ["ages", "evens", "allpos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then return whether all values are positive.", "solution": "def op_ages_evens_allpos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_ages_evens_allpos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_evens_allpos([]) == True\nassert op_ages_evens_allpos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_evens_allpos([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_gt5_takewhilepos_sum", "entry_point": "op_gt5_takewhilepos_sum", "primitives": ["gt5", "takewhilepos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then return their sum.", "solution": "def op_gt5_takewhilepos_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_gt5_takewhilepos_sum([1, 2, 3, 4]) == 0\nassert op_gt5_takewhilepos_sum([]) == 0\nassert op_gt5_takewhilepos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_takewhilepos_sum([5, 5, 5]) == 0\nassert op_gt5_takewhilepos_sum([3, 1, 2]) == 0\nassert op_gt5_takewhilepos_sum([10]) == 10\nassert op_gt5_takewhilepos_sum([2, 4, 6]) == 6\nassert op_gt5_takewhilepos_sum([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_double_dec", "entry_point": "op_dropfirst_double_dec", "primitives": ["dropfirst", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then double each, then subtract one from each.", "solution": "def op_dropfirst_double_dec(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropfirst_double_dec([1, 2, 3, 4]) == [3, 5, 7]\nassert op_dropfirst_double_dec([]) == []\nassert op_dropfirst_double_dec([-2, -1, 0, 1, 2]) == [-3, -1, 1, 3]\nassert op_dropfirst_double_dec([5, 5, 5]) == [9, 9]\nassert op_dropfirst_double_dec([3, 1, 2]) == [1, 3]\nassert op_dropfirst_double_dec([10]) == []\nassert op_dropfirst_double_dec([2, 4, 6]) == [7, 11]\nassert op_dropfirst_double_dec([-7, 12, -7]) == [23, -15]"}
{"id": "op_gt5_neg_max", "entry_point": "op_gt5_neg_max", "primitives": ["gt5", "neg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_gt5_neg_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_gt5_neg_max([1, 2, 3, 4]) == 0\nassert op_gt5_neg_max([]) == 0\nassert op_gt5_neg_max([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_neg_max([5, 5, 5]) == 0\nassert op_gt5_neg_max([3, 1, 2]) == 0\nassert op_gt5_neg_max([10]) == 0\nassert op_gt5_neg_max([2, 4, 6]) == 0\nassert op_gt5_neg_max([-7, 12, -7]) == 0"}
{"id": "op_odds_padto3_add10", "entry_point": "op_odds_padto3_add10", "primitives": ["odds", "padto3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements, then add ten to each.", "solution": "def op_odds_padto3_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_odds_padto3_add10([1, 2, 3, 4]) == [11, 13, 10]\nassert op_odds_padto3_add10([]) == [10, 10, 10]\nassert op_odds_padto3_add10([-2, -1, 0, 1, 2]) == [9, 11, 10]\nassert op_odds_padto3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_odds_padto3_add10([3, 1, 2]) == [13, 11, 10]\nassert op_odds_padto3_add10([10]) == [10, 10, 10]\nassert op_odds_padto3_add10([2, 4, 6]) == [10, 10, 10]\nassert op_odds_padto3_add10([-7, 12, -7]) == [3, 3, 10]"}
{"id": "op_odds_last3_firsteven", "entry_point": "op_odds_last3_firsteven", "primitives": ["odds", "last3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then return the first even value (0 if none).", "solution": "def op_odds_last3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_odds_last3_firsteven([1, 2, 3, 4]) == 0\nassert op_odds_last3_firsteven([]) == 0\nassert op_odds_last3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_last3_firsteven([5, 5, 5]) == 0\nassert op_odds_last3_firsteven([3, 1, 2]) == 0\nassert op_odds_last3_firsteven([10]) == 0\nassert op_odds_last3_firsteven([2, 4, 6]) == 0\nassert op_odds_last3_firsteven([-7, 12, -7]) == 0"}
{"id": "op_square_last3_len", "entry_point": "op_square_last3_len", "primitives": ["square", "last3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then return how many remain.", "solution": "def op_square_last3_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return len(r)", "tests": "assert op_square_last3_len([1, 2, 3, 4]) == 3\nassert op_square_last3_len([]) == 0\nassert op_square_last3_len([-2, -1, 0, 1, 2]) == 3\nassert op_square_last3_len([5, 5, 5]) == 3\nassert op_square_last3_len([3, 1, 2]) == 3\nassert op_square_last3_len([10]) == 1\nassert op_square_last3_len([2, 4, 6]) == 3\nassert op_square_last3_len([-7, 12, -7]) == 3"}
{"id": "op_beforezero_dropfirst_double", "entry_point": "op_beforezero_dropfirst_double", "primitives": ["beforezero", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then double each.", "solution": "def op_beforezero_dropfirst_double(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_beforezero_dropfirst_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_beforezero_dropfirst_double([]) == []\nassert op_beforezero_dropfirst_double([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_dropfirst_double([5, 5, 5]) == [10, 10]\nassert op_beforezero_dropfirst_double([3, 1, 2]) == [2, 4]\nassert op_beforezero_dropfirst_double([10]) == []\nassert op_beforezero_dropfirst_double([2, 4, 6]) == [8, 12]\nassert op_beforezero_dropfirst_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_uniq_add10_trimends", "entry_point": "op_uniq_add10_trimends", "primitives": ["uniq", "add10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then drop the first and last elements.", "solution": "def op_uniq_add10_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_add10_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_uniq_add10_trimends([]) == []\nassert op_uniq_add10_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_uniq_add10_trimends([5, 5, 5]) == []\nassert op_uniq_add10_trimends([3, 1, 2]) == [11]\nassert op_uniq_add10_trimends([10]) == []\nassert op_uniq_add10_trimends([2, 4, 6]) == [14]\nassert op_uniq_add10_trimends([-7, 12, -7]) == []"}
{"id": "op_dropfirst_dropwhileneg_padto3", "entry_point": "op_dropfirst_dropwhileneg_padto3", "primitives": ["dropfirst", "dropwhileneg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_dropwhileneg_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_dropwhileneg_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropwhileneg_padto3([]) == [0, 0, 0]\nassert op_dropfirst_dropwhileneg_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_dropwhileneg_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_dropwhileneg_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_dropwhileneg_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_dropwhileneg_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_dropwhileneg_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_square_beforezero_odds", "entry_point": "op_square_beforezero_odds", "primitives": ["square", "beforezero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_square_beforezero_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_beforezero_odds([1, 2, 3, 4]) == [1, 9]\nassert op_square_beforezero_odds([]) == []\nassert op_square_beforezero_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_square_beforezero_odds([5, 5, 5]) == [25, 25, 25]\nassert op_square_beforezero_odds([3, 1, 2]) == [9, 1]\nassert op_square_beforezero_odds([10]) == []\nassert op_square_beforezero_odds([2, 4, 6]) == []\nassert op_square_beforezero_odds([-7, 12, -7]) == [49, 49]"}
{"id": "op_dropzeros_gt5_takewhilepos", "entry_point": "op_dropzeros_gt5_takewhilepos", "primitives": ["dropzeros", "gt5", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five, then take values while they are positive.", "solution": "def op_dropzeros_gt5_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_gt5_takewhilepos([1, 2, 3, 4]) == []\nassert op_dropzeros_gt5_takewhilepos([]) == []\nassert op_dropzeros_gt5_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_gt5_takewhilepos([5, 5, 5]) == []\nassert op_dropzeros_gt5_takewhilepos([3, 1, 2]) == []\nassert op_dropzeros_gt5_takewhilepos([10]) == [10]\nassert op_dropzeros_gt5_takewhilepos([2, 4, 6]) == [6]\nassert op_dropzeros_gt5_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_last3_sortabs_trimends", "entry_point": "op_last3_sortabs_trimends", "primitives": ["last3", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then drop the first and last elements.", "solution": "def op_last3_sortabs_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_sortabs_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_sortabs_trimends([]) == []\nassert op_last3_sortabs_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_sortabs_trimends([5, 5, 5]) == [5]\nassert op_last3_sortabs_trimends([3, 1, 2]) == [2]\nassert op_last3_sortabs_trimends([10]) == []\nassert op_last3_sortabs_trimends([2, 4, 6]) == [4]\nassert op_last3_sortabs_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_dropwhileneg_beforezero_sorta", "entry_point": "op_dropwhileneg_beforezero_sorta", "primitives": ["dropwhileneg", "beforezero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero, then sort ascending.", "solution": "def op_dropwhileneg_beforezero_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_beforezero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_beforezero_sorta([]) == []\nassert op_dropwhileneg_beforezero_sorta([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_beforezero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_beforezero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_beforezero_sorta([10]) == [10]\nassert op_dropwhileneg_beforezero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_beforezero_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_inc_clamp10_gt5", "entry_point": "op_inc_clamp10_gt5", "primitives": ["inc", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then keep values greater than five.", "solution": "def op_inc_clamp10_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_inc_clamp10_gt5([]) == []\nassert op_inc_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_clamp10_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_inc_clamp10_gt5([3, 1, 2]) == []\nassert op_inc_clamp10_gt5([10]) == [10]\nassert op_inc_clamp10_gt5([2, 4, 6]) == [7]\nassert op_inc_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_clamp10_sortabs_square", "entry_point": "op_clamp10_sortabs_square", "primitives": ["clamp10", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then square each.", "solution": "def op_clamp10_sortabs_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_sortabs_square([]) == []\nassert op_clamp10_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_clamp10_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_clamp10_sortabs_square([10]) == [100]\nassert op_clamp10_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_sortabs_square([-7, 12, -7]) == [49, 49, 100]"}
{"id": "op_trimends_evens_sum", "entry_point": "op_trimends_evens_sum", "primitives": ["trimends", "evens", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then return their sum.", "solution": "def op_trimends_evens_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_trimends_evens_sum([1, 2, 3, 4]) == 2\nassert op_trimends_evens_sum([]) == 0\nassert op_trimends_evens_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_evens_sum([5, 5, 5]) == 0\nassert op_trimends_evens_sum([3, 1, 2]) == 0\nassert op_trimends_evens_sum([10]) == 0\nassert op_trimends_evens_sum([2, 4, 6]) == 4\nassert op_trimends_evens_sum([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_uniq_padto3", "entry_point": "op_dropzeros_uniq_padto3", "primitives": ["dropzeros", "uniq", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_uniq_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_uniq_padto3([]) == [0, 0, 0]\nassert op_dropzeros_uniq_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_dropzeros_uniq_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_uniq_padto3([10]) == [10, 0, 0]\nassert op_dropzeros_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_uniq_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_absval_padto3_odds", "entry_point": "op_absval_padto3_odds", "primitives": ["absval", "padto3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_absval_padto3_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_padto3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_padto3_odds([]) == []\nassert op_absval_padto3_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_padto3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_odds([3, 1, 2]) == [3, 1]\nassert op_absval_padto3_odds([10]) == []\nassert op_absval_padto3_odds([2, 4, 6]) == []\nassert op_absval_padto3_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_rev_add10_gt5", "entry_point": "op_rev_add10_gt5", "primitives": ["rev", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then keep values greater than five.", "solution": "def op_rev_add10_gt5(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_rev_add10_gt5([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_rev_add10_gt5([]) == []\nassert op_rev_add10_gt5([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_rev_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_rev_add10_gt5([3, 1, 2]) == [12, 11, 13]\nassert op_rev_add10_gt5([10]) == [20]\nassert op_rev_add10_gt5([2, 4, 6]) == [16, 14, 12]\nassert op_rev_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_div3_beforezero_sortabs", "entry_point": "op_div3_beforezero_sortabs", "primitives": ["div3", "beforezero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then sort by absolute value.", "solution": "def op_div3_beforezero_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_beforezero_sortabs([1, 2, 3, 4]) == [3]\nassert op_div3_beforezero_sortabs([]) == []\nassert op_div3_beforezero_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_sortabs([5, 5, 5]) == []\nassert op_div3_beforezero_sortabs([3, 1, 2]) == [3]\nassert op_div3_beforezero_sortabs([10]) == []\nassert op_div3_beforezero_sortabs([2, 4, 6]) == [6]\nassert op_div3_beforezero_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_last3_dropfirst_neg", "entry_point": "op_last3_dropfirst_neg", "primitives": ["last3", "dropfirst", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then keep the negative numbers.", "solution": "def op_last3_dropfirst_neg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_last3_dropfirst_neg([1, 2, 3, 4]) == []\nassert op_last3_dropfirst_neg([]) == []\nassert op_last3_dropfirst_neg([-2, -1, 0, 1, 2]) == []\nassert op_last3_dropfirst_neg([5, 5, 5]) == []\nassert op_last3_dropfirst_neg([3, 1, 2]) == []\nassert op_last3_dropfirst_neg([10]) == []\nassert op_last3_dropfirst_neg([2, 4, 6]) == []\nassert op_last3_dropfirst_neg([-7, 12, -7]) == [-7]"}
{"id": "op_first3_inc_padto3", "entry_point": "op_first3_inc_padto3", "primitives": ["first3", "inc", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then pad with zeros to at least three elements.", "solution": "def op_first3_inc_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_inc_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_first3_inc_padto3([]) == [0, 0, 0]\nassert op_first3_inc_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_first3_inc_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_first3_inc_padto3([3, 1, 2]) == [4, 2, 3]\nassert op_first3_inc_padto3([10]) == [11, 0, 0]\nassert op_first3_inc_padto3([2, 4, 6]) == [3, 5, 7]\nassert op_first3_inc_padto3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_takewhilepos_sorta_odds", "entry_point": "op_takewhilepos_sorta_odds", "primitives": ["takewhilepos", "sorta", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending, then keep the odd numbers.", "solution": "def op_takewhilepos_sorta_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_sorta_odds([1, 2, 3, 4]) == [1, 3]\nassert op_takewhilepos_sorta_odds([]) == []\nassert op_takewhilepos_sorta_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sorta_odds([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sorta_odds([3, 1, 2]) == [1, 3]\nassert op_takewhilepos_sorta_odds([10]) == []\nassert op_takewhilepos_sorta_odds([2, 4, 6]) == []\nassert op_takewhilepos_sorta_odds([-7, 12, -7]) == []"}
{"id": "op_first3_dropzeros_last3", "entry_point": "op_first3_dropzeros_last3", "primitives": ["first3", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then keep only the last three.", "solution": "def op_first3_dropzeros_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_dropzeros_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropzeros_last3([]) == []\nassert op_first3_dropzeros_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropzeros_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropzeros_last3([10]) == [10]\nassert op_first3_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropzeros_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_evens_trimends_double", "entry_point": "op_evens_trimends_double", "primitives": ["evens", "trimends", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then double each.", "solution": "def op_evens_trimends_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_trimends_double([1, 2, 3, 4]) == []\nassert op_evens_trimends_double([]) == []\nassert op_evens_trimends_double([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_trimends_double([5, 5, 5]) == []\nassert op_evens_trimends_double([3, 1, 2]) == []\nassert op_evens_trimends_double([10]) == []\nassert op_evens_trimends_double([2, 4, 6]) == [8]\nassert op_evens_trimends_double([-7, 12, -7]) == []"}
{"id": "op_dropzeros_dropfirst_last3", "entry_point": "op_dropzeros_dropfirst_last3", "primitives": ["dropzeros", "dropfirst", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then keep only the last three.", "solution": "def op_dropzeros_dropfirst_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_dropfirst_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropfirst_last3([]) == []\nassert op_dropzeros_dropfirst_last3([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropzeros_dropfirst_last3([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropfirst_last3([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst_last3([10]) == []\nassert op_dropzeros_dropfirst_last3([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropfirst_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_negate_evens_add10", "entry_point": "op_negate_evens_add10", "primitives": ["negate", "evens", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers, then add ten to each.", "solution": "def op_negate_evens_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_evens_add10([1, 2, 3, 4]) == [8, 6]\nassert op_negate_evens_add10([]) == []\nassert op_negate_evens_add10([-2, -1, 0, 1, 2]) == [12, 10, 8]\nassert op_negate_evens_add10([5, 5, 5]) == []\nassert op_negate_evens_add10([3, 1, 2]) == [8]\nassert op_negate_evens_add10([10]) == [0]\nassert op_negate_evens_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_evens_add10([-7, 12, -7]) == [-2]"}
{"id": "op_absval_takewhilepos_evens", "entry_point": "op_absval_takewhilepos_evens", "primitives": ["absval", "takewhilepos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then keep the even numbers.", "solution": "def op_absval_takewhilepos_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_takewhilepos_evens([1, 2, 3, 4]) == [2, 4]\nassert op_absval_takewhilepos_evens([]) == []\nassert op_absval_takewhilepos_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_absval_takewhilepos_evens([5, 5, 5]) == []\nassert op_absval_takewhilepos_evens([3, 1, 2]) == [2]\nassert op_absval_takewhilepos_evens([10]) == [10]\nassert op_absval_takewhilepos_evens([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_evens([-7, 12, -7]) == [12]"}
{"id": "op_ages_dropwhileneg_max", "entry_point": "op_ages_dropwhileneg_max", "primitives": ["ages", "dropwhileneg", "max"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_ages_dropwhileneg_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_ages_dropwhileneg_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_dropwhileneg_max([]) == 0\nassert op_ages_dropwhileneg_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_dropwhileneg_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_evens_div3_allpos", "entry_point": "op_evens_div3_allpos", "primitives": ["evens", "div3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then return whether all values are positive.", "solution": "def op_evens_div3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_div3_allpos([1, 2, 3, 4]) == True\nassert op_evens_div3_allpos([]) == True\nassert op_evens_div3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_div3_allpos([5, 5, 5]) == True\nassert op_evens_div3_allpos([3, 1, 2]) == True\nassert op_evens_div3_allpos([10]) == True\nassert op_evens_div3_allpos([2, 4, 6]) == True\nassert op_evens_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_neg_beforezero_sum", "entry_point": "op_neg_beforezero_sum", "primitives": ["neg", "beforezero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then return their sum.", "solution": "def op_neg_beforezero_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(r)", "tests": "assert op_neg_beforezero_sum([1, 2, 3, 4]) == 0\nassert op_neg_beforezero_sum([]) == 0\nassert op_neg_beforezero_sum([-2, -1, 0, 1, 2]) == -3\nassert op_neg_beforezero_sum([5, 5, 5]) == 0\nassert op_neg_beforezero_sum([3, 1, 2]) == 0\nassert op_neg_beforezero_sum([10]) == 0\nassert op_neg_beforezero_sum([2, 4, 6]) == 0\nassert op_neg_beforezero_sum([-7, 12, -7]) == -14"}
{"id": "op_beforezero_dec_counteven", "entry_point": "op_beforezero_dec_counteven", "primitives": ["beforezero", "dec", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then return how many values are even.", "solution": "def op_beforezero_dec_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_dec_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_dec_counteven([]) == 0\nassert op_beforezero_dec_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_dec_counteven([5, 5, 5]) == 3\nassert op_beforezero_dec_counteven([3, 1, 2]) == 2\nassert op_beforezero_dec_counteven([10]) == 0\nassert op_beforezero_dec_counteven([2, 4, 6]) == 0\nassert op_beforezero_dec_counteven([-7, 12, -7]) == 2"}
{"id": "op_neg_inc_counteven", "entry_point": "op_neg_inc_counteven", "primitives": ["neg", "inc", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then return how many values are even.", "solution": "def op_neg_inc_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_inc_counteven([1, 2, 3, 4]) == 0\nassert op_neg_inc_counteven([]) == 0\nassert op_neg_inc_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_inc_counteven([5, 5, 5]) == 0\nassert op_neg_inc_counteven([3, 1, 2]) == 0\nassert op_neg_inc_counteven([10]) == 0\nassert op_neg_inc_counteven([2, 4, 6]) == 0\nassert op_neg_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_sortabs_sorta_firsteven", "entry_point": "op_sortabs_sorta_firsteven", "primitives": ["sortabs", "sorta", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then return the first even value (0 if none).", "solution": "def op_sortabs_sorta_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_sorta_firsteven([1, 2, 3, 4]) == 2\nassert op_sortabs_sorta_firsteven([]) == 0\nassert op_sortabs_sorta_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_sorta_firsteven([5, 5, 5]) == 0\nassert op_sortabs_sorta_firsteven([3, 1, 2]) == 2\nassert op_sortabs_sorta_firsteven([10]) == 10\nassert op_sortabs_sorta_firsteven([2, 4, 6]) == 2\nassert op_sortabs_sorta_firsteven([-7, 12, -7]) == 12"}
{"id": "op_last3_uniq_rev", "entry_point": "op_last3_uniq_rev", "primitives": ["last3", "uniq", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_last3_uniq_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_uniq_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_uniq_rev([]) == []\nassert op_last3_uniq_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_uniq_rev([5, 5, 5]) == [5]\nassert op_last3_uniq_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_uniq_rev([10]) == [10]\nassert op_last3_uniq_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_uniq_rev([-7, 12, -7]) == [12, -7]"}
{"id": "op_add10_neg_dec", "entry_point": "op_add10_neg_dec", "primitives": ["add10", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then subtract one from each.", "solution": "def op_add10_neg_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_neg_dec([1, 2, 3, 4]) == []\nassert op_add10_neg_dec([]) == []\nassert op_add10_neg_dec([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_dec([5, 5, 5]) == []\nassert op_add10_neg_dec([3, 1, 2]) == []\nassert op_add10_neg_dec([10]) == []\nassert op_add10_neg_dec([2, 4, 6]) == []\nassert op_add10_neg_dec([-7, 12, -7]) == []"}
{"id": "op_first3_dropwhileneg_firsteven", "entry_point": "op_first3_dropwhileneg_firsteven", "primitives": ["first3", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_first3_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_dropwhileneg_firsteven([1, 2, 3, 4]) == 2\nassert op_first3_dropwhileneg_firsteven([]) == 0\nassert op_first3_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_first3_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_first3_dropwhileneg_firsteven([3, 1, 2]) == 2\nassert op_first3_dropwhileneg_firsteven([10]) == 10\nassert op_first3_dropwhileneg_firsteven([2, 4, 6]) == 2\nassert op_first3_dropwhileneg_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_trimends_neg", "entry_point": "op_dropwhileneg_trimends_neg", "primitives": ["dropwhileneg", "trimends", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_dropwhileneg_trimends_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_trimends_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_trimends_neg([]) == []\nassert op_dropwhileneg_trimends_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_trimends_neg([5, 5, 5]) == []\nassert op_dropwhileneg_trimends_neg([3, 1, 2]) == []\nassert op_dropwhileneg_trimends_neg([10]) == []\nassert op_dropwhileneg_trimends_neg([2, 4, 6]) == []\nassert op_dropwhileneg_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_sortlen_uniqs_anyempty", "entry_point": "op_sortlen_uniqs_anyempty", "primitives": ["sortlen", "uniqs", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_sortlen_uniqs_anyempty(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_sortlen_uniqs_anyempty(['Hello', 'world']) == False\nassert op_sortlen_uniqs_anyempty([]) == False\nassert op_sortlen_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_sortlen_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_sortlen_uniqs_anyempty(['x']) == False\nassert op_sortlen_uniqs_anyempty(['abc', 'de', '']) == True"}
{"id": "op_dropfirst_clamp10_neg", "entry_point": "op_dropfirst_clamp10_neg", "primitives": ["dropfirst", "clamp10", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then keep the negative numbers.", "solution": "def op_dropfirst_clamp10_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_clamp10_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_clamp10_neg([]) == []\nassert op_dropfirst_clamp10_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_clamp10_neg([5, 5, 5]) == []\nassert op_dropfirst_clamp10_neg([3, 1, 2]) == []\nassert op_dropfirst_clamp10_neg([10]) == []\nassert op_dropfirst_clamp10_neg([2, 4, 6]) == []\nassert op_dropfirst_clamp10_neg([-7, 12, -7]) == [-7]"}
{"id": "op_first3_dropwhileneg_oremptyzero", "entry_point": "op_first3_dropwhileneg_oremptyzero", "primitives": ["first3", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_first3_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropwhileneg_oremptyzero([]) == [0]\nassert op_first3_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropwhileneg_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropwhileneg_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropwhileneg_oremptyzero([10]) == [10]\nassert op_first3_dropwhileneg_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropwhileneg_oremptyzero([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_dropzeros_counteven", "entry_point": "op_absval_dropzeros_counteven", "primitives": ["absval", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then return how many values are even.", "solution": "def op_absval_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_absval_dropzeros_counteven([]) == 0\nassert op_absval_dropzeros_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_dropzeros_counteven([5, 5, 5]) == 0\nassert op_absval_dropzeros_counteven([3, 1, 2]) == 1\nassert op_absval_dropzeros_counteven([10]) == 1\nassert op_absval_dropzeros_counteven([2, 4, 6]) == 3\nassert op_absval_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_sortabs_oremptyzero", "entry_point": "op_first3_sortabs_oremptyzero", "primitives": ["first3", "sortabs", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_first3_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs_oremptyzero([]) == [0]\nassert op_first3_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sortabs_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs_oremptyzero([10]) == [10]\nassert op_first3_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_square_dropfirst_anyeven", "entry_point": "op_square_dropfirst_anyeven", "primitives": ["square", "dropfirst", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then return whether any value is even.", "solution": "def op_square_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_square_dropfirst_anyeven([]) == False\nassert op_square_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_dropfirst_anyeven([5, 5, 5]) == False\nassert op_square_dropfirst_anyeven([3, 1, 2]) == True\nassert op_square_dropfirst_anyeven([10]) == False\nassert op_square_dropfirst_anyeven([2, 4, 6]) == True\nassert op_square_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropfirst_pos_takewhilepos", "entry_point": "op_dropfirst_pos_takewhilepos", "primitives": ["dropfirst", "pos", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then take values while they are positive.", "solution": "def op_dropfirst_pos_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_pos_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_pos_takewhilepos([]) == []\nassert op_dropfirst_pos_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropfirst_pos_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_pos_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_pos_takewhilepos([10]) == []\nassert op_dropfirst_pos_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_pos_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_first3_trimends_dropfirst", "entry_point": "op_first3_trimends_dropfirst", "primitives": ["first3", "trimends", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then drop the first element.", "solution": "def op_first3_trimends_dropfirst(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_first3_trimends_dropfirst([1, 2, 3, 4]) == []\nassert op_first3_trimends_dropfirst([]) == []\nassert op_first3_trimends_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_first3_trimends_dropfirst([5, 5, 5]) == []\nassert op_first3_trimends_dropfirst([3, 1, 2]) == []\nassert op_first3_trimends_dropfirst([10]) == []\nassert op_first3_trimends_dropfirst([2, 4, 6]) == []\nassert op_first3_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sorta_dropzeros_inc", "entry_point": "op_sorta_dropzeros_inc", "primitives": ["sorta", "dropzeros", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then add one to each.", "solution": "def op_sorta_dropzeros_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_dropzeros_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_dropzeros_inc([]) == []\nassert op_sorta_dropzeros_inc([-2, -1, 0, 1, 2]) == [-1, 0, 2, 3]\nassert op_sorta_dropzeros_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_dropzeros_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_dropzeros_inc([10]) == [11]\nassert op_sorta_dropzeros_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_dropzeros_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_absval_dropzeros_last3", "entry_point": "op_absval_dropzeros_last3", "primitives": ["absval", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then keep only the last three.", "solution": "def op_absval_dropzeros_last3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_absval_dropzeros_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_dropzeros_last3([]) == []\nassert op_absval_dropzeros_last3([-2, -1, 0, 1, 2]) == [1, 1, 2]\nassert op_absval_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropzeros_last3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_dropzeros_last3([10]) == [10]\nassert op_absval_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_dropzeros_last3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_square_add10_len", "entry_point": "op_square_add10_len", "primitives": ["square", "add10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each, then return how many remain.", "solution": "def op_square_add10_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_square_add10_len([1, 2, 3, 4]) == 4\nassert op_square_add10_len([]) == 0\nassert op_square_add10_len([-2, -1, 0, 1, 2]) == 5\nassert op_square_add10_len([5, 5, 5]) == 3\nassert op_square_add10_len([3, 1, 2]) == 3\nassert op_square_add10_len([10]) == 1\nassert op_square_add10_len([2, 4, 6]) == 3\nassert op_square_add10_len([-7, 12, -7]) == 3"}
{"id": "op_gt5_absval_prod", "entry_point": "op_gt5_absval_prod", "primitives": ["gt5", "absval", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take the absolute value of each, then return their product.", "solution": "def op_gt5_absval_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_gt5_absval_prod([1, 2, 3, 4]) == 1\nassert op_gt5_absval_prod([]) == 1\nassert op_gt5_absval_prod([-2, -1, 0, 1, 2]) == 1\nassert op_gt5_absval_prod([5, 5, 5]) == 1\nassert op_gt5_absval_prod([3, 1, 2]) == 1\nassert op_gt5_absval_prod([10]) == 10\nassert op_gt5_absval_prod([2, 4, 6]) == 6\nassert op_gt5_absval_prod([-7, 12, -7]) == 12"}
{"id": "op_ages_odds_len", "entry_point": "op_ages_odds_len", "primitives": ["ages", "odds", "len"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then return how many remain.", "solution": "def op_ages_odds_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_ages_odds_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_odds_len([]) == 0\nassert op_ages_odds_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 2\nassert op_ages_odds_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_evens_double_add10", "entry_point": "op_evens_double_add10", "primitives": ["evens", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then add ten to each.", "solution": "def op_evens_double_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_evens_double_add10([1, 2, 3, 4]) == [14, 18]\nassert op_evens_double_add10([]) == []\nassert op_evens_double_add10([-2, -1, 0, 1, 2]) == [6, 10, 14]\nassert op_evens_double_add10([5, 5, 5]) == []\nassert op_evens_double_add10([3, 1, 2]) == [14]\nassert op_evens_double_add10([10]) == [30]\nassert op_evens_double_add10([2, 4, 6]) == [14, 18, 22]\nassert op_evens_double_add10([-7, 12, -7]) == [34]"}
{"id": "op_dropfirst_sortabs_anyeven", "entry_point": "op_dropfirst_sortabs_anyeven", "primitives": ["dropfirst", "sortabs", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then return whether any value is even.", "solution": "def op_dropfirst_sortabs_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_sortabs_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_sortabs_anyeven([]) == False\nassert op_dropfirst_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_sortabs_anyeven([5, 5, 5]) == False\nassert op_dropfirst_sortabs_anyeven([3, 1, 2]) == True\nassert op_dropfirst_sortabs_anyeven([10]) == False\nassert op_dropfirst_sortabs_anyeven([2, 4, 6]) == True\nassert op_dropfirst_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_double_sorta_issorted", "entry_point": "op_double_sorta_issorted", "primitives": ["double", "sorta", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_double_sorta_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_double_sorta_issorted([1, 2, 3, 4]) == True\nassert op_double_sorta_issorted([]) == True\nassert op_double_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_sorta_issorted([5, 5, 5]) == True\nassert op_double_sorta_issorted([3, 1, 2]) == True\nassert op_double_sorta_issorted([10]) == True\nassert op_double_sorta_issorted([2, 4, 6]) == True\nassert op_double_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_neg_sorta", "entry_point": "op_gt5_neg_sorta", "primitives": ["gt5", "neg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then sort ascending.", "solution": "def op_gt5_neg_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_neg_sorta([1, 2, 3, 4]) == []\nassert op_gt5_neg_sorta([]) == []\nassert op_gt5_neg_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg_sorta([5, 5, 5]) == []\nassert op_gt5_neg_sorta([3, 1, 2]) == []\nassert op_gt5_neg_sorta([10]) == []\nassert op_gt5_neg_sorta([2, 4, 6]) == []\nassert op_gt5_neg_sorta([-7, 12, -7]) == []"}
{"id": "op_sorta_padto3_odds", "entry_point": "op_sorta_padto3_odds", "primitives": ["sorta", "padto3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_sorta_padto3_odds(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sorta_padto3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sorta_padto3_odds([]) == []\nassert op_sorta_padto3_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sorta_padto3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_padto3_odds([3, 1, 2]) == [1, 3]\nassert op_sorta_padto3_odds([10]) == []\nassert op_sorta_padto3_odds([2, 4, 6]) == []\nassert op_sorta_padto3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_double_padto3_anyeven", "entry_point": "op_double_padto3_anyeven", "primitives": ["double", "padto3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_double_padto3_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_double_padto3_anyeven([]) == True\nassert op_double_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_double_padto3_anyeven([5, 5, 5]) == True\nassert op_double_padto3_anyeven([3, 1, 2]) == True\nassert op_double_padto3_anyeven([10]) == True\nassert op_double_padto3_anyeven([2, 4, 6]) == True\nassert op_double_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_padto3_takewhilepos", "entry_point": "op_sortd_padto3_takewhilepos", "primitives": ["sortd", "padto3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_sortd_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_padto3_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_padto3_takewhilepos([]) == []\nassert op_sortd_padto3_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_padto3_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_padto3_takewhilepos([10]) == [10]\nassert op_sortd_padto3_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_padto3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dec_dropzeros_len", "entry_point": "op_dec_dropzeros_len", "primitives": ["dec", "dropzeros", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then return how many remain.", "solution": "def op_dec_dropzeros_len(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_dec_dropzeros_len([1, 2, 3, 4]) == 3\nassert op_dec_dropzeros_len([]) == 0\nassert op_dec_dropzeros_len([-2, -1, 0, 1, 2]) == 4\nassert op_dec_dropzeros_len([5, 5, 5]) == 3\nassert op_dec_dropzeros_len([3, 1, 2]) == 2\nassert op_dec_dropzeros_len([10]) == 1\nassert op_dec_dropzeros_len([2, 4, 6]) == 3\nassert op_dec_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_add10_absval_oremptyzero", "entry_point": "op_add10_absval_oremptyzero", "primitives": ["add10", "absval", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_add10_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_absval_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_absval_oremptyzero([]) == [0]\nassert op_add10_absval_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_absval_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_absval_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_absval_oremptyzero([10]) == [20]\nassert op_add10_absval_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_absval_oremptyzero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_dropfirst_dropwhileneg_last3", "entry_point": "op_dropfirst_dropwhileneg_last3", "primitives": ["dropfirst", "dropwhileneg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then keep only the last three.", "solution": "def op_dropfirst_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropwhileneg_last3([]) == []\nassert op_dropfirst_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_dropwhileneg_last3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dropwhileneg_last3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dropwhileneg_last3([10]) == []\nassert op_dropfirst_dropwhileneg_last3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dropwhileneg_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_negate_div3_prod", "entry_point": "op_negate_div3_prod", "primitives": ["negate", "div3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then return their product.", "solution": "def op_negate_div3_prod(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_negate_div3_prod([1, 2, 3, 4]) == -3\nassert op_negate_div3_prod([]) == 1\nassert op_negate_div3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_negate_div3_prod([5, 5, 5]) == 1\nassert op_negate_div3_prod([3, 1, 2]) == -3\nassert op_negate_div3_prod([10]) == 1\nassert op_negate_div3_prod([2, 4, 6]) == -6\nassert op_negate_div3_prod([-7, 12, -7]) == -12"}
{"id": "op_sortlen_sortalpha_uniqs", "entry_point": "op_sortlen_sortalpha_uniqs", "primitives": ["sortlen", "sortalpha", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then sort alphabetically, then drop duplicate strings keeping the first.", "solution": "def op_sortlen_sortalpha_uniqs(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortlen_sortalpha_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortlen_sortalpha_uniqs([]) == []\nassert op_sortlen_sortalpha_uniqs(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'BC', 'bc']\nassert op_sortlen_sortalpha_uniqs(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_sortlen_sortalpha_uniqs(['x']) == ['x']\nassert op_sortlen_sortalpha_uniqs(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_uniq_last3_odds", "entry_point": "op_uniq_last3_odds", "primitives": ["uniq", "last3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three, then keep the odd numbers.", "solution": "def op_uniq_last3_odds(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_uniq_last3_odds([1, 2, 3, 4]) == [3]\nassert op_uniq_last3_odds([]) == []\nassert op_uniq_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_uniq_last3_odds([5, 5, 5]) == [5]\nassert op_uniq_last3_odds([3, 1, 2]) == [3, 1]\nassert op_uniq_last3_odds([10]) == []\nassert op_uniq_last3_odds([2, 4, 6]) == []\nassert op_uniq_last3_odds([-7, 12, -7]) == [-7]"}
{"id": "op_evens_gt5_odds", "entry_point": "op_evens_gt5_odds", "primitives": ["evens", "gt5", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then keep the odd numbers.", "solution": "def op_evens_gt5_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_gt5_odds([1, 2, 3, 4]) == []\nassert op_evens_gt5_odds([]) == []\nassert op_evens_gt5_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5_odds([5, 5, 5]) == []\nassert op_evens_gt5_odds([3, 1, 2]) == []\nassert op_evens_gt5_odds([10]) == []\nassert op_evens_gt5_odds([2, 4, 6]) == []\nassert op_evens_gt5_odds([-7, 12, -7]) == []"}
{"id": "op_evens_dropzeros_negate", "entry_point": "op_evens_dropzeros_negate", "primitives": ["evens", "dropzeros", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then negate each.", "solution": "def op_evens_dropzeros_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_dropzeros_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_evens_dropzeros_negate([]) == []\nassert op_evens_dropzeros_negate([-2, -1, 0, 1, 2]) == [2, -2]\nassert op_evens_dropzeros_negate([5, 5, 5]) == []\nassert op_evens_dropzeros_negate([3, 1, 2]) == [-2]\nassert op_evens_dropzeros_negate([10]) == [-10]\nassert op_evens_dropzeros_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_evens_dropzeros_negate([-7, 12, -7]) == [-12]"}
{"id": "op_double_dropzeros_sorta", "entry_point": "op_double_dropzeros_sorta", "primitives": ["double", "dropzeros", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then sort ascending.", "solution": "def op_double_dropzeros_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_double_dropzeros_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropzeros_sorta([]) == []\nassert op_double_dropzeros_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_dropzeros_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropzeros_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_double_dropzeros_sorta([10]) == [20]\nassert op_double_dropzeros_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropzeros_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_sortabs_double_max", "entry_point": "op_sortabs_double_max", "primitives": ["sortabs", "double", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then return the maximum (0 if empty).", "solution": "def op_sortabs_double_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_sortabs_double_max([1, 2, 3, 4]) == 8\nassert op_sortabs_double_max([]) == 0\nassert op_sortabs_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_sortabs_double_max([5, 5, 5]) == 10\nassert op_sortabs_double_max([3, 1, 2]) == 6\nassert op_sortabs_double_max([10]) == 20\nassert op_sortabs_double_max([2, 4, 6]) == 12\nassert op_sortabs_double_max([-7, 12, -7]) == 24"}
{"id": "op_uniq_dec_sortabs", "entry_point": "op_uniq_dec_sortabs", "primitives": ["uniq", "dec", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then sort by absolute value.", "solution": "def op_uniq_dec_sortabs(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_uniq_dec_sortabs([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_uniq_dec_sortabs([]) == []\nassert op_uniq_dec_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, -3]\nassert op_uniq_dec_sortabs([5, 5, 5]) == [4]\nassert op_uniq_dec_sortabs([3, 1, 2]) == [0, 1, 2]\nassert op_uniq_dec_sortabs([10]) == [9]\nassert op_uniq_dec_sortabs([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_dec_sortabs([-7, 12, -7]) == [-8, 11]"}
{"id": "op_absval_clamp10_alldistinct", "entry_point": "op_absval_clamp10_alldistinct", "primitives": ["absval", "clamp10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_absval_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_absval_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_clamp10_alldistinct([]) == True\nassert op_absval_clamp10_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_absval_clamp10_alldistinct([5, 5, 5]) == False\nassert op_absval_clamp10_alldistinct([3, 1, 2]) == True\nassert op_absval_clamp10_alldistinct([10]) == True\nassert op_absval_clamp10_alldistinct([2, 4, 6]) == True\nassert op_absval_clamp10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_pos_dropfirst_issorted", "entry_point": "op_pos_dropfirst_issorted", "primitives": ["pos", "dropfirst", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first element, then return whether the list is sorted ascending.", "solution": "def op_pos_dropfirst_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r == sorted(r)", "tests": "assert op_pos_dropfirst_issorted([1, 2, 3, 4]) == True\nassert op_pos_dropfirst_issorted([]) == True\nassert op_pos_dropfirst_issorted([-2, -1, 0, 1, 2]) == True\nassert op_pos_dropfirst_issorted([5, 5, 5]) == True\nassert op_pos_dropfirst_issorted([3, 1, 2]) == True\nassert op_pos_dropfirst_issorted([10]) == True\nassert op_pos_dropfirst_issorted([2, 4, 6]) == True\nassert op_pos_dropfirst_issorted([-7, 12, -7]) == True"}
{"id": "op_double_dropwhileneg_sortabs", "entry_point": "op_double_dropwhileneg_sortabs", "primitives": ["double", "dropwhileneg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then sort by absolute value.", "solution": "def op_double_dropwhileneg_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_dropwhileneg_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropwhileneg_sortabs([]) == []\nassert op_double_dropwhileneg_sortabs([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_dropwhileneg_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropwhileneg_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_double_dropwhileneg_sortabs([10]) == [20]\nassert op_double_dropwhileneg_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropwhileneg_sortabs([-7, 12, -7]) == [-14, 24]"}
{"id": "op_dropfirst_dropwhileneg_negate", "entry_point": "op_dropfirst_dropwhileneg_negate", "primitives": ["dropfirst", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then negate each.", "solution": "def op_dropfirst_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropfirst_dropwhileneg_negate([]) == []\nassert op_dropfirst_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropfirst_dropwhileneg_negate([5, 5, 5]) == [-5, -5]\nassert op_dropfirst_dropwhileneg_negate([3, 1, 2]) == [-1, -2]\nassert op_dropfirst_dropwhileneg_negate([10]) == []\nassert op_dropfirst_dropwhileneg_negate([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_trimends_first3_last3", "entry_point": "op_trimends_first3_last3", "primitives": ["trimends", "first3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then keep only the last three.", "solution": "def op_trimends_first3_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_first3_last3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_first3_last3([]) == []\nassert op_trimends_first3_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_first3_last3([5, 5, 5]) == [5]\nassert op_trimends_first3_last3([3, 1, 2]) == [1]\nassert op_trimends_first3_last3([10]) == []\nassert op_trimends_first3_last3([2, 4, 6]) == [4]\nassert op_trimends_first3_last3([-7, 12, -7]) == [12]"}
{"id": "op_sorta_trimends_inc", "entry_point": "op_sorta_trimends_inc", "primitives": ["sorta", "trimends", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then add one to each.", "solution": "def op_sorta_trimends_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_trimends_inc([1, 2, 3, 4]) == [3, 4]\nassert op_sorta_trimends_inc([]) == []\nassert op_sorta_trimends_inc([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sorta_trimends_inc([5, 5, 5]) == [6]\nassert op_sorta_trimends_inc([3, 1, 2]) == [3]\nassert op_sorta_trimends_inc([10]) == []\nassert op_sorta_trimends_inc([2, 4, 6]) == [5]\nassert op_sorta_trimends_inc([-7, 12, -7]) == [-6]"}
{"id": "op_double_trimends_firsteven", "entry_point": "op_double_trimends_firsteven", "primitives": ["double", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_double_trimends_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_trimends_firsteven([1, 2, 3, 4]) == 4\nassert op_double_trimends_firsteven([]) == 0\nassert op_double_trimends_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_double_trimends_firsteven([5, 5, 5]) == 10\nassert op_double_trimends_firsteven([3, 1, 2]) == 2\nassert op_double_trimends_firsteven([10]) == 0\nassert op_double_trimends_firsteven([2, 4, 6]) == 8\nassert op_double_trimends_firsteven([-7, 12, -7]) == 24"}
{"id": "op_evens_oremptyzero_last3", "entry_point": "op_evens_oremptyzero_last3", "primitives": ["evens", "oremptyzero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then keep only the last three.", "solution": "def op_evens_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_evens_oremptyzero_last3([1, 2, 3, 4]) == [2, 4]\nassert op_evens_oremptyzero_last3([]) == [0]\nassert op_evens_oremptyzero_last3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_oremptyzero_last3([5, 5, 5]) == [0]\nassert op_evens_oremptyzero_last3([3, 1, 2]) == [2]\nassert op_evens_oremptyzero_last3([10]) == [10]\nassert op_evens_oremptyzero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_oremptyzero_last3([-7, 12, -7]) == [12]"}
{"id": "op_absval_first3_len", "entry_point": "op_absval_first3_len", "primitives": ["absval", "first3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then return how many remain.", "solution": "def op_absval_first3_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return len(r)", "tests": "assert op_absval_first3_len([1, 2, 3, 4]) == 3\nassert op_absval_first3_len([]) == 0\nassert op_absval_first3_len([-2, -1, 0, 1, 2]) == 3\nassert op_absval_first3_len([5, 5, 5]) == 3\nassert op_absval_first3_len([3, 1, 2]) == 3\nassert op_absval_first3_len([10]) == 1\nassert op_absval_first3_len([2, 4, 6]) == 3\nassert op_absval_first3_len([-7, 12, -7]) == 3"}
{"id": "op_dec_last3_sorta", "entry_point": "op_dec_last3_sorta", "primitives": ["dec", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then sort ascending.", "solution": "def op_dec_last3_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_last3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_last3_sorta([]) == []\nassert op_dec_last3_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dec_last3_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_dec_last3_sorta([3, 1, 2]) == [0, 1, 2]\nassert op_dec_last3_sorta([10]) == [9]\nassert op_dec_last3_sorta([2, 4, 6]) == [1, 3, 5]\nassert op_dec_last3_sorta([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_square_uniq_haszero", "entry_point": "op_square_uniq_haszero", "primitives": ["square", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_square_uniq_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_square_uniq_haszero([1, 2, 3, 4]) == False\nassert op_square_uniq_haszero([]) == False\nassert op_square_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_square_uniq_haszero([5, 5, 5]) == False\nassert op_square_uniq_haszero([3, 1, 2]) == False\nassert op_square_uniq_haszero([10]) == False\nassert op_square_uniq_haszero([2, 4, 6]) == False\nassert op_square_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_last3_trimends_padto3", "entry_point": "op_last3_trimends_padto3", "primitives": ["last3", "trimends", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_last3_trimends_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_trimends_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_last3_trimends_padto3([]) == [0, 0, 0]\nassert op_last3_trimends_padto3([-2, -1, 0, 1, 2]) == [1, 0, 0]\nassert op_last3_trimends_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_last3_trimends_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_last3_trimends_padto3([10]) == [0, 0, 0]\nassert op_last3_trimends_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_last3_trimends_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_dec_last3_alldistinct", "entry_point": "op_dec_last3_alldistinct", "primitives": ["dec", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then return whether all values are distinct.", "solution": "def op_dec_last3_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_dec_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_last3_alldistinct([]) == True\nassert op_dec_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_last3_alldistinct([5, 5, 5]) == False\nassert op_dec_last3_alldistinct([3, 1, 2]) == True\nassert op_dec_last3_alldistinct([10]) == True\nassert op_dec_last3_alldistinct([2, 4, 6]) == True\nassert op_dec_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_takewhilepos_padto3", "entry_point": "op_dropzeros_takewhilepos_padto3", "primitives": ["dropzeros", "takewhilepos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_takewhilepos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_dropzeros_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_dropzeros_takewhilepos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos_padto3([10]) == [10, 0, 0]\nassert op_dropzeros_takewhilepos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_first3_sortd_sortabs", "entry_point": "op_first3_sortd_sortabs", "primitives": ["first3", "sortd", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then sort by absolute value.", "solution": "def op_first3_sortd_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_sortd_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortd_sortabs([]) == []\nassert op_first3_sortd_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sortd_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortd_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortd_sortabs([10]) == [10]\nassert op_first3_sortd_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortd_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_neg_absval_square", "entry_point": "op_neg_absval_square", "primitives": ["neg", "absval", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then square each.", "solution": "def op_neg_absval_square(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_neg_absval_square([1, 2, 3, 4]) == []\nassert op_neg_absval_square([]) == []\nassert op_neg_absval_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_neg_absval_square([5, 5, 5]) == []\nassert op_neg_absval_square([3, 1, 2]) == []\nassert op_neg_absval_square([10]) == []\nassert op_neg_absval_square([2, 4, 6]) == []\nassert op_neg_absval_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_last3_dropwhileneg_first3", "entry_point": "op_last3_dropwhileneg_first3", "primitives": ["last3", "dropwhileneg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then keep only the first three.", "solution": "def op_last3_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_last3_dropwhileneg_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_dropwhileneg_first3([]) == []\nassert op_last3_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_last3_dropwhileneg_first3([10]) == [10]\nassert op_last3_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_dropwhileneg_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_trimends_evens_padto3", "entry_point": "op_trimends_evens_padto3", "primitives": ["trimends", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_trimends_evens_padto3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_trimends_evens_padto3([1, 2, 3, 4]) == [2, 0, 0]\nassert op_trimends_evens_padto3([]) == [0, 0, 0]\nassert op_trimends_evens_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_trimends_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_trimends_evens_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_trimends_evens_padto3([10]) == [0, 0, 0]\nassert op_trimends_evens_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_add10_last3_double", "entry_point": "op_add10_last3_double", "primitives": ["add10", "last3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then double each.", "solution": "def op_add10_last3_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_last3_double([1, 2, 3, 4]) == [24, 26, 28]\nassert op_add10_last3_double([]) == []\nassert op_add10_last3_double([-2, -1, 0, 1, 2]) == [20, 22, 24]\nassert op_add10_last3_double([5, 5, 5]) == [30, 30, 30]\nassert op_add10_last3_double([3, 1, 2]) == [26, 22, 24]\nassert op_add10_last3_double([10]) == [40]\nassert op_add10_last3_double([2, 4, 6]) == [24, 28, 32]\nassert op_add10_last3_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_negate_inc_evens", "entry_point": "op_negate_inc_evens", "primitives": ["negate", "inc", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then keep the even numbers.", "solution": "def op_negate_inc_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_inc_evens([1, 2, 3, 4]) == [0, -2]\nassert op_negate_inc_evens([]) == []\nassert op_negate_inc_evens([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_negate_inc_evens([5, 5, 5]) == [-4, -4, -4]\nassert op_negate_inc_evens([3, 1, 2]) == [-2, 0]\nassert op_negate_inc_evens([10]) == []\nassert op_negate_inc_evens([2, 4, 6]) == []\nassert op_negate_inc_evens([-7, 12, -7]) == [8, 8]"}
{"id": "op_rev_last3_first3", "entry_point": "op_rev_last3_first3", "primitives": ["rev", "last3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then keep only the first three.", "solution": "def op_rev_last3_first3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_rev_last3_first3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_last3_first3([]) == []\nassert op_rev_last3_first3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_rev_last3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3_first3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_last3_first3([10]) == [10]\nassert op_rev_last3_first3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_last3_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_dropwhileneg_alldistinct", "entry_point": "op_beforezero_dropwhileneg_alldistinct", "primitives": ["beforezero", "dropwhileneg", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the leading negative values, then return whether all values are distinct.", "solution": "def op_beforezero_dropwhileneg_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_dropwhileneg_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_dropwhileneg_alldistinct([]) == True\nassert op_beforezero_dropwhileneg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_dropwhileneg_alldistinct([5, 5, 5]) == False\nassert op_beforezero_dropwhileneg_alldistinct([3, 1, 2]) == True\nassert op_beforezero_dropwhileneg_alldistinct([10]) == True\nassert op_beforezero_dropwhileneg_alldistinct([2, 4, 6]) == True\nassert op_beforezero_dropwhileneg_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortabs_uniq_haszero", "entry_point": "op_sortabs_uniq_haszero", "primitives": ["sortabs", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_sortabs_uniq_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_sortabs_uniq_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_uniq_haszero([]) == False\nassert op_sortabs_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_uniq_haszero([5, 5, 5]) == False\nassert op_sortabs_uniq_haszero([3, 1, 2]) == False\nassert op_sortabs_uniq_haszero([10]) == False\nassert op_sortabs_uniq_haszero([2, 4, 6]) == False\nassert op_sortabs_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_double_first3_pos", "entry_point": "op_double_first3_pos", "primitives": ["double", "first3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three, then keep the positive numbers.", "solution": "def op_double_first3_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_first3_pos([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_first3_pos([]) == []\nassert op_double_first3_pos([-2, -1, 0, 1, 2]) == []\nassert op_double_first3_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_first3_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_first3_pos([10]) == [20]\nassert op_double_first3_pos([2, 4, 6]) == [4, 8, 12]\nassert op_double_first3_pos([-7, 12, -7]) == [24]"}
{"id": "op_last3_dropwhileneg_rev", "entry_point": "op_last3_dropwhileneg_rev", "primitives": ["last3", "dropwhileneg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then reverse the order.", "solution": "def op_last3_dropwhileneg_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_dropwhileneg_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_dropwhileneg_rev([]) == []\nassert op_last3_dropwhileneg_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_dropwhileneg_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropwhileneg_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_dropwhileneg_rev([10]) == [10]\nassert op_last3_dropwhileneg_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_dropwhileneg_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dec_gt5_firsteven", "entry_point": "op_dec_gt5_firsteven", "primitives": ["dec", "gt5", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then return the first even value (0 if none).", "solution": "def op_dec_gt5_firsteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dec_gt5_firsteven([1, 2, 3, 4]) == 0\nassert op_dec_gt5_firsteven([]) == 0\nassert op_dec_gt5_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dec_gt5_firsteven([5, 5, 5]) == 0\nassert op_dec_gt5_firsteven([3, 1, 2]) == 0\nassert op_dec_gt5_firsteven([10]) == 0\nassert op_dec_gt5_firsteven([2, 4, 6]) == 0\nassert op_dec_gt5_firsteven([-7, 12, -7]) == 0"}
{"id": "op_negate_rev_evens", "entry_point": "op_negate_rev_evens", "primitives": ["negate", "rev", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then reverse the order, then keep the even numbers.", "solution": "def op_negate_rev_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_rev_evens([1, 2, 3, 4]) == [-4, -2]\nassert op_negate_rev_evens([]) == []\nassert op_negate_rev_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_negate_rev_evens([5, 5, 5]) == []\nassert op_negate_rev_evens([3, 1, 2]) == [-2]\nassert op_negate_rev_evens([10]) == [-10]\nassert op_negate_rev_evens([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_rev_evens([-7, 12, -7]) == [-12]"}
{"id": "op_uniq_evens_anyeven", "entry_point": "op_uniq_evens_anyeven", "primitives": ["uniq", "evens", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then return whether any value is even.", "solution": "def op_uniq_evens_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_evens_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_evens_anyeven([]) == False\nassert op_uniq_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_evens_anyeven([5, 5, 5]) == False\nassert op_uniq_evens_anyeven([3, 1, 2]) == True\nassert op_uniq_evens_anyeven([10]) == True\nassert op_uniq_evens_anyeven([2, 4, 6]) == True\nassert op_uniq_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_oremptyzero_prod", "entry_point": "op_uniq_oremptyzero_prod", "primitives": ["uniq", "oremptyzero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then return their product.", "solution": "def op_uniq_oremptyzero_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_uniq_oremptyzero_prod([1, 2, 3, 4]) == 24\nassert op_uniq_oremptyzero_prod([]) == 0\nassert op_uniq_oremptyzero_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_oremptyzero_prod([5, 5, 5]) == 5\nassert op_uniq_oremptyzero_prod([3, 1, 2]) == 6\nassert op_uniq_oremptyzero_prod([10]) == 10\nassert op_uniq_oremptyzero_prod([2, 4, 6]) == 48\nassert op_uniq_oremptyzero_prod([-7, 12, -7]) == -84"}
{"id": "op_clamp10_padto3_uniq", "entry_point": "op_clamp10_padto3_uniq", "primitives": ["clamp10", "padto3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_padto3_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_padto3_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_padto3_uniq([]) == [0]\nassert op_clamp10_padto3_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_padto3_uniq([5, 5, 5]) == [5]\nassert op_clamp10_padto3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3_uniq([10]) == [10, 0]\nassert op_clamp10_padto3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_div3_neg_padto3", "entry_point": "op_div3_neg_padto3", "primitives": ["div3", "neg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_div3_neg_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_div3_neg_padto3([]) == [0, 0, 0]\nassert op_div3_neg_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_div3_neg_padto3([10]) == [0, 0, 0]\nassert op_div3_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_div3_neg_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_ages_evens_padto3", "entry_point": "op_ages_evens_padto3", "primitives": ["ages", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_ages_evens_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_evens_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12, 0]\nassert op_ages_evens_padto3([]) == [0, 0, 0]\nassert op_ages_evens_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 0, 0]\nassert op_ages_evens_padto3([{'name': 'Fi', 'age': 41}]) == [0, 0, 0]"}
{"id": "op_odds_div3_trimends", "entry_point": "op_odds_div3_trimends", "primitives": ["odds", "div3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then drop the first and last elements.", "solution": "def op_odds_div3_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_div3_trimends([1, 2, 3, 4]) == []\nassert op_odds_div3_trimends([]) == []\nassert op_odds_div3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_trimends([5, 5, 5]) == []\nassert op_odds_div3_trimends([3, 1, 2]) == []\nassert op_odds_div3_trimends([10]) == []\nassert op_odds_div3_trimends([2, 4, 6]) == []\nassert op_odds_div3_trimends([-7, 12, -7]) == []"}
{"id": "op_last3_odds_rev", "entry_point": "op_last3_odds_rev", "primitives": ["last3", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then reverse the order.", "solution": "def op_last3_odds_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_odds_rev([1, 2, 3, 4]) == [3]\nassert op_last3_odds_rev([]) == []\nassert op_last3_odds_rev([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_odds_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_odds_rev([3, 1, 2]) == [1, 3]\nassert op_last3_odds_rev([10]) == []\nassert op_last3_odds_rev([2, 4, 6]) == []\nassert op_last3_odds_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero_first3_takewhilepos", "entry_point": "op_oremptyzero_first3_takewhilepos", "primitives": ["oremptyzero", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then take values while they are positive.", "solution": "def op_oremptyzero_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_first3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_first3_takewhilepos([]) == []\nassert op_oremptyzero_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_first3_takewhilepos([10]) == [10]\nassert op_oremptyzero_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_first3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_negate_gt5_oremptyzero", "entry_point": "op_negate_gt5_oremptyzero", "primitives": ["negate", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_negate_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_negate_gt5_oremptyzero([]) == [0]\nassert op_negate_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_negate_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_negate_gt5_oremptyzero([10]) == [0]\nassert op_negate_gt5_oremptyzero([2, 4, 6]) == [0]\nassert op_negate_gt5_oremptyzero([-7, 12, -7]) == [7, 7]"}
{"id": "op_double_sortabs_div3", "entry_point": "op_double_sortabs_div3", "primitives": ["double", "sortabs", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then keep multiples of three.", "solution": "def op_double_sortabs_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_sortabs_div3([1, 2, 3, 4]) == [6]\nassert op_double_sortabs_div3([]) == []\nassert op_double_sortabs_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_sortabs_div3([5, 5, 5]) == []\nassert op_double_sortabs_div3([3, 1, 2]) == [6]\nassert op_double_sortabs_div3([10]) == []\nassert op_double_sortabs_div3([2, 4, 6]) == [12]\nassert op_double_sortabs_div3([-7, 12, -7]) == [24]"}
{"id": "op_gt5_clamp10_allpos", "entry_point": "op_gt5_clamp10_allpos", "primitives": ["gt5", "clamp10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then return whether all values are positive.", "solution": "def op_gt5_clamp10_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_clamp10_allpos([1, 2, 3, 4]) == True\nassert op_gt5_clamp10_allpos([]) == True\nassert op_gt5_clamp10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_clamp10_allpos([5, 5, 5]) == True\nassert op_gt5_clamp10_allpos([3, 1, 2]) == True\nassert op_gt5_clamp10_allpos([10]) == True\nassert op_gt5_clamp10_allpos([2, 4, 6]) == True\nassert op_gt5_clamp10_allpos([-7, 12, -7]) == True"}
{"id": "op_dropzeros_add10_first3", "entry_point": "op_dropzeros_add10_first3", "primitives": ["dropzeros", "add10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then keep only the first three.", "solution": "def op_dropzeros_add10_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_add10_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_dropzeros_add10_first3([]) == []\nassert op_dropzeros_add10_first3([-2, -1, 0, 1, 2]) == [8, 9, 11]\nassert op_dropzeros_add10_first3([5, 5, 5]) == [15, 15, 15]\nassert op_dropzeros_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_dropzeros_add10_first3([10]) == [20]\nassert op_dropzeros_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_add10_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_rev_oremptyzero_sorta", "entry_point": "op_rev_oremptyzero_sorta", "primitives": ["rev", "oremptyzero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then sort ascending.", "solution": "def op_rev_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_rev_oremptyzero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_oremptyzero_sorta([]) == [0]\nassert op_rev_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_oremptyzero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_rev_oremptyzero_sorta([10]) == [10]\nassert op_rev_oremptyzero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_rev_oremptyzero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_square_takewhilepos_sorta", "entry_point": "op_square_takewhilepos_sorta", "primitives": ["square", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then sort ascending.", "solution": "def op_square_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_square_takewhilepos_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos_sorta([]) == []\nassert op_square_takewhilepos_sorta([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_square_takewhilepos_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_square_takewhilepos_sorta([10]) == [100]\nassert op_square_takewhilepos_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_sorta([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_add10_absval_min", "entry_point": "op_add10_absval_min", "primitives": ["add10", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_add10_absval_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_add10_absval_min([1, 2, 3, 4]) == 11\nassert op_add10_absval_min([]) == 0\nassert op_add10_absval_min([-2, -1, 0, 1, 2]) == 8\nassert op_add10_absval_min([5, 5, 5]) == 15\nassert op_add10_absval_min([3, 1, 2]) == 11\nassert op_add10_absval_min([10]) == 20\nassert op_add10_absval_min([2, 4, 6]) == 12\nassert op_add10_absval_min([-7, 12, -7]) == 3"}
{"id": "op_uniq_takewhilepos_dropfirst", "entry_point": "op_uniq_takewhilepos_dropfirst", "primitives": ["uniq", "takewhilepos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then drop the first element.", "solution": "def op_uniq_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_uniq_takewhilepos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_takewhilepos_dropfirst([]) == []\nassert op_uniq_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos_dropfirst([5, 5, 5]) == []\nassert op_uniq_takewhilepos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_uniq_takewhilepos_dropfirst([10]) == []\nassert op_uniq_takewhilepos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_uniq_takewhilepos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sortd_evens_odds", "entry_point": "op_sortd_evens_odds", "primitives": ["sortd", "evens", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then keep the odd numbers.", "solution": "def op_sortd_evens_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_evens_odds([1, 2, 3, 4]) == []\nassert op_sortd_evens_odds([]) == []\nassert op_sortd_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_sortd_evens_odds([5, 5, 5]) == []\nassert op_sortd_evens_odds([3, 1, 2]) == []\nassert op_sortd_evens_odds([10]) == []\nassert op_sortd_evens_odds([2, 4, 6]) == []\nassert op_sortd_evens_odds([-7, 12, -7]) == []"}
{"id": "op_clamp10_absval_issorted", "entry_point": "op_clamp10_absval_issorted", "primitives": ["clamp10", "absval", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_clamp10_absval_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_clamp10_absval_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_absval_issorted([]) == True\nassert op_clamp10_absval_issorted([-2, -1, 0, 1, 2]) == False\nassert op_clamp10_absval_issorted([5, 5, 5]) == True\nassert op_clamp10_absval_issorted([3, 1, 2]) == False\nassert op_clamp10_absval_issorted([10]) == True\nassert op_clamp10_absval_issorted([2, 4, 6]) == True\nassert op_clamp10_absval_issorted([-7, 12, -7]) == False"}
{"id": "op_inc_add10_gt5", "entry_point": "op_inc_add10_gt5", "primitives": ["inc", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then keep values greater than five.", "solution": "def op_inc_add10_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_add10_gt5([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_add10_gt5([]) == []\nassert op_inc_add10_gt5([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_add10_gt5([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10_gt5([3, 1, 2]) == [14, 12, 13]\nassert op_inc_add10_gt5([10]) == [21]\nassert op_inc_add10_gt5([2, 4, 6]) == [13, 15, 17]\nassert op_inc_add10_gt5([-7, 12, -7]) == [23]"}
{"id": "op_double_oremptyzero_sorta", "entry_point": "op_double_oremptyzero_sorta", "primitives": ["double", "oremptyzero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then sort ascending.", "solution": "def op_double_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_double_oremptyzero_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_sorta([]) == [0]\nassert op_double_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_oremptyzero_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_double_oremptyzero_sorta([10]) == [20]\nassert op_double_oremptyzero_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dec_sortd_dropzeros", "entry_point": "op_dec_sortd_dropzeros", "primitives": ["dec", "sortd", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort descending, then drop the zeros.", "solution": "def op_dec_sortd_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_sortd_dropzeros([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dec_sortd_dropzeros([]) == []\nassert op_dec_sortd_dropzeros([-2, -1, 0, 1, 2]) == [1, -1, -2, -3]\nassert op_dec_sortd_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortd_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dec_sortd_dropzeros([10]) == [9]\nassert op_dec_sortd_dropzeros([2, 4, 6]) == [5, 3, 1]\nassert op_dec_sortd_dropzeros([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_dropwhileneg_dropzeros_anyeven", "entry_point": "op_dropwhileneg_dropzeros_anyeven", "primitives": ["dropwhileneg", "dropzeros", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then return whether any value is even.", "solution": "def op_dropwhileneg_dropzeros_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_dropzeros_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_dropzeros_anyeven([]) == False\nassert op_dropwhileneg_dropzeros_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_dropzeros_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_dropzeros_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_dropzeros_anyeven([10]) == True\nassert op_dropwhileneg_dropzeros_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_dropzeros_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_beforezero_last3", "entry_point": "op_evens_beforezero_last3", "primitives": ["evens", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then keep only the last three.", "solution": "def op_evens_beforezero_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_evens_beforezero_last3([1, 2, 3, 4]) == [2, 4]\nassert op_evens_beforezero_last3([]) == []\nassert op_evens_beforezero_last3([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_beforezero_last3([5, 5, 5]) == []\nassert op_evens_beforezero_last3([3, 1, 2]) == [2]\nassert op_evens_beforezero_last3([10]) == [10]\nassert op_evens_beforezero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_beforezero_last3([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_gt5_padto3", "entry_point": "op_sortabs_gt5_padto3", "primitives": ["sortabs", "gt5", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then pad with zeros to at least three elements.", "solution": "def op_sortabs_gt5_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_gt5_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_sortabs_gt5_padto3([]) == [0, 0, 0]\nassert op_sortabs_gt5_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_sortabs_gt5_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_sortabs_gt5_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_sortabs_gt5_padto3([10]) == [10, 0, 0]\nassert op_sortabs_gt5_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_sortabs_gt5_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_rev_dropzeros_issorted", "entry_point": "op_rev_dropzeros_issorted", "primitives": ["rev", "dropzeros", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_rev_dropzeros_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_rev_dropzeros_issorted([1, 2, 3, 4]) == False\nassert op_rev_dropzeros_issorted([]) == True\nassert op_rev_dropzeros_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_dropzeros_issorted([5, 5, 5]) == True\nassert op_rev_dropzeros_issorted([3, 1, 2]) == False\nassert op_rev_dropzeros_issorted([10]) == True\nassert op_rev_dropzeros_issorted([2, 4, 6]) == False\nassert op_rev_dropzeros_issorted([-7, 12, -7]) == False"}
{"id": "op_sortd_dec_sorta", "entry_point": "op_sortd_dec_sorta", "primitives": ["sortd", "dec", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each, then sort ascending.", "solution": "def op_sortd_dec_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_dec_sorta([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortd_dec_sorta([]) == []\nassert op_sortd_dec_sorta([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_sortd_dec_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_dec_sorta([3, 1, 2]) == [0, 1, 2]\nassert op_sortd_dec_sorta([10]) == [9]\nassert op_sortd_dec_sorta([2, 4, 6]) == [1, 3, 5]\nassert op_sortd_dec_sorta([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_absval_first3_sortabs", "entry_point": "op_absval_first3_sortabs", "primitives": ["absval", "first3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then sort by absolute value.", "solution": "def op_absval_first3_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_first3_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_first3_sortabs([]) == []\nassert op_absval_first3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_first3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_absval_first3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_absval_first3_sortabs([10]) == [10]\nassert op_absval_first3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_absval_first3_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_uniq_double_dec", "entry_point": "op_uniq_double_dec", "primitives": ["uniq", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then subtract one from each.", "solution": "def op_uniq_double_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_double_dec([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_uniq_double_dec([]) == []\nassert op_uniq_double_dec([-2, -1, 0, 1, 2]) == [-5, -3, -1, 1, 3]\nassert op_uniq_double_dec([5, 5, 5]) == [9]\nassert op_uniq_double_dec([3, 1, 2]) == [5, 1, 3]\nassert op_uniq_double_dec([10]) == [19]\nassert op_uniq_double_dec([2, 4, 6]) == [3, 7, 11]\nassert op_uniq_double_dec([-7, 12, -7]) == [-15, 23]"}
{"id": "op_takewhilepos_first3_allpos", "entry_point": "op_takewhilepos_first3_allpos", "primitives": ["takewhilepos", "first3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then return whether all values are positive.", "solution": "def op_takewhilepos_first3_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_first3_allpos([1, 2, 3, 4]) == True\nassert op_takewhilepos_first3_allpos([]) == True\nassert op_takewhilepos_first3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_first3_allpos([5, 5, 5]) == True\nassert op_takewhilepos_first3_allpos([3, 1, 2]) == True\nassert op_takewhilepos_first3_allpos([10]) == True\nassert op_takewhilepos_first3_allpos([2, 4, 6]) == True\nassert op_takewhilepos_first3_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_inc_oremptyzero", "entry_point": "op_dec_inc_oremptyzero", "primitives": ["dec", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then if empty, use a single zero.", "solution": "def op_dec_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dec_inc_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc_oremptyzero([]) == [0]\nassert op_dec_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_dec_inc_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc_oremptyzero([10]) == [10]\nassert op_dec_inc_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg_takewhilepos_add10", "entry_point": "op_neg_takewhilepos_add10", "primitives": ["neg", "takewhilepos", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then add ten to each.", "solution": "def op_neg_takewhilepos_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_takewhilepos_add10([1, 2, 3, 4]) == []\nassert op_neg_takewhilepos_add10([]) == []\nassert op_neg_takewhilepos_add10([-2, -1, 0, 1, 2]) == []\nassert op_neg_takewhilepos_add10([5, 5, 5]) == []\nassert op_neg_takewhilepos_add10([3, 1, 2]) == []\nassert op_neg_takewhilepos_add10([10]) == []\nassert op_neg_takewhilepos_add10([2, 4, 6]) == []\nassert op_neg_takewhilepos_add10([-7, 12, -7]) == []"}
{"id": "op_gt5_pos_double", "entry_point": "op_gt5_pos_double", "primitives": ["gt5", "pos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then double each.", "solution": "def op_gt5_pos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_gt5_pos_double([1, 2, 3, 4]) == []\nassert op_gt5_pos_double([]) == []\nassert op_gt5_pos_double([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_double([5, 5, 5]) == []\nassert op_gt5_pos_double([3, 1, 2]) == []\nassert op_gt5_pos_double([10]) == [20]\nassert op_gt5_pos_double([2, 4, 6]) == [12]\nassert op_gt5_pos_double([-7, 12, -7]) == [24]"}
{"id": "op_first3_dropfirst_dropzeros", "entry_point": "op_first3_dropfirst_dropzeros", "primitives": ["first3", "dropfirst", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then drop the zeros.", "solution": "def op_first3_dropfirst_dropzeros(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_first3_dropfirst_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_first3_dropfirst_dropzeros([]) == []\nassert op_first3_dropfirst_dropzeros([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_dropfirst_dropzeros([5, 5, 5]) == [5, 5]\nassert op_first3_dropfirst_dropzeros([3, 1, 2]) == [1, 2]\nassert op_first3_dropfirst_dropzeros([10]) == []\nassert op_first3_dropfirst_dropzeros([2, 4, 6]) == [4, 6]\nassert op_first3_dropfirst_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_takewhilepos_max", "entry_point": "op_padto3_takewhilepos_max", "primitives": ["padto3", "takewhilepos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_padto3_takewhilepos_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_padto3_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_padto3_takewhilepos_max([]) == 0\nassert op_padto3_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_takewhilepos_max([5, 5, 5]) == 5\nassert op_padto3_takewhilepos_max([3, 1, 2]) == 3\nassert op_padto3_takewhilepos_max([10]) == 10\nassert op_padto3_takewhilepos_max([2, 4, 6]) == 6\nassert op_padto3_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_dropfirst_sortd", "entry_point": "op_dropwhileneg_dropfirst_sortd", "primitives": ["dropwhileneg", "dropfirst", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then sort descending.", "solution": "def op_dropwhileneg_dropfirst_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_dropfirst_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropwhileneg_dropfirst_sortd([]) == []\nassert op_dropwhileneg_dropfirst_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_dropwhileneg_dropfirst_sortd([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_dropfirst_sortd([3, 1, 2]) == [2, 1]\nassert op_dropwhileneg_dropfirst_sortd([10]) == []\nassert op_dropwhileneg_dropfirst_sortd([2, 4, 6]) == [6, 4]\nassert op_dropwhileneg_dropfirst_sortd([-7, 12, -7]) == [-7]"}
{"id": "op_takewhilepos_dec_evens", "entry_point": "op_takewhilepos_dec_evens", "primitives": ["takewhilepos", "dec", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then keep the even numbers.", "solution": "def op_takewhilepos_dec_evens(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_takewhilepos_dec_evens([1, 2, 3, 4]) == [0, 2]\nassert op_takewhilepos_dec_evens([]) == []\nassert op_takewhilepos_dec_evens([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec_evens([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_dec_evens([3, 1, 2]) == [2, 0]\nassert op_takewhilepos_dec_evens([10]) == []\nassert op_takewhilepos_dec_evens([2, 4, 6]) == []\nassert op_takewhilepos_dec_evens([-7, 12, -7]) == []"}
{"id": "op_square_gt5_counteven", "entry_point": "op_square_gt5_counteven", "primitives": ["square", "gt5", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then return how many values are even.", "solution": "def op_square_gt5_counteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_square_gt5_counteven([1, 2, 3, 4]) == 1\nassert op_square_gt5_counteven([]) == 0\nassert op_square_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_square_gt5_counteven([5, 5, 5]) == 0\nassert op_square_gt5_counteven([3, 1, 2]) == 0\nassert op_square_gt5_counteven([10]) == 1\nassert op_square_gt5_counteven([2, 4, 6]) == 2\nassert op_square_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_square_sortd_haszero", "entry_point": "op_square_sortd_haszero", "primitives": ["square", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then return whether the list contains a zero.", "solution": "def op_square_sortd_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_square_sortd_haszero([1, 2, 3, 4]) == False\nassert op_square_sortd_haszero([]) == False\nassert op_square_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_square_sortd_haszero([5, 5, 5]) == False\nassert op_square_sortd_haszero([3, 1, 2]) == False\nassert op_square_sortd_haszero([10]) == False\nassert op_square_sortd_haszero([2, 4, 6]) == False\nassert op_square_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_double_uniq_max", "entry_point": "op_double_uniq_max", "primitives": ["double", "uniq", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_double_uniq_max(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_double_uniq_max([1, 2, 3, 4]) == 8\nassert op_double_uniq_max([]) == 0\nassert op_double_uniq_max([-2, -1, 0, 1, 2]) == 4\nassert op_double_uniq_max([5, 5, 5]) == 10\nassert op_double_uniq_max([3, 1, 2]) == 6\nassert op_double_uniq_max([10]) == 20\nassert op_double_uniq_max([2, 4, 6]) == 12\nassert op_double_uniq_max([-7, 12, -7]) == 24"}
{"id": "op_add10_takewhilepos_neg", "entry_point": "op_add10_takewhilepos_neg", "primitives": ["add10", "takewhilepos", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then keep the negative numbers.", "solution": "def op_add10_takewhilepos_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_takewhilepos_neg([1, 2, 3, 4]) == []\nassert op_add10_takewhilepos_neg([]) == []\nassert op_add10_takewhilepos_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_takewhilepos_neg([5, 5, 5]) == []\nassert op_add10_takewhilepos_neg([3, 1, 2]) == []\nassert op_add10_takewhilepos_neg([10]) == []\nassert op_add10_takewhilepos_neg([2, 4, 6]) == []\nassert op_add10_takewhilepos_neg([-7, 12, -7]) == []"}
{"id": "op_sortd_trimends_odds", "entry_point": "op_sortd_trimends_odds", "primitives": ["sortd", "trimends", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then keep the odd numbers.", "solution": "def op_sortd_trimends_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_trimends_odds([1, 2, 3, 4]) == [3]\nassert op_sortd_trimends_odds([]) == []\nassert op_sortd_trimends_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_trimends_odds([5, 5, 5]) == [5]\nassert op_sortd_trimends_odds([3, 1, 2]) == []\nassert op_sortd_trimends_odds([10]) == []\nassert op_sortd_trimends_odds([2, 4, 6]) == []\nassert op_sortd_trimends_odds([-7, 12, -7]) == [-7]"}
{"id": "op_odds_negate_sortabs", "entry_point": "op_odds_negate_sortabs", "primitives": ["odds", "negate", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each, then sort by absolute value.", "solution": "def op_odds_negate_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_negate_sortabs([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_negate_sortabs([]) == []\nassert op_odds_negate_sortabs([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_negate_sortabs([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_negate_sortabs([3, 1, 2]) == [-1, -3]\nassert op_odds_negate_sortabs([10]) == []\nassert op_odds_negate_sortabs([2, 4, 6]) == []\nassert op_odds_negate_sortabs([-7, 12, -7]) == [7, 7]"}
{"id": "op_beforezero_dropfirst_max", "entry_point": "op_beforezero_dropfirst_max", "primitives": ["beforezero", "dropfirst", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_beforezero_dropfirst_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_beforezero_dropfirst_max([1, 2, 3, 4]) == 4\nassert op_beforezero_dropfirst_max([]) == 0\nassert op_beforezero_dropfirst_max([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_dropfirst_max([5, 5, 5]) == 5\nassert op_beforezero_dropfirst_max([3, 1, 2]) == 2\nassert op_beforezero_dropfirst_max([10]) == 0\nassert op_beforezero_dropfirst_max([2, 4, 6]) == 6\nassert op_beforezero_dropfirst_max([-7, 12, -7]) == 12"}
{"id": "op_padto3_square_len", "entry_point": "op_padto3_square_len", "primitives": ["padto3", "square", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then return how many remain.", "solution": "def op_padto3_square_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_padto3_square_len([1, 2, 3, 4]) == 4\nassert op_padto3_square_len([]) == 3\nassert op_padto3_square_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_square_len([5, 5, 5]) == 3\nassert op_padto3_square_len([3, 1, 2]) == 3\nassert op_padto3_square_len([10]) == 3\nassert op_padto3_square_len([2, 4, 6]) == 3\nassert op_padto3_square_len([-7, 12, -7]) == 3"}
{"id": "op_takewhilepos_inc_haszero", "entry_point": "op_takewhilepos_inc_haszero", "primitives": ["takewhilepos", "inc", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then return whether the list contains a zero.", "solution": "def op_takewhilepos_inc_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_takewhilepos_inc_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_inc_haszero([]) == False\nassert op_takewhilepos_inc_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_inc_haszero([5, 5, 5]) == False\nassert op_takewhilepos_inc_haszero([3, 1, 2]) == False\nassert op_takewhilepos_inc_haszero([10]) == False\nassert op_takewhilepos_inc_haszero([2, 4, 6]) == False\nassert op_takewhilepos_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_inc_rev_alldistinct", "entry_point": "op_inc_rev_alldistinct", "primitives": ["inc", "rev", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then return whether all values are distinct.", "solution": "def op_inc_rev_alldistinct(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_inc_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_inc_rev_alldistinct([]) == True\nassert op_inc_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_inc_rev_alldistinct([5, 5, 5]) == False\nassert op_inc_rev_alldistinct([3, 1, 2]) == True\nassert op_inc_rev_alldistinct([10]) == True\nassert op_inc_rev_alldistinct([2, 4, 6]) == True\nassert op_inc_rev_alldistinct([-7, 12, -7]) == False"}
{"id": "op_absval_takewhilepos_clamp10", "entry_point": "op_absval_takewhilepos_clamp10", "primitives": ["absval", "takewhilepos", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then cap each value at 10.", "solution": "def op_absval_takewhilepos_clamp10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_absval_takewhilepos_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos_clamp10([]) == []\nassert op_absval_takewhilepos_clamp10([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_takewhilepos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_absval_takewhilepos_clamp10([10]) == [10]\nassert op_absval_takewhilepos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_negate_absval_padto3", "entry_point": "op_negate_absval_padto3", "primitives": ["negate", "absval", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_negate_absval_padto3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_negate_absval_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval_padto3([]) == [0, 0, 0]\nassert op_negate_absval_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_negate_absval_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval_padto3([10]) == [10, 0, 0]\nassert op_negate_absval_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval_padto3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_absval_sortabs_div3", "entry_point": "op_absval_sortabs_div3", "primitives": ["absval", "sortabs", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then keep multiples of three.", "solution": "def op_absval_sortabs_div3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_absval_sortabs_div3([1, 2, 3, 4]) == [3]\nassert op_absval_sortabs_div3([]) == []\nassert op_absval_sortabs_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_absval_sortabs_div3([5, 5, 5]) == []\nassert op_absval_sortabs_div3([3, 1, 2]) == [3]\nassert op_absval_sortabs_div3([10]) == []\nassert op_absval_sortabs_div3([2, 4, 6]) == [6]\nassert op_absval_sortabs_div3([-7, 12, -7]) == [12]"}
{"id": "op_negate_double_max", "entry_point": "op_negate_double_max", "primitives": ["negate", "double", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then return the maximum (0 if empty).", "solution": "def op_negate_double_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_negate_double_max([1, 2, 3, 4]) == -2\nassert op_negate_double_max([]) == 0\nassert op_negate_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_negate_double_max([5, 5, 5]) == -10\nassert op_negate_double_max([3, 1, 2]) == -2\nassert op_negate_double_max([10]) == -20\nassert op_negate_double_max([2, 4, 6]) == -4\nassert op_negate_double_max([-7, 12, -7]) == 14"}
{"id": "op_takewhilepos_beforezero_dropzeros", "entry_point": "op_takewhilepos_beforezero_dropzeros", "primitives": ["takewhilepos", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then drop the zeros.", "solution": "def op_takewhilepos_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_beforezero_dropzeros([]) == []\nassert op_takewhilepos_beforezero_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_beforezero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_beforezero_dropzeros([10]) == [10]\nassert op_takewhilepos_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_beforezero_dropzeros([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dec_dropfirst", "entry_point": "op_takewhilepos_dec_dropfirst", "primitives": ["takewhilepos", "dec", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then drop the first element.", "solution": "def op_takewhilepos_dec_dropfirst(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_takewhilepos_dec_dropfirst([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_dec_dropfirst([]) == []\nassert op_takewhilepos_dec_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec_dropfirst([5, 5, 5]) == [4, 4]\nassert op_takewhilepos_dec_dropfirst([3, 1, 2]) == [0, 1]\nassert op_takewhilepos_dec_dropfirst([10]) == []\nassert op_takewhilepos_dec_dropfirst([2, 4, 6]) == [3, 5]\nassert op_takewhilepos_dec_dropfirst([-7, 12, -7]) == []"}
{"id": "op_dropzeros_square_sorta", "entry_point": "op_dropzeros_square_sorta", "primitives": ["dropzeros", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each, then sort ascending.", "solution": "def op_dropzeros_square_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_square_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropzeros_square_sorta([]) == []\nassert op_dropzeros_square_sorta([-2, -1, 0, 1, 2]) == [1, 1, 4, 4]\nassert op_dropzeros_square_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_square_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_dropzeros_square_sorta([10]) == [100]\nassert op_dropzeros_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_square_sorta([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_negate_inc_odds", "entry_point": "op_negate_inc_odds", "primitives": ["negate", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then keep the odd numbers.", "solution": "def op_negate_inc_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_inc_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_inc_odds([]) == []\nassert op_negate_inc_odds([-2, -1, 0, 1, 2]) == [3, 1, -1]\nassert op_negate_inc_odds([5, 5, 5]) == []\nassert op_negate_inc_odds([3, 1, 2]) == [-1]\nassert op_negate_inc_odds([10]) == [-9]\nassert op_negate_inc_odds([2, 4, 6]) == [-1, -3, -5]\nassert op_negate_inc_odds([-7, 12, -7]) == [-11]"}
{"id": "op_last3_pos_clamp10", "entry_point": "op_last3_pos_clamp10", "primitives": ["last3", "pos", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers, then cap each value at 10.", "solution": "def op_last3_pos_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_pos_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_pos_clamp10([]) == []\nassert op_last3_pos_clamp10([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_pos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_pos_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_last3_pos_clamp10([10]) == [10]\nassert op_last3_pos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_last3_pos_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_evens_dec_div3", "entry_point": "op_evens_dec_div3", "primitives": ["evens", "dec", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then subtract one from each, then keep multiples of three.", "solution": "def op_evens_dec_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_dec_div3([1, 2, 3, 4]) == [3]\nassert op_evens_dec_div3([]) == []\nassert op_evens_dec_div3([-2, -1, 0, 1, 2]) == [-3]\nassert op_evens_dec_div3([5, 5, 5]) == []\nassert op_evens_dec_div3([3, 1, 2]) == []\nassert op_evens_dec_div3([10]) == [9]\nassert op_evens_dec_div3([2, 4, 6]) == [3]\nassert op_evens_dec_div3([-7, 12, -7]) == []"}
{"id": "op_evens_takewhilepos_pos", "entry_point": "op_evens_takewhilepos_pos", "primitives": ["evens", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then keep the positive numbers.", "solution": "def op_evens_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_evens_takewhilepos_pos([1, 2, 3, 4]) == [2, 4]\nassert op_evens_takewhilepos_pos([]) == []\nassert op_evens_takewhilepos_pos([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_pos([5, 5, 5]) == []\nassert op_evens_takewhilepos_pos([3, 1, 2]) == [2]\nassert op_evens_takewhilepos_pos([10]) == [10]\nassert op_evens_takewhilepos_pos([2, 4, 6]) == [2, 4, 6]\nassert op_evens_takewhilepos_pos([-7, 12, -7]) == [12]"}
{"id": "op_div3_inc_add10", "entry_point": "op_div3_inc_add10", "primitives": ["div3", "inc", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then add ten to each.", "solution": "def op_div3_inc_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_div3_inc_add10([1, 2, 3, 4]) == [14]\nassert op_div3_inc_add10([]) == []\nassert op_div3_inc_add10([-2, -1, 0, 1, 2]) == [11]\nassert op_div3_inc_add10([5, 5, 5]) == []\nassert op_div3_inc_add10([3, 1, 2]) == [14]\nassert op_div3_inc_add10([10]) == []\nassert op_div3_inc_add10([2, 4, 6]) == [17]\nassert op_div3_inc_add10([-7, 12, -7]) == [23]"}
{"id": "op_padto3_square_trimends", "entry_point": "op_padto3_square_trimends", "primitives": ["padto3", "square", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then drop the first and last elements.", "solution": "def op_padto3_square_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_square_trimends([1, 2, 3, 4]) == [4, 9]\nassert op_padto3_square_trimends([]) == [0]\nassert op_padto3_square_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_padto3_square_trimends([5, 5, 5]) == [25]\nassert op_padto3_square_trimends([3, 1, 2]) == [1]\nassert op_padto3_square_trimends([10]) == [0]\nassert op_padto3_square_trimends([2, 4, 6]) == [16]\nassert op_padto3_square_trimends([-7, 12, -7]) == [144]"}
{"id": "op_odds_dropwhileneg_oremptyzero", "entry_point": "op_odds_dropwhileneg_oremptyzero", "primitives": ["odds", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_odds_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_odds_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [1, 3]\nassert op_odds_dropwhileneg_oremptyzero([]) == [0]\nassert op_odds_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropwhileneg_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_odds_dropwhileneg_oremptyzero([3, 1, 2]) == [3, 1]\nassert op_odds_dropwhileneg_oremptyzero([10]) == [0]\nassert op_odds_dropwhileneg_oremptyzero([2, 4, 6]) == [0]\nassert op_odds_dropwhileneg_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_gt5_trimends_alldistinct", "entry_point": "op_gt5_trimends_alldistinct", "primitives": ["gt5", "trimends", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_gt5_trimends_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_gt5_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_gt5_trimends_alldistinct([]) == True\nassert op_gt5_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_gt5_trimends_alldistinct([5, 5, 5]) == True\nassert op_gt5_trimends_alldistinct([3, 1, 2]) == True\nassert op_gt5_trimends_alldistinct([10]) == True\nassert op_gt5_trimends_alldistinct([2, 4, 6]) == True\nassert op_gt5_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_add10_oremptyzero_inc", "entry_point": "op_add10_oremptyzero_inc", "primitives": ["add10", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then add one to each.", "solution": "def op_add10_oremptyzero_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_oremptyzero_inc([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_add10_oremptyzero_inc([]) == [1]\nassert op_add10_oremptyzero_inc([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_add10_oremptyzero_inc([5, 5, 5]) == [16, 16, 16]\nassert op_add10_oremptyzero_inc([3, 1, 2]) == [14, 12, 13]\nassert op_add10_oremptyzero_inc([10]) == [21]\nassert op_add10_oremptyzero_inc([2, 4, 6]) == [13, 15, 17]\nassert op_add10_oremptyzero_inc([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_takewhilepos_trimends_firsteven", "entry_point": "op_takewhilepos_trimends_firsteven", "primitives": ["takewhilepos", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_takewhilepos_trimends_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_trimends_firsteven([]) == 0\nassert op_takewhilepos_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_trimends_firsteven([5, 5, 5]) == 0\nassert op_takewhilepos_trimends_firsteven([3, 1, 2]) == 0\nassert op_takewhilepos_trimends_firsteven([10]) == 0\nassert op_takewhilepos_trimends_firsteven([2, 4, 6]) == 4\nassert op_takewhilepos_trimends_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_sortabs_beforezero", "entry_point": "op_dropwhileneg_sortabs_beforezero", "primitives": ["dropwhileneg", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_dropwhileneg_sortabs_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_sortabs_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_sortabs_beforezero([]) == []\nassert op_dropwhileneg_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_sortabs_beforezero([10]) == [10]\nassert op_dropwhileneg_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_sortabs_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_clamp10_div3_neg", "entry_point": "op_clamp10_div3_neg", "primitives": ["clamp10", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep multiples of three, then keep the negative numbers.", "solution": "def op_clamp10_div3_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_div3_neg([1, 2, 3, 4]) == []\nassert op_clamp10_div3_neg([]) == []\nassert op_clamp10_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_div3_neg([5, 5, 5]) == []\nassert op_clamp10_div3_neg([3, 1, 2]) == []\nassert op_clamp10_div3_neg([10]) == []\nassert op_clamp10_div3_neg([2, 4, 6]) == []\nassert op_clamp10_div3_neg([-7, 12, -7]) == []"}
{"id": "op_uniq_gt5_sum", "entry_point": "op_uniq_gt5_sum", "primitives": ["uniq", "gt5", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then return their sum.", "solution": "def op_uniq_gt5_sum(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_uniq_gt5_sum([1, 2, 3, 4]) == 0\nassert op_uniq_gt5_sum([]) == 0\nassert op_uniq_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_gt5_sum([5, 5, 5]) == 0\nassert op_uniq_gt5_sum([3, 1, 2]) == 0\nassert op_uniq_gt5_sum([10]) == 10\nassert op_uniq_gt5_sum([2, 4, 6]) == 6\nassert op_uniq_gt5_sum([-7, 12, -7]) == 12"}
{"id": "op_add10_pos_prod", "entry_point": "op_add10_pos_prod", "primitives": ["add10", "pos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then return their product.", "solution": "def op_add10_pos_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_add10_pos_prod([1, 2, 3, 4]) == 24024\nassert op_add10_pos_prod([]) == 1\nassert op_add10_pos_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_pos_prod([5, 5, 5]) == 3375\nassert op_add10_pos_prod([3, 1, 2]) == 1716\nassert op_add10_pos_prod([10]) == 20\nassert op_add10_pos_prod([2, 4, 6]) == 2688\nassert op_add10_pos_prod([-7, 12, -7]) == 198"}
{"id": "op_div3_negate_firsteven", "entry_point": "op_div3_negate_firsteven", "primitives": ["div3", "negate", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then return the first even value (0 if none).", "solution": "def op_div3_negate_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_negate_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_negate_firsteven([]) == 0\nassert op_div3_negate_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_negate_firsteven([5, 5, 5]) == 0\nassert op_div3_negate_firsteven([3, 1, 2]) == 0\nassert op_div3_negate_firsteven([10]) == 0\nassert op_div3_negate_firsteven([2, 4, 6]) == -6\nassert op_div3_negate_firsteven([-7, 12, -7]) == -12"}
{"id": "op_div3_sorta_haszero", "entry_point": "op_div3_sorta_haszero", "primitives": ["div3", "sorta", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending, then return whether the list contains a zero.", "solution": "def op_div3_sorta_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return 0 in r", "tests": "assert op_div3_sorta_haszero([1, 2, 3, 4]) == False\nassert op_div3_sorta_haszero([]) == False\nassert op_div3_sorta_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_sorta_haszero([5, 5, 5]) == False\nassert op_div3_sorta_haszero([3, 1, 2]) == False\nassert op_div3_sorta_haszero([10]) == False\nassert op_div3_sorta_haszero([2, 4, 6]) == False\nassert op_div3_sorta_haszero([-7, 12, -7]) == False"}
{"id": "op_neg_last3_firsteven", "entry_point": "op_neg_last3_firsteven", "primitives": ["neg", "last3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then return the first even value (0 if none).", "solution": "def op_neg_last3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_last3_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_last3_firsteven([]) == 0\nassert op_neg_last3_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_neg_last3_firsteven([5, 5, 5]) == 0\nassert op_neg_last3_firsteven([3, 1, 2]) == 0\nassert op_neg_last3_firsteven([10]) == 0\nassert op_neg_last3_firsteven([2, 4, 6]) == 0\nassert op_neg_last3_firsteven([-7, 12, -7]) == 0"}
{"id": "op_uniq_dropzeros_min", "entry_point": "op_uniq_dropzeros_min", "primitives": ["uniq", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_uniq_dropzeros_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_uniq_dropzeros_min([1, 2, 3, 4]) == 1\nassert op_uniq_dropzeros_min([]) == 0\nassert op_uniq_dropzeros_min([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_dropzeros_min([5, 5, 5]) == 5\nassert op_uniq_dropzeros_min([3, 1, 2]) == 1\nassert op_uniq_dropzeros_min([10]) == 10\nassert op_uniq_dropzeros_min([2, 4, 6]) == 2\nassert op_uniq_dropzeros_min([-7, 12, -7]) == -7"}
{"id": "op_dropzeros_uniq_haszero", "entry_point": "op_dropzeros_uniq_haszero", "primitives": ["dropzeros", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_dropzeros_uniq_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_dropzeros_uniq_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_uniq_haszero([]) == False\nassert op_dropzeros_uniq_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_uniq_haszero([5, 5, 5]) == False\nassert op_dropzeros_uniq_haszero([3, 1, 2]) == False\nassert op_dropzeros_uniq_haszero([10]) == False\nassert op_dropzeros_uniq_haszero([2, 4, 6]) == False\nassert op_dropzeros_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_takewhilepos_max", "entry_point": "op_uniq_takewhilepos_max", "primitives": ["uniq", "takewhilepos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_uniq_takewhilepos_max(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_uniq_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_uniq_takewhilepos_max([]) == 0\nassert op_uniq_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_takewhilepos_max([5, 5, 5]) == 5\nassert op_uniq_takewhilepos_max([3, 1, 2]) == 3\nassert op_uniq_takewhilepos_max([10]) == 10\nassert op_uniq_takewhilepos_max([2, 4, 6]) == 6\nassert op_uniq_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_beforezero_clamp10_firsteven", "entry_point": "op_beforezero_clamp10_firsteven", "primitives": ["beforezero", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_beforezero_clamp10_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_clamp10_firsteven([]) == 0\nassert op_beforezero_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_clamp10_firsteven([5, 5, 5]) == 0\nassert op_beforezero_clamp10_firsteven([3, 1, 2]) == 2\nassert op_beforezero_clamp10_firsteven([10]) == 10\nassert op_beforezero_clamp10_firsteven([2, 4, 6]) == 2\nassert op_beforezero_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_dropwhileneg_takewhilepos_issorted", "entry_point": "op_dropwhileneg_takewhilepos_issorted", "primitives": ["dropwhileneg", "takewhilepos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_takewhilepos_issorted([]) == True\nassert op_dropwhileneg_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_takewhilepos_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_takewhilepos_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_takewhilepos_issorted([10]) == True\nassert op_dropwhileneg_takewhilepos_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_add10_last3_sum", "entry_point": "op_add10_last3_sum", "primitives": ["add10", "last3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return their sum.", "solution": "def op_add10_last3_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_add10_last3_sum([1, 2, 3, 4]) == 39\nassert op_add10_last3_sum([]) == 0\nassert op_add10_last3_sum([-2, -1, 0, 1, 2]) == 33\nassert op_add10_last3_sum([5, 5, 5]) == 45\nassert op_add10_last3_sum([3, 1, 2]) == 36\nassert op_add10_last3_sum([10]) == 20\nassert op_add10_last3_sum([2, 4, 6]) == 42\nassert op_add10_last3_sum([-7, 12, -7]) == 28"}
{"id": "op_absval_add10_sum", "entry_point": "op_absval_add10_sum", "primitives": ["absval", "add10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then return their sum.", "solution": "def op_absval_add10_sum(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_absval_add10_sum([1, 2, 3, 4]) == 50\nassert op_absval_add10_sum([]) == 0\nassert op_absval_add10_sum([-2, -1, 0, 1, 2]) == 56\nassert op_absval_add10_sum([5, 5, 5]) == 45\nassert op_absval_add10_sum([3, 1, 2]) == 36\nassert op_absval_add10_sum([10]) == 20\nassert op_absval_add10_sum([2, 4, 6]) == 42\nassert op_absval_add10_sum([-7, 12, -7]) == 56"}
{"id": "op_uniq_dropfirst_last3", "entry_point": "op_uniq_dropfirst_last3", "primitives": ["uniq", "dropfirst", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then keep only the last three.", "solution": "def op_uniq_dropfirst_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_dropfirst_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_dropfirst_last3([]) == []\nassert op_uniq_dropfirst_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_dropfirst_last3([5, 5, 5]) == []\nassert op_uniq_dropfirst_last3([3, 1, 2]) == [1, 2]\nassert op_uniq_dropfirst_last3([10]) == []\nassert op_uniq_dropfirst_last3([2, 4, 6]) == [4, 6]\nassert op_uniq_dropfirst_last3([-7, 12, -7]) == [12]"}
{"id": "op_ages_rev_clamp10", "entry_point": "op_ages_rev_clamp10", "primitives": ["ages", "rev", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then cap each value at 10.", "solution": "def op_ages_rev_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_rev_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_rev_clamp10([]) == []\nassert op_ages_rev_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_rev_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_sortabs_takewhilepos_sortd", "entry_point": "op_sortabs_takewhilepos_sortd", "primitives": ["sortabs", "takewhilepos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then sort descending.", "solution": "def op_sortabs_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortabs_takewhilepos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_takewhilepos_sortd([]) == []\nassert op_sortabs_takewhilepos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_takewhilepos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_takewhilepos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_takewhilepos_sortd([10]) == [10]\nassert op_sortabs_takewhilepos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_takewhilepos_sortd([-7, 12, -7]) == []"}
{"id": "op_last3_div3_sorta", "entry_point": "op_last3_div3_sorta", "primitives": ["last3", "div3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then sort ascending.", "solution": "def op_last3_div3_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_div3_sorta([1, 2, 3, 4]) == [3]\nassert op_last3_div3_sorta([]) == []\nassert op_last3_div3_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_div3_sorta([5, 5, 5]) == []\nassert op_last3_div3_sorta([3, 1, 2]) == [3]\nassert op_last3_div3_sorta([10]) == []\nassert op_last3_div3_sorta([2, 4, 6]) == [6]\nassert op_last3_div3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_last3_pos_padto3", "entry_point": "op_last3_pos_padto3", "primitives": ["last3", "pos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers, then pad with zeros to at least three elements.", "solution": "def op_last3_pos_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_pos_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_pos_padto3([]) == [0, 0, 0]\nassert op_last3_pos_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_last3_pos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_pos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_last3_pos_padto3([10]) == [10, 0, 0]\nassert op_last3_pos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_pos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sortd_evens_add10", "entry_point": "op_sortd_evens_add10", "primitives": ["sortd", "evens", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then add ten to each.", "solution": "def op_sortd_evens_add10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortd_evens_add10([1, 2, 3, 4]) == [14, 12]\nassert op_sortd_evens_add10([]) == []\nassert op_sortd_evens_add10([-2, -1, 0, 1, 2]) == [12, 10, 8]\nassert op_sortd_evens_add10([5, 5, 5]) == []\nassert op_sortd_evens_add10([3, 1, 2]) == [12]\nassert op_sortd_evens_add10([10]) == [20]\nassert op_sortd_evens_add10([2, 4, 6]) == [16, 14, 12]\nassert op_sortd_evens_add10([-7, 12, -7]) == [22]"}
{"id": "op_dec_beforezero_dropfirst", "entry_point": "op_dec_beforezero_dropfirst", "primitives": ["dec", "beforezero", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then drop the first element.", "solution": "def op_dec_beforezero_dropfirst(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return r", "tests": "assert op_dec_beforezero_dropfirst([1, 2, 3, 4]) == []\nassert op_dec_beforezero_dropfirst([]) == []\nassert op_dec_beforezero_dropfirst([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_dec_beforezero_dropfirst([5, 5, 5]) == [4, 4]\nassert op_dec_beforezero_dropfirst([3, 1, 2]) == []\nassert op_dec_beforezero_dropfirst([10]) == []\nassert op_dec_beforezero_dropfirst([2, 4, 6]) == [3, 5]\nassert op_dec_beforezero_dropfirst([-7, 12, -7]) == [11, -8]"}
{"id": "op_neg_trimends_haszero", "entry_point": "op_neg_trimends_haszero", "primitives": ["neg", "trimends", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then return whether the list contains a zero.", "solution": "def op_neg_trimends_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return 0 in r", "tests": "assert op_neg_trimends_haszero([1, 2, 3, 4]) == False\nassert op_neg_trimends_haszero([]) == False\nassert op_neg_trimends_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_trimends_haszero([5, 5, 5]) == False\nassert op_neg_trimends_haszero([3, 1, 2]) == False\nassert op_neg_trimends_haszero([10]) == False\nassert op_neg_trimends_haszero([2, 4, 6]) == False\nassert op_neg_trimends_haszero([-7, 12, -7]) == False"}
{"id": "op_beforezero_negate_allpos", "entry_point": "op_beforezero_negate_allpos", "primitives": ["beforezero", "negate", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then return whether all values are positive.", "solution": "def op_beforezero_negate_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_negate_allpos([1, 2, 3, 4]) == False\nassert op_beforezero_negate_allpos([]) == True\nassert op_beforezero_negate_allpos([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_negate_allpos([5, 5, 5]) == False\nassert op_beforezero_negate_allpos([3, 1, 2]) == False\nassert op_beforezero_negate_allpos([10]) == False\nassert op_beforezero_negate_allpos([2, 4, 6]) == False\nassert op_beforezero_negate_allpos([-7, 12, -7]) == False"}
{"id": "op_dropzeros_dropwhileneg_dropfirst", "entry_point": "op_dropzeros_dropwhileneg_dropfirst", "primitives": ["dropzeros", "dropwhileneg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then drop the first element.", "solution": "def op_dropzeros_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropwhileneg_dropfirst([]) == []\nassert op_dropzeros_dropwhileneg_dropfirst([-2, -1, 0, 1, 2]) == [2]\nassert op_dropzeros_dropwhileneg_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropwhileneg_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropwhileneg_dropfirst([10]) == []\nassert op_dropzeros_dropwhileneg_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropwhileneg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_dropwhileneg_sorta_dropzeros", "entry_point": "op_dropwhileneg_sorta_dropzeros", "primitives": ["dropwhileneg", "sorta", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort ascending, then drop the zeros.", "solution": "def op_dropwhileneg_sorta_dropzeros(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropwhileneg_sorta_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_sorta_dropzeros([]) == []\nassert op_dropwhileneg_sorta_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_sorta_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sorta_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_sorta_dropzeros([10]) == [10]\nassert op_dropwhileneg_sorta_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_sorta_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_trimends_inc_min", "entry_point": "op_trimends_inc_min", "primitives": ["trimends", "inc", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then return the minimum (0 if empty).", "solution": "def op_trimends_inc_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_trimends_inc_min([1, 2, 3, 4]) == 3\nassert op_trimends_inc_min([]) == 0\nassert op_trimends_inc_min([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_inc_min([5, 5, 5]) == 6\nassert op_trimends_inc_min([3, 1, 2]) == 2\nassert op_trimends_inc_min([10]) == 0\nassert op_trimends_inc_min([2, 4, 6]) == 5\nassert op_trimends_inc_min([-7, 12, -7]) == 13"}
{"id": "op_last3_negate_div3", "entry_point": "op_last3_negate_div3", "primitives": ["last3", "negate", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then keep multiples of three.", "solution": "def op_last3_negate_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_negate_div3([1, 2, 3, 4]) == [-3]\nassert op_last3_negate_div3([]) == []\nassert op_last3_negate_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_negate_div3([5, 5, 5]) == []\nassert op_last3_negate_div3([3, 1, 2]) == [-3]\nassert op_last3_negate_div3([10]) == []\nassert op_last3_negate_div3([2, 4, 6]) == [-6]\nassert op_last3_negate_div3([-7, 12, -7]) == [-12]"}
{"id": "op_gt5_inc_oremptyzero", "entry_point": "op_gt5_inc_oremptyzero", "primitives": ["gt5", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then if empty, use a single zero.", "solution": "def op_gt5_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_inc_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_inc_oremptyzero([]) == [0]\nassert op_gt5_inc_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_inc_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_inc_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_inc_oremptyzero([10]) == [11]\nassert op_gt5_inc_oremptyzero([2, 4, 6]) == [7]\nassert op_gt5_inc_oremptyzero([-7, 12, -7]) == [13]"}
{"id": "op_takewhilepos_oremptyzero_inc", "entry_point": "op_takewhilepos_oremptyzero_inc", "primitives": ["takewhilepos", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then add one to each.", "solution": "def op_takewhilepos_oremptyzero_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_takewhilepos_oremptyzero_inc([]) == [1]\nassert op_takewhilepos_oremptyzero_inc([-2, -1, 0, 1, 2]) == [1]\nassert op_takewhilepos_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_takewhilepos_oremptyzero_inc([10]) == [11]\nassert op_takewhilepos_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_oremptyzero_inc([-7, 12, -7]) == [1]"}
{"id": "op_takewhilepos_neg_gt5", "entry_point": "op_takewhilepos_neg_gt5", "primitives": ["takewhilepos", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then keep values greater than five.", "solution": "def op_takewhilepos_neg_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_neg_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_neg_gt5([]) == []\nassert op_takewhilepos_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_neg_gt5([5, 5, 5]) == []\nassert op_takewhilepos_neg_gt5([3, 1, 2]) == []\nassert op_takewhilepos_neg_gt5([10]) == []\nassert op_takewhilepos_neg_gt5([2, 4, 6]) == []\nassert op_takewhilepos_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_last3_takewhilepos_dropwhileneg", "entry_point": "op_last3_takewhilepos_dropwhileneg", "primitives": ["last3", "takewhilepos", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then drop the leading negative values.", "solution": "def op_last3_takewhilepos_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_takewhilepos_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_takewhilepos_dropwhileneg([]) == []\nassert op_last3_takewhilepos_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_last3_takewhilepos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_last3_takewhilepos_dropwhileneg([10]) == [10]\nassert op_last3_takewhilepos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_last3_takewhilepos_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_div3_beforezero_first3", "entry_point": "op_div3_beforezero_first3", "primitives": ["div3", "beforezero", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then keep only the first three.", "solution": "def op_div3_beforezero_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return r", "tests": "assert op_div3_beforezero_first3([1, 2, 3, 4]) == [3]\nassert op_div3_beforezero_first3([]) == []\nassert op_div3_beforezero_first3([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_first3([5, 5, 5]) == []\nassert op_div3_beforezero_first3([3, 1, 2]) == [3]\nassert op_div3_beforezero_first3([10]) == []\nassert op_div3_beforezero_first3([2, 4, 6]) == [6]\nassert op_div3_beforezero_first3([-7, 12, -7]) == [12]"}
{"id": "op_double_add10_evens", "entry_point": "op_double_add10_evens", "primitives": ["double", "add10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then keep the even numbers.", "solution": "def op_double_add10_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_add10_evens([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_add10_evens([]) == []\nassert op_double_add10_evens([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_double_add10_evens([5, 5, 5]) == [20, 20, 20]\nassert op_double_add10_evens([3, 1, 2]) == [16, 12, 14]\nassert op_double_add10_evens([10]) == [30]\nassert op_double_add10_evens([2, 4, 6]) == [14, 18, 22]\nassert op_double_add10_evens([-7, 12, -7]) == [-4, 34, -4]"}
{"id": "op_dropwhileneg_absval_issorted", "entry_point": "op_dropwhileneg_absval_issorted", "primitives": ["dropwhileneg", "absval", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_absval_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_absval_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_absval_issorted([]) == True\nassert op_dropwhileneg_absval_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_absval_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_absval_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_absval_issorted([10]) == True\nassert op_dropwhileneg_absval_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_absval_issorted([-7, 12, -7]) == False"}
{"id": "op_padto3_gt5_haszero", "entry_point": "op_padto3_gt5_haszero", "primitives": ["padto3", "gt5", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then return whether the list contains a zero.", "solution": "def op_padto3_gt5_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_padto3_gt5_haszero([1, 2, 3, 4]) == False\nassert op_padto3_gt5_haszero([]) == False\nassert op_padto3_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_padto3_gt5_haszero([5, 5, 5]) == False\nassert op_padto3_gt5_haszero([3, 1, 2]) == False\nassert op_padto3_gt5_haszero([10]) == False\nassert op_padto3_gt5_haszero([2, 4, 6]) == False\nassert op_padto3_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_dropzeros_sum", "entry_point": "op_padto3_dropzeros_sum", "primitives": ["padto3", "dropzeros", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros, then return their sum.", "solution": "def op_padto3_dropzeros_sum(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_padto3_dropzeros_sum([1, 2, 3, 4]) == 10\nassert op_padto3_dropzeros_sum([]) == 0\nassert op_padto3_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_dropzeros_sum([5, 5, 5]) == 15\nassert op_padto3_dropzeros_sum([3, 1, 2]) == 6\nassert op_padto3_dropzeros_sum([10]) == 10\nassert op_padto3_dropzeros_sum([2, 4, 6]) == 12\nassert op_padto3_dropzeros_sum([-7, 12, -7]) == -2"}
{"id": "op_absval_last3_first3", "entry_point": "op_absval_last3_first3", "primitives": ["absval", "last3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then keep only the first three.", "solution": "def op_absval_last3_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_absval_last3_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_last3_first3([]) == []\nassert op_absval_last3_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_last3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_last3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_last3_first3([10]) == [10]\nassert op_absval_last3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_last3_first3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_add10_odds_max", "entry_point": "op_add10_odds_max", "primitives": ["add10", "odds", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then return the maximum (0 if empty).", "solution": "def op_add10_odds_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return max(r) if r else 0", "tests": "assert op_add10_odds_max([1, 2, 3, 4]) == 13\nassert op_add10_odds_max([]) == 0\nassert op_add10_odds_max([-2, -1, 0, 1, 2]) == 11\nassert op_add10_odds_max([5, 5, 5]) == 15\nassert op_add10_odds_max([3, 1, 2]) == 13\nassert op_add10_odds_max([10]) == 0\nassert op_add10_odds_max([2, 4, 6]) == 0\nassert op_add10_odds_max([-7, 12, -7]) == 3"}
{"id": "op_double_trimends_haszero", "entry_point": "op_double_trimends_haszero", "primitives": ["double", "trimends", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then return whether the list contains a zero.", "solution": "def op_double_trimends_haszero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return 0 in r", "tests": "assert op_double_trimends_haszero([1, 2, 3, 4]) == False\nassert op_double_trimends_haszero([]) == False\nassert op_double_trimends_haszero([-2, -1, 0, 1, 2]) == True\nassert op_double_trimends_haszero([5, 5, 5]) == False\nassert op_double_trimends_haszero([3, 1, 2]) == False\nassert op_double_trimends_haszero([10]) == False\nassert op_double_trimends_haszero([2, 4, 6]) == False\nassert op_double_trimends_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_negate_dropfirst", "entry_point": "op_sorta_negate_dropfirst", "primitives": ["sorta", "negate", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then drop the first element.", "solution": "def op_sorta_negate_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sorta_negate_dropfirst([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_sorta_negate_dropfirst([]) == []\nassert op_sorta_negate_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_sorta_negate_dropfirst([5, 5, 5]) == [-5, -5]\nassert op_sorta_negate_dropfirst([3, 1, 2]) == [-2, -3]\nassert op_sorta_negate_dropfirst([10]) == []\nassert op_sorta_negate_dropfirst([2, 4, 6]) == [-4, -6]\nassert op_sorta_negate_dropfirst([-7, 12, -7]) == [7, -12]"}
{"id": "op_clamp10_gt5_square", "entry_point": "op_clamp10_gt5_square", "primitives": ["clamp10", "gt5", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five, then square each.", "solution": "def op_clamp10_gt5_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_gt5_square([1, 2, 3, 4]) == []\nassert op_clamp10_gt5_square([]) == []\nassert op_clamp10_gt5_square([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_gt5_square([5, 5, 5]) == []\nassert op_clamp10_gt5_square([3, 1, 2]) == []\nassert op_clamp10_gt5_square([10]) == [100]\nassert op_clamp10_gt5_square([2, 4, 6]) == [36]\nassert op_clamp10_gt5_square([-7, 12, -7]) == [100]"}
{"id": "op_trimends_add10_gt5", "entry_point": "op_trimends_add10_gt5", "primitives": ["trimends", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then keep values greater than five.", "solution": "def op_trimends_add10_gt5(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_trimends_add10_gt5([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_add10_gt5([]) == []\nassert op_trimends_add10_gt5([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10_gt5([5, 5, 5]) == [15]\nassert op_trimends_add10_gt5([3, 1, 2]) == [11]\nassert op_trimends_add10_gt5([10]) == []\nassert op_trimends_add10_gt5([2, 4, 6]) == [14]\nassert op_trimends_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_pos_double_allpos", "entry_point": "op_pos_double_allpos", "primitives": ["pos", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then return whether all values are positive.", "solution": "def op_pos_double_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_pos_double_allpos([1, 2, 3, 4]) == True\nassert op_pos_double_allpos([]) == True\nassert op_pos_double_allpos([-2, -1, 0, 1, 2]) == True\nassert op_pos_double_allpos([5, 5, 5]) == True\nassert op_pos_double_allpos([3, 1, 2]) == True\nassert op_pos_double_allpos([10]) == True\nassert op_pos_double_allpos([2, 4, 6]) == True\nassert op_pos_double_allpos([-7, 12, -7]) == True"}
{"id": "op_sortabs_square_dec", "entry_point": "op_sortabs_square_dec", "primitives": ["sortabs", "square", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then subtract one from each.", "solution": "def op_sortabs_square_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_square_dec([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_sortabs_square_dec([]) == []\nassert op_sortabs_square_dec([-2, -1, 0, 1, 2]) == [-1, 0, 0, 3, 3]\nassert op_sortabs_square_dec([5, 5, 5]) == [24, 24, 24]\nassert op_sortabs_square_dec([3, 1, 2]) == [0, 3, 8]\nassert op_sortabs_square_dec([10]) == [99]\nassert op_sortabs_square_dec([2, 4, 6]) == [3, 15, 35]\nassert op_sortabs_square_dec([-7, 12, -7]) == [48, 48, 143]"}
{"id": "op_dropwhileneg_evens_max", "entry_point": "op_dropwhileneg_evens_max", "primitives": ["dropwhileneg", "evens", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_evens_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_evens_max([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_evens_max([]) == 0\nassert op_dropwhileneg_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_evens_max([5, 5, 5]) == 0\nassert op_dropwhileneg_evens_max([3, 1, 2]) == 2\nassert op_dropwhileneg_evens_max([10]) == 10\nassert op_dropwhileneg_evens_max([2, 4, 6]) == 6\nassert op_dropwhileneg_evens_max([-7, 12, -7]) == 12"}
{"id": "op_nonempty_sortlen_dropshort", "entry_point": "op_nonempty_sortlen_dropshort", "primitives": ["nonempty", "sortlen", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort by length, shortest first, then drop strings shorter than three characters.", "solution": "def op_nonempty_sortlen_dropshort(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_nonempty_sortlen_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_sortlen_dropshort([]) == []\nassert op_nonempty_sortlen_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_nonempty_sortlen_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'Two']\nassert op_nonempty_sortlen_dropshort(['x']) == []\nassert op_nonempty_sortlen_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_sortd_square_sortabs", "entry_point": "op_sortd_square_sortabs", "primitives": ["sortd", "square", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then sort by absolute value.", "solution": "def op_sortd_square_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortd_square_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortd_square_sortabs([]) == []\nassert op_sortd_square_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sortd_square_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_sortd_square_sortabs([10]) == [100]\nassert op_sortd_square_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_sortd_square_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_negate_last3_add10", "entry_point": "op_negate_last3_add10", "primitives": ["negate", "last3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then add ten to each.", "solution": "def op_negate_last3_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_last3_add10([1, 2, 3, 4]) == [8, 7, 6]\nassert op_negate_last3_add10([]) == []\nassert op_negate_last3_add10([-2, -1, 0, 1, 2]) == [10, 9, 8]\nassert op_negate_last3_add10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_last3_add10([3, 1, 2]) == [7, 9, 8]\nassert op_negate_last3_add10([10]) == [0]\nassert op_negate_last3_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_last3_add10([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_dropfirst_last3_pos", "entry_point": "op_dropfirst_last3_pos", "primitives": ["dropfirst", "last3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then keep the positive numbers.", "solution": "def op_dropfirst_last3_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_last3_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_last3_pos([]) == []\nassert op_dropfirst_last3_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropfirst_last3_pos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_last3_pos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_last3_pos([10]) == []\nassert op_dropfirst_last3_pos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_last3_pos([-7, 12, -7]) == [12]"}
{"id": "op_add10_trimends_sortabs", "entry_point": "op_add10_trimends_sortabs", "primitives": ["add10", "trimends", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then sort by absolute value.", "solution": "def op_add10_trimends_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_trimends_sortabs([1, 2, 3, 4]) == [12, 13]\nassert op_add10_trimends_sortabs([]) == []\nassert op_add10_trimends_sortabs([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_trimends_sortabs([5, 5, 5]) == [15]\nassert op_add10_trimends_sortabs([3, 1, 2]) == [11]\nassert op_add10_trimends_sortabs([10]) == []\nassert op_add10_trimends_sortabs([2, 4, 6]) == [14]\nassert op_add10_trimends_sortabs([-7, 12, -7]) == [22]"}
{"id": "op_clamp10_pos_rev", "entry_point": "op_clamp10_pos_rev", "primitives": ["clamp10", "pos", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the positive numbers, then reverse the order.", "solution": "def op_clamp10_pos_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_pos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_pos_rev([]) == []\nassert op_clamp10_pos_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_pos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_pos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_pos_rev([10]) == [10]\nassert op_clamp10_pos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_pos_rev([-7, 12, -7]) == [10]"}
{"id": "op_dropzeros_pos_alldistinct", "entry_point": "op_dropzeros_pos_alldistinct", "primitives": ["dropzeros", "pos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the positive numbers, then return whether all values are distinct.", "solution": "def op_dropzeros_pos_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropzeros_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_dropzeros_pos_alldistinct([]) == True\nassert op_dropzeros_pos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_pos_alldistinct([5, 5, 5]) == False\nassert op_dropzeros_pos_alldistinct([3, 1, 2]) == True\nassert op_dropzeros_pos_alldistinct([10]) == True\nassert op_dropzeros_pos_alldistinct([2, 4, 6]) == True\nassert op_dropzeros_pos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_double_takewhilepos_first3", "entry_point": "op_double_takewhilepos_first3", "primitives": ["double", "takewhilepos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then keep only the first three.", "solution": "def op_double_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_double_takewhilepos_first3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_takewhilepos_first3([]) == []\nassert op_double_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos_first3([5, 5, 5]) == [10, 10, 10]\nassert op_double_takewhilepos_first3([3, 1, 2]) == [6, 2, 4]\nassert op_double_takewhilepos_first3([10]) == [20]\nassert op_double_takewhilepos_first3([2, 4, 6]) == [4, 8, 12]\nassert op_double_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_dec_dropfirst_gt5", "entry_point": "op_dec_dropfirst_gt5", "primitives": ["dec", "dropfirst", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first element, then keep values greater than five.", "solution": "def op_dec_dropfirst_gt5(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dec_dropfirst_gt5([1, 2, 3, 4]) == []\nassert op_dec_dropfirst_gt5([]) == []\nassert op_dec_dropfirst_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dec_dropfirst_gt5([5, 5, 5]) == []\nassert op_dec_dropfirst_gt5([3, 1, 2]) == []\nassert op_dec_dropfirst_gt5([10]) == []\nassert op_dec_dropfirst_gt5([2, 4, 6]) == []\nassert op_dec_dropfirst_gt5([-7, 12, -7]) == [11]"}
{"id": "op_dropfirst_pos_padto3", "entry_point": "op_dropfirst_pos_padto3", "primitives": ["dropfirst", "pos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_pos_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_pos_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_pos_padto3([]) == [0, 0, 0]\nassert op_dropfirst_pos_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_pos_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_pos_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_pos_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_pos_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_pos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_double_inc_anyeven", "entry_point": "op_double_inc_anyeven", "primitives": ["double", "inc", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each, then return whether any value is even.", "solution": "def op_double_inc_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_inc_anyeven([1, 2, 3, 4]) == False\nassert op_double_inc_anyeven([]) == False\nassert op_double_inc_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_double_inc_anyeven([5, 5, 5]) == False\nassert op_double_inc_anyeven([3, 1, 2]) == False\nassert op_double_inc_anyeven([10]) == False\nassert op_double_inc_anyeven([2, 4, 6]) == False\nassert op_double_inc_anyeven([-7, 12, -7]) == False"}
{"id": "op_dropfirst_odds_dropwhileneg", "entry_point": "op_dropfirst_odds_dropwhileneg", "primitives": ["dropfirst", "odds", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_dropfirst_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_odds_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_dropfirst_odds_dropwhileneg([]) == []\nassert op_dropfirst_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_odds_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_dropfirst_odds_dropwhileneg([3, 1, 2]) == [1]\nassert op_dropfirst_odds_dropwhileneg([10]) == []\nassert op_dropfirst_odds_dropwhileneg([2, 4, 6]) == []\nassert op_dropfirst_odds_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_rev_absval_uniq", "entry_point": "op_rev_absval_uniq", "primitives": ["rev", "absval", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_rev_absval_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_absval_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_absval_uniq([]) == []\nassert op_rev_absval_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_absval_uniq([5, 5, 5]) == [5]\nassert op_rev_absval_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_absval_uniq([10]) == [10]\nassert op_rev_absval_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_absval_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_dropwhileneg_beforezero_last3", "entry_point": "op_dropwhileneg_beforezero_last3", "primitives": ["dropwhileneg", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero, then keep only the last three.", "solution": "def op_dropwhileneg_beforezero_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_beforezero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_beforezero_last3([]) == []\nassert op_dropwhileneg_beforezero_last3([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_beforezero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_beforezero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_beforezero_last3([10]) == [10]\nassert op_dropwhileneg_beforezero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_beforezero_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_oremptyzero_negate", "entry_point": "op_dropfirst_oremptyzero_negate", "primitives": ["dropfirst", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then negate each.", "solution": "def op_dropfirst_oremptyzero_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_oremptyzero_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropfirst_oremptyzero_negate([]) == [0]\nassert op_dropfirst_oremptyzero_negate([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_dropfirst_oremptyzero_negate([5, 5, 5]) == [-5, -5]\nassert op_dropfirst_oremptyzero_negate([3, 1, 2]) == [-1, -2]\nassert op_dropfirst_oremptyzero_negate([10]) == [0]\nassert op_dropfirst_oremptyzero_negate([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_oremptyzero_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_evens_rev_last3", "entry_point": "op_evens_rev_last3", "primitives": ["evens", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then keep only the last three.", "solution": "def op_evens_rev_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_evens_rev_last3([1, 2, 3, 4]) == [4, 2]\nassert op_evens_rev_last3([]) == []\nassert op_evens_rev_last3([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_rev_last3([5, 5, 5]) == []\nassert op_evens_rev_last3([3, 1, 2]) == [2]\nassert op_evens_rev_last3([10]) == [10]\nassert op_evens_rev_last3([2, 4, 6]) == [6, 4, 2]\nassert op_evens_rev_last3([-7, 12, -7]) == [12]"}
{"id": "op_add10_dropwhileneg_dropfirst", "entry_point": "op_add10_dropwhileneg_dropfirst", "primitives": ["add10", "dropwhileneg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then drop the first element.", "solution": "def op_add10_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_add10_dropwhileneg_dropfirst([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropwhileneg_dropfirst([]) == []\nassert op_add10_dropwhileneg_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_dropwhileneg_dropfirst([5, 5, 5]) == [15, 15]\nassert op_add10_dropwhileneg_dropfirst([3, 1, 2]) == [11, 12]\nassert op_add10_dropwhileneg_dropfirst([10]) == []\nassert op_add10_dropwhileneg_dropfirst([2, 4, 6]) == [14, 16]\nassert op_add10_dropwhileneg_dropfirst([-7, 12, -7]) == [22, 3]"}
{"id": "op_clamp10_pos_max", "entry_point": "op_clamp10_pos_max", "primitives": ["clamp10", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_clamp10_pos_max(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_clamp10_pos_max([1, 2, 3, 4]) == 4\nassert op_clamp10_pos_max([]) == 0\nassert op_clamp10_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_clamp10_pos_max([5, 5, 5]) == 5\nassert op_clamp10_pos_max([3, 1, 2]) == 3\nassert op_clamp10_pos_max([10]) == 10\nassert op_clamp10_pos_max([2, 4, 6]) == 6\nassert op_clamp10_pos_max([-7, 12, -7]) == 10"}
{"id": "op_absval_add10_len", "entry_point": "op_absval_add10_len", "primitives": ["absval", "add10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then return how many remain.", "solution": "def op_absval_add10_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_absval_add10_len([1, 2, 3, 4]) == 4\nassert op_absval_add10_len([]) == 0\nassert op_absval_add10_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_add10_len([5, 5, 5]) == 3\nassert op_absval_add10_len([3, 1, 2]) == 3\nassert op_absval_add10_len([10]) == 1\nassert op_absval_add10_len([2, 4, 6]) == 3\nassert op_absval_add10_len([-7, 12, -7]) == 3"}
{"id": "op_negate_beforezero_max", "entry_point": "op_negate_beforezero_max", "primitives": ["negate", "beforezero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_negate_beforezero_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_negate_beforezero_max([1, 2, 3, 4]) == -1\nassert op_negate_beforezero_max([]) == 0\nassert op_negate_beforezero_max([-2, -1, 0, 1, 2]) == 2\nassert op_negate_beforezero_max([5, 5, 5]) == -5\nassert op_negate_beforezero_max([3, 1, 2]) == -1\nassert op_negate_beforezero_max([10]) == -10\nassert op_negate_beforezero_max([2, 4, 6]) == -2\nassert op_negate_beforezero_max([-7, 12, -7]) == 7"}
{"id": "op_first3_uniq_rev", "entry_point": "op_first3_uniq_rev", "primitives": ["first3", "uniq", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_first3_uniq_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_uniq_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_uniq_rev([]) == []\nassert op_first3_uniq_rev([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_uniq_rev([5, 5, 5]) == [5]\nassert op_first3_uniq_rev([3, 1, 2]) == [2, 1, 3]\nassert op_first3_uniq_rev([10]) == [10]\nassert op_first3_uniq_rev([2, 4, 6]) == [6, 4, 2]\nassert op_first3_uniq_rev([-7, 12, -7]) == [12, -7]"}
{"id": "op_sorta_trimends_add10", "entry_point": "op_sorta_trimends_add10", "primitives": ["sorta", "trimends", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then add ten to each.", "solution": "def op_sorta_trimends_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_trimends_add10([1, 2, 3, 4]) == [12, 13]\nassert op_sorta_trimends_add10([]) == []\nassert op_sorta_trimends_add10([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_sorta_trimends_add10([5, 5, 5]) == [15]\nassert op_sorta_trimends_add10([3, 1, 2]) == [12]\nassert op_sorta_trimends_add10([10]) == []\nassert op_sorta_trimends_add10([2, 4, 6]) == [14]\nassert op_sorta_trimends_add10([-7, 12, -7]) == [3]"}
{"id": "op_takewhilepos_oremptyzero_sum", "entry_point": "op_takewhilepos_oremptyzero_sum", "primitives": ["takewhilepos", "oremptyzero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then return their sum.", "solution": "def op_takewhilepos_oremptyzero_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_takewhilepos_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_takewhilepos_oremptyzero_sum([]) == 0\nassert op_takewhilepos_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_oremptyzero_sum([5, 5, 5]) == 15\nassert op_takewhilepos_oremptyzero_sum([3, 1, 2]) == 6\nassert op_takewhilepos_oremptyzero_sum([10]) == 10\nassert op_takewhilepos_oremptyzero_sum([2, 4, 6]) == 12\nassert op_takewhilepos_oremptyzero_sum([-7, 12, -7]) == 0"}
{"id": "op_negate_div3_odds", "entry_point": "op_negate_div3_odds", "primitives": ["negate", "div3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then keep the odd numbers.", "solution": "def op_negate_div3_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_div3_odds([1, 2, 3, 4]) == [-3]\nassert op_negate_div3_odds([]) == []\nassert op_negate_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_negate_div3_odds([5, 5, 5]) == []\nassert op_negate_div3_odds([3, 1, 2]) == [-3]\nassert op_negate_div3_odds([10]) == []\nassert op_negate_div3_odds([2, 4, 6]) == []\nassert op_negate_div3_odds([-7, 12, -7]) == []"}
{"id": "op_rev_div3_anyeven", "entry_point": "op_rev_div3_anyeven", "primitives": ["rev", "div3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then return whether any value is even.", "solution": "def op_rev_div3_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_div3_anyeven([1, 2, 3, 4]) == False\nassert op_rev_div3_anyeven([]) == False\nassert op_rev_div3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_div3_anyeven([5, 5, 5]) == False\nassert op_rev_div3_anyeven([3, 1, 2]) == False\nassert op_rev_div3_anyeven([10]) == False\nassert op_rev_div3_anyeven([2, 4, 6]) == True\nassert op_rev_div3_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_inc_first3", "entry_point": "op_dropwhileneg_inc_first3", "primitives": ["dropwhileneg", "inc", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then keep only the first three.", "solution": "def op_dropwhileneg_inc_first3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropwhileneg_inc_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_inc_first3([]) == []\nassert op_dropwhileneg_inc_first3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_inc_first3([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_inc_first3([3, 1, 2]) == [4, 2, 3]\nassert op_dropwhileneg_inc_first3([10]) == [11]\nassert op_dropwhileneg_inc_first3([2, 4, 6]) == [3, 5, 7]\nassert op_dropwhileneg_inc_first3([-7, 12, -7]) == [13, -6]"}
{"id": "op_evens_square_takewhilepos", "entry_point": "op_evens_square_takewhilepos", "primitives": ["evens", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then take values while they are positive.", "solution": "def op_evens_square_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_evens_square_takewhilepos([1, 2, 3, 4]) == [4, 16]\nassert op_evens_square_takewhilepos([]) == []\nassert op_evens_square_takewhilepos([-2, -1, 0, 1, 2]) == [4]\nassert op_evens_square_takewhilepos([5, 5, 5]) == []\nassert op_evens_square_takewhilepos([3, 1, 2]) == [4]\nassert op_evens_square_takewhilepos([10]) == [100]\nassert op_evens_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_evens_square_takewhilepos([-7, 12, -7]) == [144]"}
{"id": "op_gt5_last3_oremptyzero", "entry_point": "op_gt5_last3_oremptyzero", "primitives": ["gt5", "last3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three, then if empty, use a single zero.", "solution": "def op_gt5_last3_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_last3_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_last3_oremptyzero([]) == [0]\nassert op_gt5_last3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_last3_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_last3_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_last3_oremptyzero([10]) == [10]\nassert op_gt5_last3_oremptyzero([2, 4, 6]) == [6]\nassert op_gt5_last3_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_uniq_sorta", "entry_point": "op_clamp10_uniq_sorta", "primitives": ["clamp10", "uniq", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then sort ascending.", "solution": "def op_clamp10_uniq_sorta(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return r", "tests": "assert op_clamp10_uniq_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_uniq_sorta([]) == []\nassert op_clamp10_uniq_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_uniq_sorta([5, 5, 5]) == [5]\nassert op_clamp10_uniq_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_uniq_sorta([10]) == [10]\nassert op_clamp10_uniq_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_uniq_sorta([-7, 12, -7]) == [-7, 10]"}
{"id": "op_dropfirst_last3_issorted", "entry_point": "op_dropfirst_last3_issorted", "primitives": ["dropfirst", "last3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_last3_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_dropfirst_last3_issorted([1, 2, 3, 4]) == True\nassert op_dropfirst_last3_issorted([]) == True\nassert op_dropfirst_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_last3_issorted([5, 5, 5]) == True\nassert op_dropfirst_last3_issorted([3, 1, 2]) == True\nassert op_dropfirst_last3_issorted([10]) == True\nassert op_dropfirst_last3_issorted([2, 4, 6]) == True\nassert op_dropfirst_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_ages_dropzeros_dropfirst", "entry_point": "op_ages_dropzeros_dropfirst", "primitives": ["ages", "dropzeros", "dropfirst"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros, then drop the first element.", "solution": "def op_ages_dropzeros_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return r", "tests": "assert op_ages_dropzeros_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropzeros_dropfirst([]) == []\nassert op_ages_dropzeros_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropzeros_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sortabs_evens_alldistinct", "entry_point": "op_sortabs_evens_alldistinct", "primitives": ["sortabs", "evens", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_sortabs_evens_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_evens_alldistinct([]) == True\nassert op_sortabs_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_evens_alldistinct([5, 5, 5]) == True\nassert op_sortabs_evens_alldistinct([3, 1, 2]) == True\nassert op_sortabs_evens_alldistinct([10]) == True\nassert op_sortabs_evens_alldistinct([2, 4, 6]) == True\nassert op_sortabs_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dec_beforezero_sortd", "entry_point": "op_dec_beforezero_sortd", "primitives": ["dec", "beforezero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then sort descending.", "solution": "def op_dec_beforezero_sortd(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dec_beforezero_sortd([1, 2, 3, 4]) == []\nassert op_dec_beforezero_sortd([]) == []\nassert op_dec_beforezero_sortd([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_dec_beforezero_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_dec_beforezero_sortd([3, 1, 2]) == [2]\nassert op_dec_beforezero_sortd([10]) == [9]\nassert op_dec_beforezero_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_dec_beforezero_sortd([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_square_inc_sum", "entry_point": "op_square_inc_sum", "primitives": ["square", "inc", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each, then return their sum.", "solution": "def op_square_inc_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_square_inc_sum([1, 2, 3, 4]) == 34\nassert op_square_inc_sum([]) == 0\nassert op_square_inc_sum([-2, -1, 0, 1, 2]) == 15\nassert op_square_inc_sum([5, 5, 5]) == 78\nassert op_square_inc_sum([3, 1, 2]) == 17\nassert op_square_inc_sum([10]) == 101\nassert op_square_inc_sum([2, 4, 6]) == 59\nassert op_square_inc_sum([-7, 12, -7]) == 245"}
{"id": "op_last3_add10_oremptyzero", "entry_point": "op_last3_add10_oremptyzero", "primitives": ["last3", "add10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then if empty, use a single zero.", "solution": "def op_last3_add10_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_add10_oremptyzero([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10_oremptyzero([]) == [0]\nassert op_last3_add10_oremptyzero([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_last3_add10_oremptyzero([10]) == [20]\nassert op_last3_add10_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_oremptyzero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_add10_oremptyzero_sum", "entry_point": "op_add10_oremptyzero_sum", "primitives": ["add10", "oremptyzero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then return their sum.", "solution": "def op_add10_oremptyzero_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_add10_oremptyzero_sum([1, 2, 3, 4]) == 50\nassert op_add10_oremptyzero_sum([]) == 0\nassert op_add10_oremptyzero_sum([-2, -1, 0, 1, 2]) == 50\nassert op_add10_oremptyzero_sum([5, 5, 5]) == 45\nassert op_add10_oremptyzero_sum([3, 1, 2]) == 36\nassert op_add10_oremptyzero_sum([10]) == 20\nassert op_add10_oremptyzero_sum([2, 4, 6]) == 42\nassert op_add10_oremptyzero_sum([-7, 12, -7]) == 28"}
{"id": "op_dropwhileneg_last3_square", "entry_point": "op_dropwhileneg_last3_square", "primitives": ["dropwhileneg", "last3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then square each.", "solution": "def op_dropwhileneg_last3_square(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropwhileneg_last3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropwhileneg_last3_square([]) == []\nassert op_dropwhileneg_last3_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropwhileneg_last3_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_last3_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_last3_square([10]) == [100]\nassert op_dropwhileneg_last3_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_last3_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_double_odds_issorted", "entry_point": "op_double_odds_issorted", "primitives": ["double", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_double_odds_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_double_odds_issorted([1, 2, 3, 4]) == True\nassert op_double_odds_issorted([]) == True\nassert op_double_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_odds_issorted([5, 5, 5]) == True\nassert op_double_odds_issorted([3, 1, 2]) == True\nassert op_double_odds_issorted([10]) == True\nassert op_double_odds_issorted([2, 4, 6]) == True\nassert op_double_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_odds_div3_len", "entry_point": "op_odds_div3_len", "primitives": ["odds", "div3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then return how many remain.", "solution": "def op_odds_div3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_odds_div3_len([1, 2, 3, 4]) == 1\nassert op_odds_div3_len([]) == 0\nassert op_odds_div3_len([-2, -1, 0, 1, 2]) == 0\nassert op_odds_div3_len([5, 5, 5]) == 0\nassert op_odds_div3_len([3, 1, 2]) == 1\nassert op_odds_div3_len([10]) == 0\nassert op_odds_div3_len([2, 4, 6]) == 0\nassert op_odds_div3_len([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_dropfirst_prod", "entry_point": "op_dropwhileneg_dropfirst_prod", "primitives": ["dropwhileneg", "dropfirst", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then return their product.", "solution": "def op_dropwhileneg_dropfirst_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_dropfirst_prod([1, 2, 3, 4]) == 24\nassert op_dropwhileneg_dropfirst_prod([]) == 1\nassert op_dropwhileneg_dropfirst_prod([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_dropfirst_prod([5, 5, 5]) == 25\nassert op_dropwhileneg_dropfirst_prod([3, 1, 2]) == 2\nassert op_dropwhileneg_dropfirst_prod([10]) == 1\nassert op_dropwhileneg_dropfirst_prod([2, 4, 6]) == 24\nassert op_dropwhileneg_dropfirst_prod([-7, 12, -7]) == -7"}
{"id": "op_neg_sorta_sortd", "entry_point": "op_neg_sorta_sortd", "primitives": ["neg", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then sort descending.", "solution": "def op_neg_sorta_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_neg_sorta_sortd([1, 2, 3, 4]) == []\nassert op_neg_sorta_sortd([]) == []\nassert op_neg_sorta_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_sorta_sortd([5, 5, 5]) == []\nassert op_neg_sorta_sortd([3, 1, 2]) == []\nassert op_neg_sorta_sortd([10]) == []\nassert op_neg_sorta_sortd([2, 4, 6]) == []\nassert op_neg_sorta_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_dec_min", "entry_point": "op_uniq_dec_min", "primitives": ["uniq", "dec", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_uniq_dec_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_uniq_dec_min([1, 2, 3, 4]) == 0\nassert op_uniq_dec_min([]) == 0\nassert op_uniq_dec_min([-2, -1, 0, 1, 2]) == -3\nassert op_uniq_dec_min([5, 5, 5]) == 4\nassert op_uniq_dec_min([3, 1, 2]) == 0\nassert op_uniq_dec_min([10]) == 9\nassert op_uniq_dec_min([2, 4, 6]) == 1\nassert op_uniq_dec_min([-7, 12, -7]) == -8"}
{"id": "op_clamp10_dec_sortd", "entry_point": "op_clamp10_dec_sortd", "primitives": ["clamp10", "dec", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then sort descending.", "solution": "def op_clamp10_dec_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_dec_sortd([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_clamp10_dec_sortd([]) == []\nassert op_clamp10_dec_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_clamp10_dec_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_clamp10_dec_sortd([3, 1, 2]) == [2, 1, 0]\nassert op_clamp10_dec_sortd([10]) == [9]\nassert op_clamp10_dec_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_clamp10_dec_sortd([-7, 12, -7]) == [9, -8, -8]"}
{"id": "op_odds_takewhilepos_first3", "entry_point": "op_odds_takewhilepos_first3", "primitives": ["odds", "takewhilepos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take values while they are positive, then keep only the first three.", "solution": "def op_odds_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_odds_takewhilepos_first3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_takewhilepos_first3([]) == []\nassert op_odds_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_odds_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_takewhilepos_first3([3, 1, 2]) == [3, 1]\nassert op_odds_takewhilepos_first3([10]) == []\nassert op_odds_takewhilepos_first3([2, 4, 6]) == []\nassert op_odds_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_trimends_negate_rev", "entry_point": "op_trimends_negate_rev", "primitives": ["trimends", "negate", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then reverse the order.", "solution": "def op_trimends_negate_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_negate_rev([1, 2, 3, 4]) == [-3, -2]\nassert op_trimends_negate_rev([]) == []\nassert op_trimends_negate_rev([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_negate_rev([5, 5, 5]) == [-5]\nassert op_trimends_negate_rev([3, 1, 2]) == [-1]\nassert op_trimends_negate_rev([10]) == []\nassert op_trimends_negate_rev([2, 4, 6]) == [-4]\nassert op_trimends_negate_rev([-7, 12, -7]) == [-12]"}
{"id": "op_inc_double_dec", "entry_point": "op_inc_double_dec", "primitives": ["inc", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then subtract one from each.", "solution": "def op_inc_double_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_double_dec([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_inc_double_dec([]) == []\nassert op_inc_double_dec([-2, -1, 0, 1, 2]) == [-3, -1, 1, 3, 5]\nassert op_inc_double_dec([5, 5, 5]) == [11, 11, 11]\nassert op_inc_double_dec([3, 1, 2]) == [7, 3, 5]\nassert op_inc_double_dec([10]) == [21]\nassert op_inc_double_dec([2, 4, 6]) == [5, 9, 13]\nassert op_inc_double_dec([-7, 12, -7]) == [-13, 25, -13]"}
{"id": "op_dropzeros_add10_gt5", "entry_point": "op_dropzeros_add10_gt5", "primitives": ["dropzeros", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then keep values greater than five.", "solution": "def op_dropzeros_add10_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropzeros_add10_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropzeros_add10_gt5([]) == []\nassert op_dropzeros_add10_gt5([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_dropzeros_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_dropzeros_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_dropzeros_add10_gt5([10]) == [20]\nassert op_dropzeros_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_sortabs_dec_square", "entry_point": "op_sortabs_dec_square", "primitives": ["sortabs", "dec", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then square each.", "solution": "def op_sortabs_dec_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_dec_square([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_sortabs_dec_square([]) == []\nassert op_sortabs_dec_square([-2, -1, 0, 1, 2]) == [1, 4, 0, 9, 1]\nassert op_sortabs_dec_square([5, 5, 5]) == [16, 16, 16]\nassert op_sortabs_dec_square([3, 1, 2]) == [0, 1, 4]\nassert op_sortabs_dec_square([10]) == [81]\nassert op_sortabs_dec_square([2, 4, 6]) == [1, 9, 25]\nassert op_sortabs_dec_square([-7, 12, -7]) == [64, 64, 121]"}
{"id": "op_sortage_ages_counteven", "entry_point": "op_sortage_ages_counteven", "primitives": ["sortage", "ages", "counteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then return how many values are even.", "solution": "def op_sortage_ages_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortage_ages_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_sortage_ages_counteven([]) == 0\nassert op_sortage_ages_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_sortage_ages_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_dropzeros_neg_odds", "entry_point": "op_dropzeros_neg_odds", "primitives": ["dropzeros", "neg", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_dropzeros_neg_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropzeros_neg_odds([1, 2, 3, 4]) == []\nassert op_dropzeros_neg_odds([]) == []\nassert op_dropzeros_neg_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropzeros_neg_odds([5, 5, 5]) == []\nassert op_dropzeros_neg_odds([3, 1, 2]) == []\nassert op_dropzeros_neg_odds([10]) == []\nassert op_dropzeros_neg_odds([2, 4, 6]) == []\nassert op_dropzeros_neg_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_uniq_firsteven", "entry_point": "op_evens_uniq_firsteven", "primitives": ["evens", "uniq", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_evens_uniq_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_evens_uniq_firsteven([1, 2, 3, 4]) == 2\nassert op_evens_uniq_firsteven([]) == 0\nassert op_evens_uniq_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_evens_uniq_firsteven([5, 5, 5]) == 0\nassert op_evens_uniq_firsteven([3, 1, 2]) == 2\nassert op_evens_uniq_firsteven([10]) == 10\nassert op_evens_uniq_firsteven([2, 4, 6]) == 2\nassert op_evens_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_first3_inc_evens", "entry_point": "op_first3_inc_evens", "primitives": ["first3", "inc", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then keep the even numbers.", "solution": "def op_first3_inc_evens(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_first3_inc_evens([1, 2, 3, 4]) == [2, 4]\nassert op_first3_inc_evens([]) == []\nassert op_first3_inc_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_inc_evens([5, 5, 5]) == [6, 6, 6]\nassert op_first3_inc_evens([3, 1, 2]) == [4, 2]\nassert op_first3_inc_evens([10]) == []\nassert op_first3_inc_evens([2, 4, 6]) == []\nassert op_first3_inc_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dropzeros_takewhilepos_anyeven", "entry_point": "op_dropzeros_takewhilepos_anyeven", "primitives": ["dropzeros", "takewhilepos", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then return whether any value is even.", "solution": "def op_dropzeros_takewhilepos_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_takewhilepos_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_takewhilepos_anyeven([]) == False\nassert op_dropzeros_takewhilepos_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_takewhilepos_anyeven([5, 5, 5]) == False\nassert op_dropzeros_takewhilepos_anyeven([3, 1, 2]) == True\nassert op_dropzeros_takewhilepos_anyeven([10]) == True\nassert op_dropzeros_takewhilepos_anyeven([2, 4, 6]) == True\nassert op_dropzeros_takewhilepos_anyeven([-7, 12, -7]) == False"}
{"id": "op_dropzeros_neg_allpos", "entry_point": "op_dropzeros_neg_allpos", "primitives": ["dropzeros", "neg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then return whether all values are positive.", "solution": "def op_dropzeros_neg_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dropzeros_neg_allpos([1, 2, 3, 4]) == True\nassert op_dropzeros_neg_allpos([]) == True\nassert op_dropzeros_neg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_neg_allpos([5, 5, 5]) == True\nassert op_dropzeros_neg_allpos([3, 1, 2]) == True\nassert op_dropzeros_neg_allpos([10]) == True\nassert op_dropzeros_neg_allpos([2, 4, 6]) == True\nassert op_dropzeros_neg_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_gt5_dropzeros", "entry_point": "op_last3_gt5_dropzeros", "primitives": ["last3", "gt5", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep values greater than five, then drop the zeros.", "solution": "def op_last3_gt5_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_last3_gt5_dropzeros([]) == []\nassert op_last3_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_last3_gt5_dropzeros([5, 5, 5]) == []\nassert op_last3_gt5_dropzeros([3, 1, 2]) == []\nassert op_last3_gt5_dropzeros([10]) == [10]\nassert op_last3_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_last3_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_evens_absval_odds", "entry_point": "op_evens_absval_odds", "primitives": ["evens", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_evens_absval_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_absval_odds([1, 2, 3, 4]) == []\nassert op_evens_absval_odds([]) == []\nassert op_evens_absval_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_absval_odds([5, 5, 5]) == []\nassert op_evens_absval_odds([3, 1, 2]) == []\nassert op_evens_absval_odds([10]) == []\nassert op_evens_absval_odds([2, 4, 6]) == []\nassert op_evens_absval_odds([-7, 12, -7]) == []"}
{"id": "op_sortabs_dropzeros_dropfirst", "entry_point": "op_sortabs_dropzeros_dropfirst", "primitives": ["sortabs", "dropzeros", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then drop the first element.", "solution": "def op_sortabs_dropzeros_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_dropzeros_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_dropzeros_dropfirst([]) == []\nassert op_sortabs_dropzeros_dropfirst([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_sortabs_dropzeros_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortabs_dropzeros_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sortabs_dropzeros_dropfirst([10]) == []\nassert op_sortabs_dropzeros_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sortabs_dropzeros_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_trimends_inc_dec", "entry_point": "op_trimends_inc_dec", "primitives": ["trimends", "inc", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then subtract one from each.", "solution": "def op_trimends_inc_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_inc_dec([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_inc_dec([]) == []\nassert op_trimends_inc_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_inc_dec([5, 5, 5]) == [5]\nassert op_trimends_inc_dec([3, 1, 2]) == [1]\nassert op_trimends_inc_dec([10]) == []\nassert op_trimends_inc_dec([2, 4, 6]) == [4]\nassert op_trimends_inc_dec([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_absval_allpos", "entry_point": "op_dropfirst_absval_allpos", "primitives": ["dropfirst", "absval", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_dropfirst_absval_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_absval_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_absval_allpos([]) == True\nassert op_dropfirst_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_absval_allpos([5, 5, 5]) == True\nassert op_dropfirst_absval_allpos([3, 1, 2]) == True\nassert op_dropfirst_absval_allpos([10]) == True\nassert op_dropfirst_absval_allpos([2, 4, 6]) == True\nassert op_dropfirst_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_uniq_sortd", "entry_point": "op_negate_uniq_sortd", "primitives": ["negate", "uniq", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_negate_uniq_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_uniq_sortd([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_uniq_sortd([]) == []\nassert op_negate_uniq_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_uniq_sortd([5, 5, 5]) == [-5]\nassert op_negate_uniq_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_uniq_sortd([10]) == [-10]\nassert op_negate_uniq_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_uniq_sortd([-7, 12, -7]) == [7, -12]"}
{"id": "op_sorta_uniq_inc", "entry_point": "op_sorta_uniq_inc", "primitives": ["sorta", "uniq", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_sorta_uniq_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_uniq_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_uniq_inc([]) == []\nassert op_sorta_uniq_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_sorta_uniq_inc([5, 5, 5]) == [6]\nassert op_sorta_uniq_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_uniq_inc([10]) == [11]\nassert op_sorta_uniq_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_uniq_inc([-7, 12, -7]) == [-6, 13]"}
{"id": "op_beforezero_absval_uniq", "entry_point": "op_beforezero_absval_uniq", "primitives": ["beforezero", "absval", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_absval_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_absval_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_absval_uniq([]) == []\nassert op_beforezero_absval_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_absval_uniq([5, 5, 5]) == [5]\nassert op_beforezero_absval_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_absval_uniq([10]) == [10]\nassert op_beforezero_absval_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_absval_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_dropfirst_add10_gt5", "entry_point": "op_dropfirst_add10_gt5", "primitives": ["dropfirst", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then keep values greater than five.", "solution": "def op_dropfirst_add10_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_add10_gt5([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_add10_gt5([]) == []\nassert op_dropfirst_add10_gt5([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_dropfirst_add10_gt5([5, 5, 5]) == [15, 15]\nassert op_dropfirst_add10_gt5([3, 1, 2]) == [11, 12]\nassert op_dropfirst_add10_gt5([10]) == []\nassert op_dropfirst_add10_gt5([2, 4, 6]) == [14, 16]\nassert op_dropfirst_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_trimends_padto3_last3", "entry_point": "op_trimends_padto3_last3", "primitives": ["trimends", "padto3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_trimends_padto3_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_padto3_last3([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_padto3_last3([]) == [0, 0, 0]\nassert op_trimends_padto3_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_padto3_last3([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_padto3_last3([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_padto3_last3([10]) == [0, 0, 0]\nassert op_trimends_padto3_last3([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_padto3_last3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_dropwhileneg_odds_rev", "entry_point": "op_dropwhileneg_odds_rev", "primitives": ["dropwhileneg", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then reverse the order.", "solution": "def op_dropwhileneg_odds_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_odds_rev([1, 2, 3, 4]) == [3, 1]\nassert op_dropwhileneg_odds_rev([]) == []\nassert op_dropwhileneg_odds_rev([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_odds_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_odds_rev([3, 1, 2]) == [1, 3]\nassert op_dropwhileneg_odds_rev([10]) == []\nassert op_dropwhileneg_odds_rev([2, 4, 6]) == []\nassert op_dropwhileneg_odds_rev([-7, 12, -7]) == [-7]"}
{"id": "op_neg_pos_counteven", "entry_point": "op_neg_pos_counteven", "primitives": ["neg", "pos", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers, then return how many values are even.", "solution": "def op_neg_pos_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_pos_counteven([1, 2, 3, 4]) == 0\nassert op_neg_pos_counteven([]) == 0\nassert op_neg_pos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_pos_counteven([5, 5, 5]) == 0\nassert op_neg_pos_counteven([3, 1, 2]) == 0\nassert op_neg_pos_counteven([10]) == 0\nassert op_neg_pos_counteven([2, 4, 6]) == 0\nassert op_neg_pos_counteven([-7, 12, -7]) == 0"}
{"id": "op_last3_sorta_trimends", "entry_point": "op_last3_sorta_trimends", "primitives": ["last3", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then drop the first and last elements.", "solution": "def op_last3_sorta_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_sorta_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_sorta_trimends([]) == []\nassert op_last3_sorta_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_sorta_trimends([5, 5, 5]) == [5]\nassert op_last3_sorta_trimends([3, 1, 2]) == [2]\nassert op_last3_sorta_trimends([10]) == []\nassert op_last3_sorta_trimends([2, 4, 6]) == [4]\nassert op_last3_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_dropfirst_sorta_neg", "entry_point": "op_dropfirst_sorta_neg", "primitives": ["dropfirst", "sorta", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then keep the negative numbers.", "solution": "def op_dropfirst_sorta_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_sorta_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_sorta_neg([]) == []\nassert op_dropfirst_sorta_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_sorta_neg([5, 5, 5]) == []\nassert op_dropfirst_sorta_neg([3, 1, 2]) == []\nassert op_dropfirst_sorta_neg([10]) == []\nassert op_dropfirst_sorta_neg([2, 4, 6]) == []\nassert op_dropfirst_sorta_neg([-7, 12, -7]) == [-7]"}
{"id": "op_div3_trimends_max", "entry_point": "op_div3_trimends_max", "primitives": ["div3", "trimends", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_div3_trimends_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_div3_trimends_max([1, 2, 3, 4]) == 0\nassert op_div3_trimends_max([]) == 0\nassert op_div3_trimends_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_trimends_max([5, 5, 5]) == 0\nassert op_div3_trimends_max([3, 1, 2]) == 0\nassert op_div3_trimends_max([10]) == 0\nassert op_div3_trimends_max([2, 4, 6]) == 0\nassert op_div3_trimends_max([-7, 12, -7]) == 0"}
{"id": "op_sortabs_double_dropfirst", "entry_point": "op_sortabs_double_dropfirst", "primitives": ["sortabs", "double", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then drop the first element.", "solution": "def op_sortabs_double_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_double_dropfirst([1, 2, 3, 4]) == [4, 6, 8]\nassert op_sortabs_double_dropfirst([]) == []\nassert op_sortabs_double_dropfirst([-2, -1, 0, 1, 2]) == [-2, 2, -4, 4]\nassert op_sortabs_double_dropfirst([5, 5, 5]) == [10, 10]\nassert op_sortabs_double_dropfirst([3, 1, 2]) == [4, 6]\nassert op_sortabs_double_dropfirst([10]) == []\nassert op_sortabs_double_dropfirst([2, 4, 6]) == [8, 12]\nassert op_sortabs_double_dropfirst([-7, 12, -7]) == [-14, 24]"}
{"id": "op_sortabs_inc_clamp10", "entry_point": "op_sortabs_inc_clamp10", "primitives": ["sortabs", "inc", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then cap each value at 10.", "solution": "def op_sortabs_inc_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_inc_clamp10([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_inc_clamp10([]) == []\nassert op_sortabs_inc_clamp10([-2, -1, 0, 1, 2]) == [1, 0, 2, -1, 3]\nassert op_sortabs_inc_clamp10([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_inc_clamp10([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_inc_clamp10([10]) == [10]\nassert op_sortabs_inc_clamp10([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_inc_clamp10([-7, 12, -7]) == [-6, -6, 10]"}
{"id": "op_sortlen_upper_strip", "entry_point": "op_sortlen_upper_strip", "primitives": ["sortlen", "upper", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then uppercase each string, then trim whitespace from each.", "solution": "def op_sortlen_upper_strip(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_sortlen_upper_strip(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortlen_upper_strip([]) == []\nassert op_sortlen_upper_strip(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'BC', 'A']\nassert op_sortlen_upper_strip(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_sortlen_upper_strip(['x']) == ['X']\nassert op_sortlen_upper_strip(['abc', 'de', '']) == ['', 'DE', 'ABC']"}
{"id": "op_odds_negate_sortd", "entry_point": "op_odds_negate_sortd", "primitives": ["odds", "negate", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each, then sort descending.", "solution": "def op_odds_negate_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_negate_sortd([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_negate_sortd([]) == []\nassert op_odds_negate_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_negate_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_negate_sortd([3, 1, 2]) == [-1, -3]\nassert op_odds_negate_sortd([10]) == []\nassert op_odds_negate_sortd([2, 4, 6]) == []\nassert op_odds_negate_sortd([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropzeros_clamp10_odds", "entry_point": "op_dropzeros_clamp10_odds", "primitives": ["dropzeros", "clamp10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then keep the odd numbers.", "solution": "def op_dropzeros_clamp10_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropzeros_clamp10_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_clamp10_odds([]) == []\nassert op_dropzeros_clamp10_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_clamp10_odds([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_clamp10_odds([3, 1, 2]) == [3, 1]\nassert op_dropzeros_clamp10_odds([10]) == []\nassert op_dropzeros_clamp10_odds([2, 4, 6]) == []\nassert op_dropzeros_clamp10_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_pos_sortabs", "entry_point": "op_div3_pos_sortabs", "primitives": ["div3", "pos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then sort by absolute value.", "solution": "def op_div3_pos_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_pos_sortabs([1, 2, 3, 4]) == [3]\nassert op_div3_pos_sortabs([]) == []\nassert op_div3_pos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_div3_pos_sortabs([5, 5, 5]) == []\nassert op_div3_pos_sortabs([3, 1, 2]) == [3]\nassert op_div3_pos_sortabs([10]) == []\nassert op_div3_pos_sortabs([2, 4, 6]) == [6]\nassert op_div3_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_trimends_dropfirst_div3", "entry_point": "op_trimends_dropfirst_div3", "primitives": ["trimends", "dropfirst", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the first element, then keep multiples of three.", "solution": "def op_trimends_dropfirst_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_trimends_dropfirst_div3([]) == []\nassert op_trimends_dropfirst_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_dropfirst_div3([5, 5, 5]) == []\nassert op_trimends_dropfirst_div3([3, 1, 2]) == []\nassert op_trimends_dropfirst_div3([10]) == []\nassert op_trimends_dropfirst_div3([2, 4, 6]) == []\nassert op_trimends_dropfirst_div3([-7, 12, -7]) == []"}
{"id": "op_uniq_takewhilepos_len", "entry_point": "op_uniq_takewhilepos_len", "primitives": ["uniq", "takewhilepos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then return how many remain.", "solution": "def op_uniq_takewhilepos_len(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_uniq_takewhilepos_len([1, 2, 3, 4]) == 4\nassert op_uniq_takewhilepos_len([]) == 0\nassert op_uniq_takewhilepos_len([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_takewhilepos_len([5, 5, 5]) == 1\nassert op_uniq_takewhilepos_len([3, 1, 2]) == 3\nassert op_uniq_takewhilepos_len([10]) == 1\nassert op_uniq_takewhilepos_len([2, 4, 6]) == 3\nassert op_uniq_takewhilepos_len([-7, 12, -7]) == 0"}
{"id": "op_square_absval_neg", "entry_point": "op_square_absval_neg", "primitives": ["square", "absval", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each, then keep the negative numbers.", "solution": "def op_square_absval_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_absval_neg([1, 2, 3, 4]) == []\nassert op_square_absval_neg([]) == []\nassert op_square_absval_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_absval_neg([5, 5, 5]) == []\nassert op_square_absval_neg([3, 1, 2]) == []\nassert op_square_absval_neg([10]) == []\nassert op_square_absval_neg([2, 4, 6]) == []\nassert op_square_absval_neg([-7, 12, -7]) == []"}
{"id": "op_last3_dropzeros_sum", "entry_point": "op_last3_dropzeros_sum", "primitives": ["last3", "dropzeros", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then return their sum.", "solution": "def op_last3_dropzeros_sum(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_last3_dropzeros_sum([1, 2, 3, 4]) == 9\nassert op_last3_dropzeros_sum([]) == 0\nassert op_last3_dropzeros_sum([-2, -1, 0, 1, 2]) == 3\nassert op_last3_dropzeros_sum([5, 5, 5]) == 15\nassert op_last3_dropzeros_sum([3, 1, 2]) == 6\nassert op_last3_dropzeros_sum([10]) == 10\nassert op_last3_dropzeros_sum([2, 4, 6]) == 12\nassert op_last3_dropzeros_sum([-7, 12, -7]) == -2"}
{"id": "op_inc_padto3_uniq", "entry_point": "op_inc_padto3_uniq", "primitives": ["inc", "padto3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_inc_padto3_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_padto3_uniq([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_padto3_uniq([]) == [0]\nassert op_inc_padto3_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_padto3_uniq([5, 5, 5]) == [6]\nassert op_inc_padto3_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_inc_padto3_uniq([10]) == [11, 0]\nassert op_inc_padto3_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_inc_padto3_uniq([-7, 12, -7]) == [-6, 13]"}
{"id": "op_dropwhileneg_dropzeros_alldistinct", "entry_point": "op_dropwhileneg_dropzeros_alldistinct", "primitives": ["dropwhileneg", "dropzeros", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then return whether all values are distinct.", "solution": "def op_dropwhileneg_dropzeros_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_dropzeros_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_dropzeros_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([10]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_dropzeros_alldistinct([-7, 12, -7]) == True"}
{"id": "op_rev_sortabs_prod", "entry_point": "op_rev_sortabs_prod", "primitives": ["rev", "sortabs", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then return their product.", "solution": "def op_rev_sortabs_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_rev_sortabs_prod([1, 2, 3, 4]) == 24\nassert op_rev_sortabs_prod([]) == 1\nassert op_rev_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_rev_sortabs_prod([5, 5, 5]) == 125\nassert op_rev_sortabs_prod([3, 1, 2]) == 6\nassert op_rev_sortabs_prod([10]) == 10\nassert op_rev_sortabs_prod([2, 4, 6]) == 48\nassert op_rev_sortabs_prod([-7, 12, -7]) == 588"}
{"id": "op_padto3_sorta_pos", "entry_point": "op_padto3_sorta_pos", "primitives": ["padto3", "sorta", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then keep the positive numbers.", "solution": "def op_padto3_sorta_pos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_padto3_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sorta_pos([]) == []\nassert op_padto3_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sorta_pos([10]) == [10]\nassert op_padto3_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_ages_dropwhileneg_issorted", "entry_point": "op_ages_dropwhileneg_issorted", "primitives": ["ages", "dropwhileneg", "issorted"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_ages_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_ages_dropwhileneg_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_dropwhileneg_issorted([]) == True\nassert op_ages_dropwhileneg_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_dropwhileneg_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_last3_square_max", "entry_point": "op_last3_square_max", "primitives": ["last3", "square", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then return the maximum (0 if empty).", "solution": "def op_last3_square_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_last3_square_max([1, 2, 3, 4]) == 16\nassert op_last3_square_max([]) == 0\nassert op_last3_square_max([-2, -1, 0, 1, 2]) == 4\nassert op_last3_square_max([5, 5, 5]) == 25\nassert op_last3_square_max([3, 1, 2]) == 9\nassert op_last3_square_max([10]) == 100\nassert op_last3_square_max([2, 4, 6]) == 36\nassert op_last3_square_max([-7, 12, -7]) == 144"}
{"id": "op_uniq_padto3_sorta", "entry_point": "op_uniq_padto3_sorta", "primitives": ["uniq", "padto3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements, then sort ascending.", "solution": "def op_uniq_padto3_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_padto3_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_padto3_sorta([]) == [0, 0, 0]\nassert op_uniq_padto3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_padto3_sorta([5, 5, 5]) == [0, 0, 5]\nassert op_uniq_padto3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_padto3_sorta([10]) == [0, 0, 10]\nassert op_uniq_padto3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_padto3_sorta([-7, 12, -7]) == [-7, 0, 12]"}
{"id": "op_odds_dropzeros_rev", "entry_point": "op_odds_dropzeros_rev", "primitives": ["odds", "dropzeros", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros, then reverse the order.", "solution": "def op_odds_dropzeros_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_odds_dropzeros_rev([1, 2, 3, 4]) == [3, 1]\nassert op_odds_dropzeros_rev([]) == []\nassert op_odds_dropzeros_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_dropzeros_rev([5, 5, 5]) == [5, 5, 5]\nassert op_odds_dropzeros_rev([3, 1, 2]) == [1, 3]\nassert op_odds_dropzeros_rev([10]) == []\nassert op_odds_dropzeros_rev([2, 4, 6]) == []\nassert op_odds_dropzeros_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_add10_sortd_gt5", "entry_point": "op_add10_sortd_gt5", "primitives": ["add10", "sortd", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort descending, then keep values greater than five.", "solution": "def op_add10_sortd_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_sortd_gt5([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_sortd_gt5([]) == []\nassert op_add10_sortd_gt5([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_sortd_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortd_gt5([3, 1, 2]) == [13, 12, 11]\nassert op_add10_sortd_gt5([10]) == [20]\nassert op_add10_sortd_gt5([2, 4, 6]) == [16, 14, 12]\nassert op_add10_sortd_gt5([-7, 12, -7]) == [22]"}
{"id": "op_odds_sortabs_rev", "entry_point": "op_odds_sortabs_rev", "primitives": ["odds", "sortabs", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then reverse the order.", "solution": "def op_odds_sortabs_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_odds_sortabs_rev([1, 2, 3, 4]) == [3, 1]\nassert op_odds_sortabs_rev([]) == []\nassert op_odds_sortabs_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_sortabs_rev([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortabs_rev([3, 1, 2]) == [3, 1]\nassert op_odds_sortabs_rev([10]) == []\nassert op_odds_sortabs_rev([2, 4, 6]) == []\nassert op_odds_sortabs_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_strip_prefixup_lens", "entry_point": "op_strip_prefixup_lens", "primitives": ["strip", "prefixup", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash, then return the total number of characters.", "solution": "def op_strip_prefixup_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_strip_prefixup_lens(['Hello', 'world']) == 12\nassert op_strip_prefixup_lens([]) == 0\nassert op_strip_prefixup_lens(['  a ', '', 'BC', 'bc']) == 9\nassert op_strip_prefixup_lens(['one', 'one', 'Two']) == 12\nassert op_strip_prefixup_lens(['x']) == 2\nassert op_strip_prefixup_lens(['abc', 'de', '']) == 8"}
{"id": "op_beforezero_sortabs_sorta", "entry_point": "op_beforezero_sortabs_sorta", "primitives": ["beforezero", "sortabs", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then sort ascending.", "solution": "def op_beforezero_sortabs_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_sortabs_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sortabs_sorta([]) == []\nassert op_beforezero_sortabs_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortabs_sorta([10]) == [10]\nassert op_beforezero_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortabs_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_inc_dropzeros_sortd", "entry_point": "op_inc_dropzeros_sortd", "primitives": ["inc", "dropzeros", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then sort descending.", "solution": "def op_inc_dropzeros_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_dropzeros_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_dropzeros_sortd([]) == []\nassert op_inc_dropzeros_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, -1]\nassert op_inc_dropzeros_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropzeros_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_inc_dropzeros_sortd([10]) == [11]\nassert op_inc_dropzeros_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_inc_dropzeros_sortd([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_ages_absval_padto3", "entry_point": "op_ages_absval_padto3", "primitives": ["ages", "absval", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_ages_absval_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_absval_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12, 0]\nassert op_ages_absval_padto3([]) == [0, 0, 0]\nassert op_ages_absval_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_absval_padto3([{'name': 'Fi', 'age': 41}]) == [41, 0, 0]"}
{"id": "op_pos_sortabs_uniq", "entry_point": "op_pos_sortabs_uniq", "primitives": ["pos", "sortabs", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_pos_sortabs_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_sortabs_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_sortabs_uniq([]) == []\nassert op_pos_sortabs_uniq([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_sortabs_uniq([5, 5, 5]) == [5]\nassert op_pos_sortabs_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_pos_sortabs_uniq([10]) == [10]\nassert op_pos_sortabs_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_pos_sortabs_uniq([-7, 12, -7]) == [12]"}
{"id": "op_sorta_sortd_absval", "entry_point": "op_sorta_sortd_absval", "primitives": ["sorta", "sortd", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then take the absolute value of each.", "solution": "def op_sorta_sortd_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_sortd_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_sortd_absval([]) == []\nassert op_sorta_sortd_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_sortd_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortd_absval([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_sortd_absval([10]) == [10]\nassert op_sorta_sortd_absval([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_sortd_absval([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_add10_neg_dropwhileneg", "entry_point": "op_add10_neg_dropwhileneg", "primitives": ["add10", "neg", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then drop the leading negative values.", "solution": "def op_add10_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_add10_neg_dropwhileneg([]) == []\nassert op_add10_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_dropwhileneg([5, 5, 5]) == []\nassert op_add10_neg_dropwhileneg([3, 1, 2]) == []\nassert op_add10_neg_dropwhileneg([10]) == []\nassert op_add10_neg_dropwhileneg([2, 4, 6]) == []\nassert op_add10_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_square_firsteven", "entry_point": "op_dropwhileneg_square_firsteven", "primitives": ["dropwhileneg", "square", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then return the first even value (0 if none).", "solution": "def op_dropwhileneg_square_firsteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropwhileneg_square_firsteven([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_square_firsteven([]) == 0\nassert op_dropwhileneg_square_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_square_firsteven([5, 5, 5]) == 0\nassert op_dropwhileneg_square_firsteven([3, 1, 2]) == 4\nassert op_dropwhileneg_square_firsteven([10]) == 100\nassert op_dropwhileneg_square_firsteven([2, 4, 6]) == 4\nassert op_dropwhileneg_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_pos_sorta_double", "entry_point": "op_pos_sorta_double", "primitives": ["pos", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort ascending, then double each.", "solution": "def op_pos_sorta_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_sorta_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_sorta_double([]) == []\nassert op_pos_sorta_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_sorta_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_sorta_double([3, 1, 2]) == [2, 4, 6]\nassert op_pos_sorta_double([10]) == [20]\nassert op_pos_sorta_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_sorta_double([-7, 12, -7]) == [24]"}
{"id": "op_rev_evens_takewhilepos", "entry_point": "op_rev_evens_takewhilepos", "primitives": ["rev", "evens", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers, then take values while they are positive.", "solution": "def op_rev_evens_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_evens_takewhilepos([1, 2, 3, 4]) == [4, 2]\nassert op_rev_evens_takewhilepos([]) == []\nassert op_rev_evens_takewhilepos([-2, -1, 0, 1, 2]) == [2]\nassert op_rev_evens_takewhilepos([5, 5, 5]) == []\nassert op_rev_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_rev_evens_takewhilepos([10]) == [10]\nassert op_rev_evens_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_dropzeros_dec", "entry_point": "op_uniq_dropzeros_dec", "primitives": ["uniq", "dropzeros", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then subtract one from each.", "solution": "def op_uniq_dropzeros_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_uniq_dropzeros_dec([]) == []\nassert op_uniq_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_uniq_dropzeros_dec([5, 5, 5]) == [4]\nassert op_uniq_dropzeros_dec([3, 1, 2]) == [2, 0, 1]\nassert op_uniq_dropzeros_dec([10]) == [9]\nassert op_uniq_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_dropzeros_dec([-7, 12, -7]) == [-8, 11]"}
{"id": "op_absval_gt5_allpos", "entry_point": "op_absval_gt5_allpos", "primitives": ["absval", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then return whether all values are positive.", "solution": "def op_absval_gt5_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_gt5_allpos([1, 2, 3, 4]) == True\nassert op_absval_gt5_allpos([]) == True\nassert op_absval_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_absval_gt5_allpos([5, 5, 5]) == True\nassert op_absval_gt5_allpos([3, 1, 2]) == True\nassert op_absval_gt5_allpos([10]) == True\nassert op_absval_gt5_allpos([2, 4, 6]) == True\nassert op_absval_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_oremptyzero_len", "entry_point": "op_inc_oremptyzero_len", "primitives": ["inc", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then return how many remain.", "solution": "def op_inc_oremptyzero_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_inc_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_inc_oremptyzero_len([]) == 1\nassert op_inc_oremptyzero_len([-2, -1, 0, 1, 2]) == 5\nassert op_inc_oremptyzero_len([5, 5, 5]) == 3\nassert op_inc_oremptyzero_len([3, 1, 2]) == 3\nassert op_inc_oremptyzero_len([10]) == 1\nassert op_inc_oremptyzero_len([2, 4, 6]) == 3\nassert op_inc_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_clamp10_square_issorted", "entry_point": "op_clamp10_square_issorted", "primitives": ["clamp10", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then return whether the list is sorted ascending.", "solution": "def op_clamp10_square_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_clamp10_square_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_square_issorted([]) == True\nassert op_clamp10_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_clamp10_square_issorted([5, 5, 5]) == True\nassert op_clamp10_square_issorted([3, 1, 2]) == False\nassert op_clamp10_square_issorted([10]) == True\nassert op_clamp10_square_issorted([2, 4, 6]) == True\nassert op_clamp10_square_issorted([-7, 12, -7]) == False"}
{"id": "op_evens_sortd_first3", "entry_point": "op_evens_sortd_first3", "primitives": ["evens", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then keep only the first three.", "solution": "def op_evens_sortd_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_evens_sortd_first3([1, 2, 3, 4]) == [4, 2]\nassert op_evens_sortd_first3([]) == []\nassert op_evens_sortd_first3([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_sortd_first3([5, 5, 5]) == []\nassert op_evens_sortd_first3([3, 1, 2]) == [2]\nassert op_evens_sortd_first3([10]) == [10]\nassert op_evens_sortd_first3([2, 4, 6]) == [6, 4, 2]\nassert op_evens_sortd_first3([-7, 12, -7]) == [12]"}
{"id": "op_square_dropwhileneg_padto3", "entry_point": "op_square_dropwhileneg_padto3", "primitives": ["square", "dropwhileneg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then pad with zeros to at least three elements.", "solution": "def op_square_dropwhileneg_padto3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_square_dropwhileneg_padto3([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_dropwhileneg_padto3([]) == [0, 0, 0]\nassert op_square_dropwhileneg_padto3([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_dropwhileneg_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_square_dropwhileneg_padto3([3, 1, 2]) == [9, 1, 4]\nassert op_square_dropwhileneg_padto3([10]) == [100, 0, 0]\nassert op_square_dropwhileneg_padto3([2, 4, 6]) == [4, 16, 36]\nassert op_square_dropwhileneg_padto3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_firstchar_sortalpha_longest", "entry_point": "op_firstchar_sortalpha_longest", "primitives": ["firstchar", "sortalpha", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then return the longest string (empty if none).", "solution": "def op_firstchar_sortalpha_longest(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    return max(r, key=len) if r else ''", "tests": "assert op_firstchar_sortalpha_longest(['Hello', 'world']) == 'H'\nassert op_firstchar_sortalpha_longest([]) == ''\nassert op_firstchar_sortalpha_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_firstchar_sortalpha_longest(['one', 'one', 'Two']) == 'T'\nassert op_firstchar_sortalpha_longest(['x']) == 'x'\nassert op_firstchar_sortalpha_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_beforezero_evens_neg", "entry_point": "op_beforezero_evens_neg", "primitives": ["beforezero", "evens", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then keep the negative numbers.", "solution": "def op_beforezero_evens_neg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_beforezero_evens_neg([1, 2, 3, 4]) == []\nassert op_beforezero_evens_neg([]) == []\nassert op_beforezero_evens_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_evens_neg([5, 5, 5]) == []\nassert op_beforezero_evens_neg([3, 1, 2]) == []\nassert op_beforezero_evens_neg([10]) == []\nassert op_beforezero_evens_neg([2, 4, 6]) == []\nassert op_beforezero_evens_neg([-7, 12, -7]) == []"}
{"id": "op_prefixup_dropshort_nonempty", "entry_point": "op_prefixup_dropshort_nonempty", "primitives": ["prefixup", "dropshort", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop strings shorter than three characters, then drop empty strings.", "solution": "def op_prefixup_dropshort_nonempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_prefixup_dropshort_nonempty(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_dropshort_nonempty([]) == []\nassert op_prefixup_dropshort_nonempty(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_prefixup_dropshort_nonempty(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_prefixup_dropshort_nonempty(['x']) == []\nassert op_prefixup_dropshort_nonempty(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_beforezero_sortabs_len", "entry_point": "op_beforezero_sortabs_len", "primitives": ["beforezero", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return how many remain.", "solution": "def op_beforezero_sortabs_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_beforezero_sortabs_len([1, 2, 3, 4]) == 4\nassert op_beforezero_sortabs_len([]) == 0\nassert op_beforezero_sortabs_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_sortabs_len([5, 5, 5]) == 3\nassert op_beforezero_sortabs_len([3, 1, 2]) == 3\nassert op_beforezero_sortabs_len([10]) == 1\nassert op_beforezero_sortabs_len([2, 4, 6]) == 3\nassert op_beforezero_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_first3_double_max", "entry_point": "op_first3_double_max", "primitives": ["first3", "double", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then return the maximum (0 if empty).", "solution": "def op_first3_double_max(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_first3_double_max([1, 2, 3, 4]) == 6\nassert op_first3_double_max([]) == 0\nassert op_first3_double_max([-2, -1, 0, 1, 2]) == 0\nassert op_first3_double_max([5, 5, 5]) == 10\nassert op_first3_double_max([3, 1, 2]) == 6\nassert op_first3_double_max([10]) == 20\nassert op_first3_double_max([2, 4, 6]) == 12\nassert op_first3_double_max([-7, 12, -7]) == 24"}
{"id": "op_sortd_dropfirst_anyeven", "entry_point": "op_sortd_dropfirst_anyeven", "primitives": ["sortd", "dropfirst", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then return whether any value is even.", "solution": "def op_sortd_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortd_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_sortd_dropfirst_anyeven([]) == False\nassert op_sortd_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortd_dropfirst_anyeven([5, 5, 5]) == False\nassert op_sortd_dropfirst_anyeven([3, 1, 2]) == True\nassert op_sortd_dropfirst_anyeven([10]) == False\nassert op_sortd_dropfirst_anyeven([2, 4, 6]) == True\nassert op_sortd_dropfirst_anyeven([-7, 12, -7]) == False"}
{"id": "op_pos_div3_haszero", "entry_point": "op_pos_div3_haszero", "primitives": ["pos", "div3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then return whether the list contains a zero.", "solution": "def op_pos_div3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return 0 in r", "tests": "assert op_pos_div3_haszero([1, 2, 3, 4]) == False\nassert op_pos_div3_haszero([]) == False\nassert op_pos_div3_haszero([-2, -1, 0, 1, 2]) == False\nassert op_pos_div3_haszero([5, 5, 5]) == False\nassert op_pos_div3_haszero([3, 1, 2]) == False\nassert op_pos_div3_haszero([10]) == False\nassert op_pos_div3_haszero([2, 4, 6]) == False\nassert op_pos_div3_haszero([-7, 12, -7]) == False"}
{"id": "op_inc_sortd_odds", "entry_point": "op_inc_sortd_odds", "primitives": ["inc", "sortd", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then keep the odd numbers.", "solution": "def op_inc_sortd_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_sortd_odds([1, 2, 3, 4]) == [5, 3]\nassert op_inc_sortd_odds([]) == []\nassert op_inc_sortd_odds([-2, -1, 0, 1, 2]) == [3, 1, -1]\nassert op_inc_sortd_odds([5, 5, 5]) == []\nassert op_inc_sortd_odds([3, 1, 2]) == [3]\nassert op_inc_sortd_odds([10]) == [11]\nassert op_inc_sortd_odds([2, 4, 6]) == [7, 5, 3]\nassert op_inc_sortd_odds([-7, 12, -7]) == [13]"}
{"id": "op_trimends_inc_add10", "entry_point": "op_trimends_inc_add10", "primitives": ["trimends", "inc", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then add ten to each.", "solution": "def op_trimends_inc_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_inc_add10([1, 2, 3, 4]) == [13, 14]\nassert op_trimends_inc_add10([]) == []\nassert op_trimends_inc_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_trimends_inc_add10([5, 5, 5]) == [16]\nassert op_trimends_inc_add10([3, 1, 2]) == [12]\nassert op_trimends_inc_add10([10]) == []\nassert op_trimends_inc_add10([2, 4, 6]) == [15]\nassert op_trimends_inc_add10([-7, 12, -7]) == [23]"}
{"id": "op_evens_dropzeros_odds", "entry_point": "op_evens_dropzeros_odds", "primitives": ["evens", "dropzeros", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then keep the odd numbers.", "solution": "def op_evens_dropzeros_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_dropzeros_odds([1, 2, 3, 4]) == []\nassert op_evens_dropzeros_odds([]) == []\nassert op_evens_dropzeros_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_dropzeros_odds([5, 5, 5]) == []\nassert op_evens_dropzeros_odds([3, 1, 2]) == []\nassert op_evens_dropzeros_odds([10]) == []\nassert op_evens_dropzeros_odds([2, 4, 6]) == []\nassert op_evens_dropzeros_odds([-7, 12, -7]) == []"}
{"id": "op_inc_rev_padto3", "entry_point": "op_inc_rev_padto3", "primitives": ["inc", "rev", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then pad with zeros to at least three elements.", "solution": "def op_inc_rev_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_rev_padto3([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_rev_padto3([]) == [0, 0, 0]\nassert op_inc_rev_padto3([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_rev_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_rev_padto3([3, 1, 2]) == [3, 2, 4]\nassert op_inc_rev_padto3([10]) == [11, 0, 0]\nassert op_inc_rev_padto3([2, 4, 6]) == [7, 5, 3]\nassert op_inc_rev_padto3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_uniq_inc_alldistinct", "entry_point": "op_uniq_inc_alldistinct", "primitives": ["uniq", "inc", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then return whether all values are distinct.", "solution": "def op_uniq_inc_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_uniq_inc_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_inc_alldistinct([]) == True\nassert op_uniq_inc_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_uniq_inc_alldistinct([5, 5, 5]) == True\nassert op_uniq_inc_alldistinct([3, 1, 2]) == True\nassert op_uniq_inc_alldistinct([10]) == True\nassert op_uniq_inc_alldistinct([2, 4, 6]) == True\nassert op_uniq_inc_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropfirst_div3_beforezero", "entry_point": "op_dropfirst_div3_beforezero", "primitives": ["dropfirst", "div3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_dropfirst_div3_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_div3_beforezero([1, 2, 3, 4]) == [3]\nassert op_dropfirst_div3_beforezero([]) == []\nassert op_dropfirst_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_div3_beforezero([5, 5, 5]) == []\nassert op_dropfirst_div3_beforezero([3, 1, 2]) == []\nassert op_dropfirst_div3_beforezero([10]) == []\nassert op_dropfirst_div3_beforezero([2, 4, 6]) == [6]\nassert op_dropfirst_div3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_trimends_sum", "entry_point": "op_sortabs_trimends_sum", "primitives": ["sortabs", "trimends", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then return their sum.", "solution": "def op_sortabs_trimends_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return sum(r)", "tests": "assert op_sortabs_trimends_sum([1, 2, 3, 4]) == 5\nassert op_sortabs_trimends_sum([]) == 0\nassert op_sortabs_trimends_sum([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_trimends_sum([5, 5, 5]) == 5\nassert op_sortabs_trimends_sum([3, 1, 2]) == 2\nassert op_sortabs_trimends_sum([10]) == 0\nassert op_sortabs_trimends_sum([2, 4, 6]) == 4\nassert op_sortabs_trimends_sum([-7, 12, -7]) == -7"}
{"id": "op_dropfirst_sortabs_firsteven", "entry_point": "op_dropfirst_sortabs_firsteven", "primitives": ["dropfirst", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_dropfirst_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_sortabs_firsteven([]) == 0\nassert op_dropfirst_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_sortabs_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_sortabs_firsteven([3, 1, 2]) == 2\nassert op_dropfirst_sortabs_firsteven([10]) == 0\nassert op_dropfirst_sortabs_firsteven([2, 4, 6]) == 4\nassert op_dropfirst_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_ages_sortabs_len", "entry_point": "op_ages_sortabs_len", "primitives": ["ages", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value, then return how many remain.", "solution": "def op_ages_sortabs_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_ages_sortabs_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_sortabs_len([]) == 0\nassert op_ages_sortabs_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_sortabs_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_dec_absval_rev", "entry_point": "op_dec_absval_rev", "primitives": ["dec", "absval", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then reverse the order.", "solution": "def op_dec_absval_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_absval_rev([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_absval_rev([]) == []\nassert op_dec_absval_rev([-2, -1, 0, 1, 2]) == [1, 0, 1, 2, 3]\nassert op_dec_absval_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_rev([3, 1, 2]) == [1, 0, 2]\nassert op_dec_absval_rev([10]) == [9]\nassert op_dec_absval_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_absval_rev([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_clamp10_sorta_add10", "entry_point": "op_clamp10_sorta_add10", "primitives": ["clamp10", "sorta", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then add ten to each.", "solution": "def op_clamp10_sorta_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_sorta_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_sorta_add10([]) == []\nassert op_clamp10_sorta_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_clamp10_sorta_add10([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_sorta_add10([3, 1, 2]) == [11, 12, 13]\nassert op_clamp10_sorta_add10([10]) == [20]\nassert op_clamp10_sorta_add10([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_sorta_add10([-7, 12, -7]) == [3, 3, 20]"}
{"id": "op_uniq_add10_last3", "entry_point": "op_uniq_add10_last3", "primitives": ["uniq", "add10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then keep only the last three.", "solution": "def op_uniq_add10_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_add10_last3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_uniq_add10_last3([]) == []\nassert op_uniq_add10_last3([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_uniq_add10_last3([5, 5, 5]) == [15]\nassert op_uniq_add10_last3([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10_last3([10]) == [20]\nassert op_uniq_add10_last3([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_last3([-7, 12, -7]) == [3, 22]"}
{"id": "op_dec_double_negate", "entry_point": "op_dec_double_negate", "primitives": ["dec", "double", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then negate each.", "solution": "def op_dec_double_negate(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dec_double_negate([1, 2, 3, 4]) == [0, -2, -4, -6]\nassert op_dec_double_negate([]) == []\nassert op_dec_double_negate([-2, -1, 0, 1, 2]) == [6, 4, 2, 0, -2]\nassert op_dec_double_negate([5, 5, 5]) == [-8, -8, -8]\nassert op_dec_double_negate([3, 1, 2]) == [-4, 0, -2]\nassert op_dec_double_negate([10]) == [-18]\nassert op_dec_double_negate([2, 4, 6]) == [-2, -6, -10]\nassert op_dec_double_negate([-7, 12, -7]) == [16, -22, 16]"}
{"id": "op_trimends_uniq_first3", "entry_point": "op_trimends_uniq_first3", "primitives": ["trimends", "uniq", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then keep only the first three.", "solution": "def op_trimends_uniq_first3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    return r", "tests": "assert op_trimends_uniq_first3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_uniq_first3([]) == []\nassert op_trimends_uniq_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_uniq_first3([5, 5, 5]) == [5]\nassert op_trimends_uniq_first3([3, 1, 2]) == [1]\nassert op_trimends_uniq_first3([10]) == []\nassert op_trimends_uniq_first3([2, 4, 6]) == [4]\nassert op_trimends_uniq_first3([-7, 12, -7]) == [12]"}
{"id": "op_square_dropfirst_negate", "entry_point": "op_square_dropfirst_negate", "primitives": ["square", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then negate each.", "solution": "def op_square_dropfirst_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_dropfirst_negate([1, 2, 3, 4]) == [-4, -9, -16]\nassert op_square_dropfirst_negate([]) == []\nassert op_square_dropfirst_negate([-2, -1, 0, 1, 2]) == [-1, 0, -1, -4]\nassert op_square_dropfirst_negate([5, 5, 5]) == [-25, -25]\nassert op_square_dropfirst_negate([3, 1, 2]) == [-1, -4]\nassert op_square_dropfirst_negate([10]) == []\nassert op_square_dropfirst_negate([2, 4, 6]) == [-16, -36]\nassert op_square_dropfirst_negate([-7, 12, -7]) == [-144, -49]"}
{"id": "op_sortd_square_counteven", "entry_point": "op_sortd_square_counteven", "primitives": ["sortd", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then return how many values are even.", "solution": "def op_sortd_square_counteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortd_square_counteven([1, 2, 3, 4]) == 2\nassert op_sortd_square_counteven([]) == 0\nassert op_sortd_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sortd_square_counteven([5, 5, 5]) == 0\nassert op_sortd_square_counteven([3, 1, 2]) == 1\nassert op_sortd_square_counteven([10]) == 1\nassert op_sortd_square_counteven([2, 4, 6]) == 3\nassert op_sortd_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_square_gt5", "entry_point": "op_first3_square_gt5", "primitives": ["first3", "square", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each, then keep values greater than five.", "solution": "def op_first3_square_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_square_gt5([1, 2, 3, 4]) == [9]\nassert op_first3_square_gt5([]) == []\nassert op_first3_square_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_square_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_first3_square_gt5([3, 1, 2]) == [9]\nassert op_first3_square_gt5([10]) == [100]\nassert op_first3_square_gt5([2, 4, 6]) == [16, 36]\nassert op_first3_square_gt5([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_takewhilepos_last3_sorta", "entry_point": "op_takewhilepos_last3_sorta", "primitives": ["takewhilepos", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then sort ascending.", "solution": "def op_takewhilepos_last3_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_last3_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_last3_sorta([]) == []\nassert op_takewhilepos_last3_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_last3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_last3_sorta([10]) == [10]\nassert op_takewhilepos_last3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_last3_sorta([-7, 12, -7]) == []"}
{"id": "op_negate_gt5_sortabs", "entry_point": "op_negate_gt5_sortabs", "primitives": ["negate", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then sort by absolute value.", "solution": "def op_negate_gt5_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_negate_gt5_sortabs([]) == []\nassert op_negate_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_negate_gt5_sortabs([5, 5, 5]) == []\nassert op_negate_gt5_sortabs([3, 1, 2]) == []\nassert op_negate_gt5_sortabs([10]) == []\nassert op_negate_gt5_sortabs([2, 4, 6]) == []\nassert op_negate_gt5_sortabs([-7, 12, -7]) == [7, 7]"}
{"id": "op_evens_takewhilepos_rev", "entry_point": "op_evens_takewhilepos_rev", "primitives": ["evens", "takewhilepos", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then reverse the order.", "solution": "def op_evens_takewhilepos_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_evens_takewhilepos_rev([1, 2, 3, 4]) == [4, 2]\nassert op_evens_takewhilepos_rev([]) == []\nassert op_evens_takewhilepos_rev([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_rev([5, 5, 5]) == []\nassert op_evens_takewhilepos_rev([3, 1, 2]) == [2]\nassert op_evens_takewhilepos_rev([10]) == [10]\nassert op_evens_takewhilepos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_evens_takewhilepos_rev([-7, 12, -7]) == [12]"}
{"id": "op_padto3_beforezero_double", "entry_point": "op_padto3_beforezero_double", "primitives": ["padto3", "beforezero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then double each.", "solution": "def op_padto3_beforezero_double(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_padto3_beforezero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_beforezero_double([]) == []\nassert op_padto3_beforezero_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_padto3_beforezero_double([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_beforezero_double([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_beforezero_double([10]) == [20]\nassert op_padto3_beforezero_double([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_beforezero_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dec_gt5_beforezero", "entry_point": "op_dec_gt5_beforezero", "primitives": ["dec", "gt5", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_dec_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dec_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_dec_gt5_beforezero([]) == []\nassert op_dec_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dec_gt5_beforezero([5, 5, 5]) == []\nassert op_dec_gt5_beforezero([3, 1, 2]) == []\nassert op_dec_gt5_beforezero([10]) == [9]\nassert op_dec_gt5_beforezero([2, 4, 6]) == []\nassert op_dec_gt5_beforezero([-7, 12, -7]) == [11]"}
{"id": "op_sortd_last3_sortabs", "entry_point": "op_sortd_last3_sortabs", "primitives": ["sortd", "last3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three, then sort by absolute value.", "solution": "def op_sortd_last3_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortd_last3_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortd_last3_sortabs([]) == []\nassert op_sortd_last3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_sortd_last3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_last3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_last3_sortabs([10]) == [10]\nassert op_sortd_last3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_last3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_padto3_dropwhileneg_dropfirst", "entry_point": "op_padto3_dropwhileneg_dropfirst", "primitives": ["padto3", "dropwhileneg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then drop the first element.", "solution": "def op_padto3_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_dropwhileneg_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_dropwhileneg_dropfirst([]) == [0, 0]\nassert op_padto3_dropwhileneg_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_dropwhileneg_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_dropwhileneg_dropfirst([3, 1, 2]) == [1, 2]\nassert op_padto3_dropwhileneg_dropfirst([10]) == [0, 0]\nassert op_padto3_dropwhileneg_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_dropwhileneg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_dropfirst_dec_oremptyzero", "entry_point": "op_dropfirst_dec_oremptyzero", "primitives": ["dropfirst", "dec", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then if empty, use a single zero.", "solution": "def op_dropfirst_dec_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_dec_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_dec_oremptyzero([]) == [0]\nassert op_dropfirst_dec_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dropfirst_dec_oremptyzero([5, 5, 5]) == [4, 4]\nassert op_dropfirst_dec_oremptyzero([3, 1, 2]) == [0, 1]\nassert op_dropfirst_dec_oremptyzero([10]) == [0]\nassert op_dropfirst_dec_oremptyzero([2, 4, 6]) == [3, 5]\nassert op_dropfirst_dec_oremptyzero([-7, 12, -7]) == [11, -8]"}
{"id": "op_inc_trimends_allpos", "entry_point": "op_inc_trimends_allpos", "primitives": ["inc", "trimends", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_inc_trimends_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_trimends_allpos([1, 2, 3, 4]) == True\nassert op_inc_trimends_allpos([]) == True\nassert op_inc_trimends_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_trimends_allpos([5, 5, 5]) == True\nassert op_inc_trimends_allpos([3, 1, 2]) == True\nassert op_inc_trimends_allpos([10]) == True\nassert op_inc_trimends_allpos([2, 4, 6]) == True\nassert op_inc_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_div3_sortd", "entry_point": "op_takewhilepos_div3_sortd", "primitives": ["takewhilepos", "div3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three, then sort descending.", "solution": "def op_takewhilepos_div3_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_div3_sortd([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_div3_sortd([]) == []\nassert op_takewhilepos_div3_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_div3_sortd([5, 5, 5]) == []\nassert op_takewhilepos_div3_sortd([3, 1, 2]) == [3]\nassert op_takewhilepos_div3_sortd([10]) == []\nassert op_takewhilepos_div3_sortd([2, 4, 6]) == [6]\nassert op_takewhilepos_div3_sortd([-7, 12, -7]) == []"}
{"id": "op_odds_evens_min", "entry_point": "op_odds_evens_min", "primitives": ["odds", "evens", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_odds_evens_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_odds_evens_min([1, 2, 3, 4]) == 0\nassert op_odds_evens_min([]) == 0\nassert op_odds_evens_min([-2, -1, 0, 1, 2]) == 0\nassert op_odds_evens_min([5, 5, 5]) == 0\nassert op_odds_evens_min([3, 1, 2]) == 0\nassert op_odds_evens_min([10]) == 0\nassert op_odds_evens_min([2, 4, 6]) == 0\nassert op_odds_evens_min([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_sortd_trimends", "entry_point": "op_dropwhileneg_sortd_trimends", "primitives": ["dropwhileneg", "sortd", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending, then drop the first and last elements.", "solution": "def op_dropwhileneg_sortd_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_sortd_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_dropwhileneg_sortd_trimends([]) == []\nassert op_dropwhileneg_sortd_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_sortd_trimends([5, 5, 5]) == [5]\nassert op_dropwhileneg_sortd_trimends([3, 1, 2]) == [2]\nassert op_dropwhileneg_sortd_trimends([10]) == []\nassert op_dropwhileneg_sortd_trimends([2, 4, 6]) == [4]\nassert op_dropwhileneg_sortd_trimends([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_clamp10_sortabs", "entry_point": "op_takewhilepos_clamp10_sortabs", "primitives": ["takewhilepos", "clamp10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then sort by absolute value.", "solution": "def op_takewhilepos_clamp10_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_clamp10_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_clamp10_sortabs([]) == []\nassert op_takewhilepos_clamp10_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_clamp10_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_clamp10_sortabs([10]) == [10]\nassert op_takewhilepos_clamp10_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_clamp10_sortabs([-7, 12, -7]) == []"}
{"id": "op_negate_neg_pos", "entry_point": "op_negate_neg_pos", "primitives": ["negate", "neg", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then keep the positive numbers.", "solution": "def op_negate_neg_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_neg_pos([1, 2, 3, 4]) == []\nassert op_negate_neg_pos([]) == []\nassert op_negate_neg_pos([-2, -1, 0, 1, 2]) == []\nassert op_negate_neg_pos([5, 5, 5]) == []\nassert op_negate_neg_pos([3, 1, 2]) == []\nassert op_negate_neg_pos([10]) == []\nassert op_negate_neg_pos([2, 4, 6]) == []\nassert op_negate_neg_pos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_clamp10_sum", "entry_point": "op_dropfirst_clamp10_sum", "primitives": ["dropfirst", "clamp10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then return their sum.", "solution": "def op_dropfirst_clamp10_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_dropfirst_clamp10_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_clamp10_sum([]) == 0\nassert op_dropfirst_clamp10_sum([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_clamp10_sum([5, 5, 5]) == 10\nassert op_dropfirst_clamp10_sum([3, 1, 2]) == 3\nassert op_dropfirst_clamp10_sum([10]) == 0\nassert op_dropfirst_clamp10_sum([2, 4, 6]) == 10\nassert op_dropfirst_clamp10_sum([-7, 12, -7]) == 3"}
{"id": "op_takewhilepos_beforezero_neg", "entry_point": "op_takewhilepos_beforezero_neg", "primitives": ["takewhilepos", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_takewhilepos_beforezero_neg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_takewhilepos_beforezero_neg([1, 2, 3, 4]) == []\nassert op_takewhilepos_beforezero_neg([]) == []\nassert op_takewhilepos_beforezero_neg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_neg([5, 5, 5]) == []\nassert op_takewhilepos_beforezero_neg([3, 1, 2]) == []\nassert op_takewhilepos_beforezero_neg([10]) == []\nassert op_takewhilepos_beforezero_neg([2, 4, 6]) == []\nassert op_takewhilepos_beforezero_neg([-7, 12, -7]) == []"}
{"id": "op_sortd_uniq_takewhilepos", "entry_point": "op_sortd_uniq_takewhilepos", "primitives": ["sortd", "uniq", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then take values while they are positive.", "solution": "def op_sortd_uniq_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_uniq_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_uniq_takewhilepos([]) == []\nassert op_sortd_uniq_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_uniq_takewhilepos([5, 5, 5]) == [5]\nassert op_sortd_uniq_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_uniq_takewhilepos([10]) == [10]\nassert op_sortd_uniq_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_uniq_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_add10_pos_square", "entry_point": "op_add10_pos_square", "primitives": ["add10", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then square each.", "solution": "def op_add10_pos_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_pos_square([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_pos_square([]) == []\nassert op_add10_pos_square([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_pos_square([5, 5, 5]) == [225, 225, 225]\nassert op_add10_pos_square([3, 1, 2]) == [169, 121, 144]\nassert op_add10_pos_square([10]) == [400]\nassert op_add10_pos_square([2, 4, 6]) == [144, 196, 256]\nassert op_add10_pos_square([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_first3_sorta_beforezero", "entry_point": "op_first3_sorta_beforezero", "primitives": ["first3", "sorta", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then keep everything before the first zero.", "solution": "def op_first3_sorta_beforezero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_first3_sorta_beforezero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta_beforezero([]) == []\nassert op_first3_sorta_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_sorta_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta_beforezero([10]) == [10]\nassert op_first3_sorta_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_uniq_padto3_trimends", "entry_point": "op_uniq_padto3_trimends", "primitives": ["uniq", "padto3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_uniq_padto3_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_padto3_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_padto3_trimends([]) == [0]\nassert op_uniq_padto3_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_uniq_padto3_trimends([5, 5, 5]) == [0]\nassert op_uniq_padto3_trimends([3, 1, 2]) == [1]\nassert op_uniq_padto3_trimends([10]) == [0]\nassert op_uniq_padto3_trimends([2, 4, 6]) == [4]\nassert op_uniq_padto3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_add10_dec", "entry_point": "op_oremptyzero_add10_dec", "primitives": ["oremptyzero", "add10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then subtract one from each.", "solution": "def op_oremptyzero_add10_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_add10_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_oremptyzero_add10_dec([]) == [9]\nassert op_oremptyzero_add10_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_oremptyzero_add10_dec([5, 5, 5]) == [14, 14, 14]\nassert op_oremptyzero_add10_dec([3, 1, 2]) == [12, 10, 11]\nassert op_oremptyzero_add10_dec([10]) == [19]\nassert op_oremptyzero_add10_dec([2, 4, 6]) == [11, 13, 15]\nassert op_oremptyzero_add10_dec([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_strip_uniqs_dropshort", "entry_point": "op_strip_uniqs_dropshort", "primitives": ["strip", "uniqs", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first, then drop strings shorter than three characters.", "solution": "def op_strip_uniqs_dropshort(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_strip_uniqs_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_strip_uniqs_dropshort([]) == []\nassert op_strip_uniqs_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_strip_uniqs_dropshort(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_strip_uniqs_dropshort(['x']) == []\nassert op_strip_uniqs_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_padto3_sorta_odds", "entry_point": "op_padto3_sorta_odds", "primitives": ["padto3", "sorta", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then keep the odd numbers.", "solution": "def op_padto3_sorta_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_sorta_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_sorta_odds([]) == []\nassert op_padto3_sorta_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_padto3_sorta_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sorta_odds([3, 1, 2]) == [1, 3]\nassert op_padto3_sorta_odds([10]) == []\nassert op_padto3_sorta_odds([2, 4, 6]) == []\nassert op_padto3_sorta_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_beforezero_len", "entry_point": "op_dropwhileneg_beforezero_len", "primitives": ["dropwhileneg", "beforezero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero, then return how many remain.", "solution": "def op_dropwhileneg_beforezero_len(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r)", "tests": "assert op_dropwhileneg_beforezero_len([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_beforezero_len([]) == 0\nassert op_dropwhileneg_beforezero_len([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_beforezero_len([5, 5, 5]) == 3\nassert op_dropwhileneg_beforezero_len([3, 1, 2]) == 3\nassert op_dropwhileneg_beforezero_len([10]) == 1\nassert op_dropwhileneg_beforezero_len([2, 4, 6]) == 3\nassert op_dropwhileneg_beforezero_len([-7, 12, -7]) == 2"}
{"id": "op_takewhilepos_negate_div3", "entry_point": "op_takewhilepos_negate_div3", "primitives": ["takewhilepos", "negate", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then keep multiples of three.", "solution": "def op_takewhilepos_negate_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_negate_div3([1, 2, 3, 4]) == [-3]\nassert op_takewhilepos_negate_div3([]) == []\nassert op_takewhilepos_negate_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_div3([5, 5, 5]) == []\nassert op_takewhilepos_negate_div3([3, 1, 2]) == [-3]\nassert op_takewhilepos_negate_div3([10]) == []\nassert op_takewhilepos_negate_div3([2, 4, 6]) == [-6]\nassert op_takewhilepos_negate_div3([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_dropwhileneg_negate", "entry_point": "op_oremptyzero_dropwhileneg_negate", "primitives": ["oremptyzero", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then negate each.", "solution": "def op_oremptyzero_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_oremptyzero_dropwhileneg_negate([]) == [0]\nassert op_oremptyzero_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_oremptyzero_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_oremptyzero_dropwhileneg_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_oremptyzero_dropwhileneg_negate([10]) == [-10]\nassert op_oremptyzero_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_oremptyzero_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_dropzeros_evens_negate", "entry_point": "op_dropzeros_evens_negate", "primitives": ["dropzeros", "evens", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then negate each.", "solution": "def op_dropzeros_evens_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropzeros_evens_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_dropzeros_evens_negate([]) == []\nassert op_dropzeros_evens_negate([-2, -1, 0, 1, 2]) == [2, -2]\nassert op_dropzeros_evens_negate([5, 5, 5]) == []\nassert op_dropzeros_evens_negate([3, 1, 2]) == [-2]\nassert op_dropzeros_evens_negate([10]) == [-10]\nassert op_dropzeros_evens_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_evens_negate([-7, 12, -7]) == [-12]"}
{"id": "op_dropfirst_oremptyzero_beforezero", "entry_point": "op_dropfirst_oremptyzero_beforezero", "primitives": ["dropfirst", "oremptyzero", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then keep everything before the first zero.", "solution": "def op_dropfirst_oremptyzero_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_oremptyzero_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_oremptyzero_beforezero([]) == []\nassert op_dropfirst_oremptyzero_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_oremptyzero_beforezero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_oremptyzero_beforezero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_oremptyzero_beforezero([10]) == []\nassert op_dropfirst_oremptyzero_beforezero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_oremptyzero_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_gt5_dropzeros_sortd", "entry_point": "op_gt5_dropzeros_sortd", "primitives": ["gt5", "dropzeros", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros, then sort descending.", "solution": "def op_gt5_dropzeros_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_dropzeros_sortd([1, 2, 3, 4]) == []\nassert op_gt5_dropzeros_sortd([]) == []\nassert op_gt5_dropzeros_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropzeros_sortd([5, 5, 5]) == []\nassert op_gt5_dropzeros_sortd([3, 1, 2]) == []\nassert op_gt5_dropzeros_sortd([10]) == [10]\nassert op_gt5_dropzeros_sortd([2, 4, 6]) == [6]\nassert op_gt5_dropzeros_sortd([-7, 12, -7]) == [12]"}
{"id": "op_evens_add10_sum", "entry_point": "op_evens_add10_sum", "primitives": ["evens", "add10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then return their sum.", "solution": "def op_evens_add10_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_evens_add10_sum([1, 2, 3, 4]) == 26\nassert op_evens_add10_sum([]) == 0\nassert op_evens_add10_sum([-2, -1, 0, 1, 2]) == 30\nassert op_evens_add10_sum([5, 5, 5]) == 0\nassert op_evens_add10_sum([3, 1, 2]) == 12\nassert op_evens_add10_sum([10]) == 20\nassert op_evens_add10_sum([2, 4, 6]) == 42\nassert op_evens_add10_sum([-7, 12, -7]) == 22"}
{"id": "op_rev_square_dropzeros", "entry_point": "op_rev_square_dropzeros", "primitives": ["rev", "square", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then drop the zeros.", "solution": "def op_rev_square_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_square_dropzeros([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_square_dropzeros([]) == []\nassert op_rev_square_dropzeros([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_rev_square_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_rev_square_dropzeros([3, 1, 2]) == [4, 1, 9]\nassert op_rev_square_dropzeros([10]) == [100]\nassert op_rev_square_dropzeros([2, 4, 6]) == [36, 16, 4]\nassert op_rev_square_dropzeros([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_first3_neg_oremptyzero", "entry_point": "op_first3_neg_oremptyzero", "primitives": ["first3", "neg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_first3_neg_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_first3_neg_oremptyzero([]) == [0]\nassert op_first3_neg_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_first3_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_first3_neg_oremptyzero([10]) == [0]\nassert op_first3_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_first3_neg_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_absval_clamp10_gt5", "entry_point": "op_absval_clamp10_gt5", "primitives": ["absval", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then keep values greater than five.", "solution": "def op_absval_clamp10_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_absval_clamp10_gt5([]) == []\nassert op_absval_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_clamp10_gt5([5, 5, 5]) == []\nassert op_absval_clamp10_gt5([3, 1, 2]) == []\nassert op_absval_clamp10_gt5([10]) == [10]\nassert op_absval_clamp10_gt5([2, 4, 6]) == [6]\nassert op_absval_clamp10_gt5([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_trimends_dec_neg", "entry_point": "op_trimends_dec_neg", "primitives": ["trimends", "dec", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then keep the negative numbers.", "solution": "def op_trimends_dec_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_dec_neg([1, 2, 3, 4]) == []\nassert op_trimends_dec_neg([]) == []\nassert op_trimends_dec_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_trimends_dec_neg([5, 5, 5]) == []\nassert op_trimends_dec_neg([3, 1, 2]) == []\nassert op_trimends_dec_neg([10]) == []\nassert op_trimends_dec_neg([2, 4, 6]) == []\nassert op_trimends_dec_neg([-7, 12, -7]) == []"}
{"id": "op_trimends_neg_dropwhileneg", "entry_point": "op_trimends_neg_dropwhileneg", "primitives": ["trimends", "neg", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then drop the leading negative values.", "solution": "def op_trimends_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_trimends_neg_dropwhileneg([]) == []\nassert op_trimends_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_trimends_neg_dropwhileneg([5, 5, 5]) == []\nassert op_trimends_neg_dropwhileneg([3, 1, 2]) == []\nassert op_trimends_neg_dropwhileneg([10]) == []\nassert op_trimends_neg_dropwhileneg([2, 4, 6]) == []\nassert op_trimends_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_beforezero_padto3_inc", "entry_point": "op_beforezero_padto3_inc", "primitives": ["beforezero", "padto3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then add one to each.", "solution": "def op_beforezero_padto3_inc(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_beforezero_padto3_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_beforezero_padto3_inc([]) == [1, 1, 1]\nassert op_beforezero_padto3_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_beforezero_padto3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_beforezero_padto3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_beforezero_padto3_inc([10]) == [11, 1, 1]\nassert op_beforezero_padto3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_beforezero_padto3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_square_gt5_dropwhileneg", "entry_point": "op_square_gt5_dropwhileneg", "primitives": ["square", "gt5", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then drop the leading negative values.", "solution": "def op_square_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_gt5_dropwhileneg([1, 2, 3, 4]) == [9, 16]\nassert op_square_gt5_dropwhileneg([]) == []\nassert op_square_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_square_gt5_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5_dropwhileneg([3, 1, 2]) == [9]\nassert op_square_gt5_dropwhileneg([10]) == [100]\nassert op_square_gt5_dropwhileneg([2, 4, 6]) == [16, 36]\nassert op_square_gt5_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_dropzeros_padto3_sortabs", "entry_point": "op_dropzeros_padto3_sortabs", "primitives": ["dropzeros", "padto3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_dropzeros_padto3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_padto3_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_padto3_sortabs([]) == [0, 0, 0]\nassert op_dropzeros_padto3_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_dropzeros_padto3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_padto3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_padto3_sortabs([10]) == [0, 0, 10]\nassert op_dropzeros_padto3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_padto3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_last3_first3_trimends", "entry_point": "op_last3_first3_trimends", "primitives": ["last3", "first3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then drop the first and last elements.", "solution": "def op_last3_first3_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_first3_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_first3_trimends([]) == []\nassert op_last3_first3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_first3_trimends([5, 5, 5]) == [5]\nassert op_last3_first3_trimends([3, 1, 2]) == [1]\nassert op_last3_first3_trimends([10]) == []\nassert op_last3_first3_trimends([2, 4, 6]) == [4]\nassert op_last3_first3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_odds_sortd_dec", "entry_point": "op_odds_sortd_dec", "primitives": ["odds", "sortd", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort descending, then subtract one from each.", "solution": "def op_odds_sortd_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_odds_sortd_dec([1, 2, 3, 4]) == [2, 0]\nassert op_odds_sortd_dec([]) == []\nassert op_odds_sortd_dec([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_odds_sortd_dec([5, 5, 5]) == [4, 4, 4]\nassert op_odds_sortd_dec([3, 1, 2]) == [2, 0]\nassert op_odds_sortd_dec([10]) == []\nassert op_odds_sortd_dec([2, 4, 6]) == []\nassert op_odds_sortd_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_gt5_dropfirst_square", "entry_point": "op_gt5_dropfirst_square", "primitives": ["gt5", "dropfirst", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then square each.", "solution": "def op_gt5_dropfirst_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_dropfirst_square([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_square([]) == []\nassert op_gt5_dropfirst_square([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_square([5, 5, 5]) == []\nassert op_gt5_dropfirst_square([3, 1, 2]) == []\nassert op_gt5_dropfirst_square([10]) == []\nassert op_gt5_dropfirst_square([2, 4, 6]) == []\nassert op_gt5_dropfirst_square([-7, 12, -7]) == []"}
{"id": "op_beforezero_evens_dropwhileneg", "entry_point": "op_beforezero_evens_dropwhileneg", "primitives": ["beforezero", "evens", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then drop the leading negative values.", "solution": "def op_beforezero_evens_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_evens_dropwhileneg([1, 2, 3, 4]) == [2, 4]\nassert op_beforezero_evens_dropwhileneg([]) == []\nassert op_beforezero_evens_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_evens_dropwhileneg([5, 5, 5]) == []\nassert op_beforezero_evens_dropwhileneg([3, 1, 2]) == [2]\nassert op_beforezero_evens_dropwhileneg([10]) == [10]\nassert op_beforezero_evens_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_evens_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_double_evens_oremptyzero", "entry_point": "op_double_evens_oremptyzero", "primitives": ["double", "evens", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then if empty, use a single zero.", "solution": "def op_double_evens_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_evens_oremptyzero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_evens_oremptyzero([]) == [0]\nassert op_double_evens_oremptyzero([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_evens_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_double_evens_oremptyzero([3, 1, 2]) == [6, 2, 4]\nassert op_double_evens_oremptyzero([10]) == [20]\nassert op_double_evens_oremptyzero([2, 4, 6]) == [4, 8, 12]\nassert op_double_evens_oremptyzero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_double_negate_odds", "entry_point": "op_double_negate_odds", "primitives": ["double", "negate", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then keep the odd numbers.", "solution": "def op_double_negate_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_negate_odds([1, 2, 3, 4]) == []\nassert op_double_negate_odds([]) == []\nassert op_double_negate_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_negate_odds([5, 5, 5]) == []\nassert op_double_negate_odds([3, 1, 2]) == []\nassert op_double_negate_odds([10]) == []\nassert op_double_negate_odds([2, 4, 6]) == []\nassert op_double_negate_odds([-7, 12, -7]) == []"}
{"id": "op_add10_div3_firsteven", "entry_point": "op_add10_div3_firsteven", "primitives": ["add10", "div3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then return the first even value (0 if none).", "solution": "def op_add10_div3_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_div3_firsteven([1, 2, 3, 4]) == 12\nassert op_add10_div3_firsteven([]) == 0\nassert op_add10_div3_firsteven([-2, -1, 0, 1, 2]) == 12\nassert op_add10_div3_firsteven([5, 5, 5]) == 0\nassert op_add10_div3_firsteven([3, 1, 2]) == 12\nassert op_add10_div3_firsteven([10]) == 0\nassert op_add10_div3_firsteven([2, 4, 6]) == 12\nassert op_add10_div3_firsteven([-7, 12, -7]) == 0"}
{"id": "op_takewhilepos_sortd_dropwhileneg", "entry_point": "op_takewhilepos_sortd_dropwhileneg", "primitives": ["takewhilepos", "sortd", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort descending, then drop the leading negative values.", "solution": "def op_takewhilepos_sortd_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_sortd_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_sortd_dropwhileneg([]) == []\nassert op_takewhilepos_sortd_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortd_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortd_dropwhileneg([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_sortd_dropwhileneg([10]) == [10]\nassert op_takewhilepos_sortd_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_sortd_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_add10_pos_absval", "entry_point": "op_add10_pos_absval", "primitives": ["add10", "pos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_add10_pos_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_pos_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_pos_absval([]) == []\nassert op_add10_pos_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_pos_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_pos_absval([3, 1, 2]) == [13, 11, 12]\nassert op_add10_pos_absval([10]) == [20]\nassert op_add10_pos_absval([2, 4, 6]) == [12, 14, 16]\nassert op_add10_pos_absval([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_odds_neg_dropfirst", "entry_point": "op_odds_neg_dropfirst", "primitives": ["odds", "neg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then drop the first element.", "solution": "def op_odds_neg_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_odds_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_odds_neg_dropfirst([]) == []\nassert op_odds_neg_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_odds_neg_dropfirst([5, 5, 5]) == []\nassert op_odds_neg_dropfirst([3, 1, 2]) == []\nassert op_odds_neg_dropfirst([10]) == []\nassert op_odds_neg_dropfirst([2, 4, 6]) == []\nassert op_odds_neg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_double_sorta_sum", "entry_point": "op_double_sorta_sum", "primitives": ["double", "sorta", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending, then return their sum.", "solution": "def op_double_sorta_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_double_sorta_sum([1, 2, 3, 4]) == 20\nassert op_double_sorta_sum([]) == 0\nassert op_double_sorta_sum([-2, -1, 0, 1, 2]) == 0\nassert op_double_sorta_sum([5, 5, 5]) == 30\nassert op_double_sorta_sum([3, 1, 2]) == 12\nassert op_double_sorta_sum([10]) == 20\nassert op_double_sorta_sum([2, 4, 6]) == 24\nassert op_double_sorta_sum([-7, 12, -7]) == -4"}
{"id": "op_takewhilepos_evens_dropwhileneg", "entry_point": "op_takewhilepos_evens_dropwhileneg", "primitives": ["takewhilepos", "evens", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers, then drop the leading negative values.", "solution": "def op_takewhilepos_evens_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_evens_dropwhileneg([1, 2, 3, 4]) == [2, 4]\nassert op_takewhilepos_evens_dropwhileneg([]) == []\nassert op_takewhilepos_evens_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens_dropwhileneg([5, 5, 5]) == []\nassert op_takewhilepos_evens_dropwhileneg([3, 1, 2]) == [2]\nassert op_takewhilepos_evens_dropwhileneg([10]) == [10]\nassert op_takewhilepos_evens_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_evens_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_last3_div3_len", "entry_point": "op_last3_div3_len", "primitives": ["last3", "div3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then return how many remain.", "solution": "def op_last3_div3_len(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_last3_div3_len([1, 2, 3, 4]) == 1\nassert op_last3_div3_len([]) == 0\nassert op_last3_div3_len([-2, -1, 0, 1, 2]) == 1\nassert op_last3_div3_len([5, 5, 5]) == 0\nassert op_last3_div3_len([3, 1, 2]) == 1\nassert op_last3_div3_len([10]) == 0\nassert op_last3_div3_len([2, 4, 6]) == 1\nassert op_last3_div3_len([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_dropwhileneg_issorted", "entry_point": "op_dropzeros_dropwhileneg_issorted", "primitives": ["dropzeros", "dropwhileneg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_dropzeros_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_dropwhileneg_issorted([]) == True\nassert op_dropzeros_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_dropzeros_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_dropzeros_dropwhileneg_issorted([10]) == True\nassert op_dropzeros_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_dropzeros_dropwhileneg_issorted([-7, 12, -7]) == False"}
{"id": "op_ages_inc_sum", "entry_point": "op_ages_inc_sum", "primitives": ["ages", "inc", "sum"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add one to each, then return their sum.", "solution": "def op_ages_inc_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_ages_inc_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 50\nassert op_ages_inc_sum([]) == 0\nassert op_ages_inc_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 103\nassert op_ages_inc_sum([{'name': 'Fi', 'age': 41}]) == 42"}
{"id": "op_first3_sortd_issorted", "entry_point": "op_first3_sortd_issorted", "primitives": ["first3", "sortd", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_first3_sortd_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_first3_sortd_issorted([1, 2, 3, 4]) == False\nassert op_first3_sortd_issorted([]) == True\nassert op_first3_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_first3_sortd_issorted([5, 5, 5]) == True\nassert op_first3_sortd_issorted([3, 1, 2]) == False\nassert op_first3_sortd_issorted([10]) == True\nassert op_first3_sortd_issorted([2, 4, 6]) == False\nassert op_first3_sortd_issorted([-7, 12, -7]) == False"}
{"id": "op_dropfirst_sortabs_odds", "entry_point": "op_dropfirst_sortabs_odds", "primitives": ["dropfirst", "sortabs", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then keep the odd numbers.", "solution": "def op_dropfirst_sortabs_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_sortabs_odds([1, 2, 3, 4]) == [3]\nassert op_dropfirst_sortabs_odds([]) == []\nassert op_dropfirst_sortabs_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_sortabs_odds([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortabs_odds([3, 1, 2]) == [1]\nassert op_dropfirst_sortabs_odds([10]) == []\nassert op_dropfirst_sortabs_odds([2, 4, 6]) == []\nassert op_dropfirst_sortabs_odds([-7, 12, -7]) == [-7]"}
{"id": "op_first3_dec_min", "entry_point": "op_first3_dec_min", "primitives": ["first3", "dec", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_first3_dec_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_first3_dec_min([1, 2, 3, 4]) == 0\nassert op_first3_dec_min([]) == 0\nassert op_first3_dec_min([-2, -1, 0, 1, 2]) == -3\nassert op_first3_dec_min([5, 5, 5]) == 4\nassert op_first3_dec_min([3, 1, 2]) == 0\nassert op_first3_dec_min([10]) == 9\nassert op_first3_dec_min([2, 4, 6]) == 1\nassert op_first3_dec_min([-7, 12, -7]) == -8"}
{"id": "op_div3_dropfirst_sortabs", "entry_point": "op_div3_dropfirst_sortabs", "primitives": ["div3", "dropfirst", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then sort by absolute value.", "solution": "def op_div3_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_dropfirst_sortabs([1, 2, 3, 4]) == []\nassert op_div3_dropfirst_sortabs([]) == []\nassert op_div3_dropfirst_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst_sortabs([5, 5, 5]) == []\nassert op_div3_dropfirst_sortabs([3, 1, 2]) == []\nassert op_div3_dropfirst_sortabs([10]) == []\nassert op_div3_dropfirst_sortabs([2, 4, 6]) == []\nassert op_div3_dropfirst_sortabs([-7, 12, -7]) == []"}
{"id": "op_rev_div3_beforezero", "entry_point": "op_rev_div3_beforezero", "primitives": ["rev", "div3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_rev_div3_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_div3_beforezero([1, 2, 3, 4]) == [3]\nassert op_rev_div3_beforezero([]) == []\nassert op_rev_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_rev_div3_beforezero([5, 5, 5]) == []\nassert op_rev_div3_beforezero([3, 1, 2]) == [3]\nassert op_rev_div3_beforezero([10]) == []\nassert op_rev_div3_beforezero([2, 4, 6]) == [6]\nassert op_rev_div3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_square_sortd_takewhilepos", "entry_point": "op_square_sortd_takewhilepos", "primitives": ["square", "sortd", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then take values while they are positive.", "solution": "def op_square_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_square_sortd_takewhilepos([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_sortd_takewhilepos([]) == []\nassert op_square_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [4, 4, 1, 1]\nassert op_square_sortd_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortd_takewhilepos([3, 1, 2]) == [9, 4, 1]\nassert op_square_sortd_takewhilepos([10]) == [100]\nassert op_square_sortd_takewhilepos([2, 4, 6]) == [36, 16, 4]\nassert op_square_sortd_takewhilepos([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_beforezero_trimends_len", "entry_point": "op_beforezero_trimends_len", "primitives": ["beforezero", "trimends", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then return how many remain.", "solution": "def op_beforezero_trimends_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_beforezero_trimends_len([1, 2, 3, 4]) == 2\nassert op_beforezero_trimends_len([]) == 0\nassert op_beforezero_trimends_len([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_trimends_len([5, 5, 5]) == 1\nassert op_beforezero_trimends_len([3, 1, 2]) == 1\nassert op_beforezero_trimends_len([10]) == 0\nassert op_beforezero_trimends_len([2, 4, 6]) == 1\nassert op_beforezero_trimends_len([-7, 12, -7]) == 1"}
{"id": "op_padto3_add10_trimends", "entry_point": "op_padto3_add10_trimends", "primitives": ["padto3", "add10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then drop the first and last elements.", "solution": "def op_padto3_add10_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_add10_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_padto3_add10_trimends([]) == [10]\nassert op_padto3_add10_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_padto3_add10_trimends([5, 5, 5]) == [15]\nassert op_padto3_add10_trimends([3, 1, 2]) == [11]\nassert op_padto3_add10_trimends([10]) == [10]\nassert op_padto3_add10_trimends([2, 4, 6]) == [14]\nassert op_padto3_add10_trimends([-7, 12, -7]) == [22]"}
{"id": "op_odds_add10_beforezero", "entry_point": "op_odds_add10_beforezero", "primitives": ["odds", "add10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then keep everything before the first zero.", "solution": "def op_odds_add10_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_odds_add10_beforezero([1, 2, 3, 4]) == [11, 13]\nassert op_odds_add10_beforezero([]) == []\nassert op_odds_add10_beforezero([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_add10_beforezero([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10_beforezero([3, 1, 2]) == [13, 11]\nassert op_odds_add10_beforezero([10]) == []\nassert op_odds_add10_beforezero([2, 4, 6]) == []\nassert op_odds_add10_beforezero([-7, 12, -7]) == [3, 3]"}
{"id": "op_beforezero_inc_haszero", "entry_point": "op_beforezero_inc_haszero", "primitives": ["beforezero", "inc", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then return whether the list contains a zero.", "solution": "def op_beforezero_inc_haszero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_beforezero_inc_haszero([1, 2, 3, 4]) == False\nassert op_beforezero_inc_haszero([]) == False\nassert op_beforezero_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_inc_haszero([5, 5, 5]) == False\nassert op_beforezero_inc_haszero([3, 1, 2]) == False\nassert op_beforezero_inc_haszero([10]) == False\nassert op_beforezero_inc_haszero([2, 4, 6]) == False\nassert op_beforezero_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_sortabs_clamp10_max", "entry_point": "op_sortabs_clamp10_max", "primitives": ["sortabs", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_sortabs_clamp10_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_sortabs_clamp10_max([1, 2, 3, 4]) == 4\nassert op_sortabs_clamp10_max([]) == 0\nassert op_sortabs_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_clamp10_max([5, 5, 5]) == 5\nassert op_sortabs_clamp10_max([3, 1, 2]) == 3\nassert op_sortabs_clamp10_max([10]) == 10\nassert op_sortabs_clamp10_max([2, 4, 6]) == 6\nassert op_sortabs_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_add10_sorta_trimends", "entry_point": "op_add10_sorta_trimends", "primitives": ["add10", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then drop the first and last elements.", "solution": "def op_add10_sorta_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_sorta_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_add10_sorta_trimends([]) == []\nassert op_add10_sorta_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_sorta_trimends([5, 5, 5]) == [15]\nassert op_add10_sorta_trimends([3, 1, 2]) == [12]\nassert op_add10_sorta_trimends([10]) == []\nassert op_add10_sorta_trimends([2, 4, 6]) == [14]\nassert op_add10_sorta_trimends([-7, 12, -7]) == [3]"}
{"id": "op_sortabs_evens_dropzeros", "entry_point": "op_sortabs_evens_dropzeros", "primitives": ["sortabs", "evens", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then drop the zeros.", "solution": "def op_sortabs_evens_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_evens_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_evens_dropzeros([]) == []\nassert op_sortabs_evens_dropzeros([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_sortabs_evens_dropzeros([5, 5, 5]) == []\nassert op_sortabs_evens_dropzeros([3, 1, 2]) == [2]\nassert op_sortabs_evens_dropzeros([10]) == [10]\nassert op_sortabs_evens_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_evens_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_negate_evens_sortd", "entry_point": "op_negate_evens_sortd", "primitives": ["negate", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers, then sort descending.", "solution": "def op_negate_evens_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_evens_sortd([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_evens_sortd([]) == []\nassert op_negate_evens_sortd([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_evens_sortd([5, 5, 5]) == []\nassert op_negate_evens_sortd([3, 1, 2]) == [-2]\nassert op_negate_evens_sortd([10]) == [-10]\nassert op_negate_evens_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_evens_sortd([-7, 12, -7]) == [-12]"}
{"id": "op_trimends_dropzeros_sortabs", "entry_point": "op_trimends_dropzeros_sortabs", "primitives": ["trimends", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then sort by absolute value.", "solution": "def op_trimends_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_dropzeros_sortabs([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_dropzeros_sortabs([]) == []\nassert op_trimends_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_dropzeros_sortabs([5, 5, 5]) == [5]\nassert op_trimends_dropzeros_sortabs([3, 1, 2]) == [1]\nassert op_trimends_dropzeros_sortabs([10]) == []\nassert op_trimends_dropzeros_sortabs([2, 4, 6]) == [4]\nassert op_trimends_dropzeros_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_sorta_clamp10_gt5", "entry_point": "op_sorta_clamp10_gt5", "primitives": ["sorta", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then keep values greater than five.", "solution": "def op_sorta_clamp10_gt5(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sorta_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_sorta_clamp10_gt5([]) == []\nassert op_sorta_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sorta_clamp10_gt5([5, 5, 5]) == []\nassert op_sorta_clamp10_gt5([3, 1, 2]) == []\nassert op_sorta_clamp10_gt5([10]) == [10]\nassert op_sorta_clamp10_gt5([2, 4, 6]) == [6]\nassert op_sorta_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_ages_dropwhileneg_dropfirst", "entry_point": "op_ages_dropwhileneg_dropfirst", "primitives": ["ages", "dropwhileneg", "dropfirst"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then drop the first element.", "solution": "def op_ages_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_ages_dropwhileneg_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropwhileneg_dropfirst([]) == []\nassert op_ages_dropwhileneg_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropwhileneg_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dropfirst_beforezero_div3", "entry_point": "op_dropfirst_beforezero_div3", "primitives": ["dropfirst", "beforezero", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_dropfirst_beforezero_div3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropfirst_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_beforezero_div3([]) == []\nassert op_dropfirst_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_beforezero_div3([5, 5, 5]) == []\nassert op_dropfirst_beforezero_div3([3, 1, 2]) == []\nassert op_dropfirst_beforezero_div3([10]) == []\nassert op_dropfirst_beforezero_div3([2, 4, 6]) == [6]\nassert op_dropfirst_beforezero_div3([-7, 12, -7]) == [12]"}
{"id": "op_rev_sorta_max", "entry_point": "op_rev_sorta_max", "primitives": ["rev", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_rev_sorta_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_rev_sorta_max([1, 2, 3, 4]) == 4\nassert op_rev_sorta_max([]) == 0\nassert op_rev_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_sorta_max([5, 5, 5]) == 5\nassert op_rev_sorta_max([3, 1, 2]) == 3\nassert op_rev_sorta_max([10]) == 10\nassert op_rev_sorta_max([2, 4, 6]) == 6\nassert op_rev_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_sortalpha_upper_longest", "entry_point": "op_sortalpha_upper_longest", "primitives": ["sortalpha", "upper", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then uppercase each string, then return the longest string (empty if none).", "solution": "def op_sortalpha_upper_longest(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.upper() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_sortalpha_upper_longest(['Hello', 'world']) == 'HELLO'\nassert op_sortalpha_upper_longest([]) == ''\nassert op_sortalpha_upper_longest(['  a ', '', 'BC', 'bc']) == '  A '\nassert op_sortalpha_upper_longest(['one', 'one', 'Two']) == 'TWO'\nassert op_sortalpha_upper_longest(['x']) == 'X'\nassert op_sortalpha_upper_longest(['abc', 'de', '']) == 'ABC'"}
{"id": "op_pos_padto3_haszero", "entry_point": "op_pos_padto3_haszero", "primitives": ["pos", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_pos_padto3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_pos_padto3_haszero([1, 2, 3, 4]) == False\nassert op_pos_padto3_haszero([]) == True\nassert op_pos_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_pos_padto3_haszero([5, 5, 5]) == False\nassert op_pos_padto3_haszero([3, 1, 2]) == False\nassert op_pos_padto3_haszero([10]) == True\nassert op_pos_padto3_haszero([2, 4, 6]) == False\nassert op_pos_padto3_haszero([-7, 12, -7]) == True"}
{"id": "op_rev_clamp10_dropzeros", "entry_point": "op_rev_clamp10_dropzeros", "primitives": ["rev", "clamp10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then drop the zeros.", "solution": "def op_rev_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_clamp10_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_clamp10_dropzeros([]) == []\nassert op_rev_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_rev_clamp10_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_rev_clamp10_dropzeros([10]) == [10]\nassert op_rev_clamp10_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_rev_clamp10_dropzeros([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_inc_neg_clamp10", "entry_point": "op_inc_neg_clamp10", "primitives": ["inc", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then cap each value at 10.", "solution": "def op_inc_neg_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_neg_clamp10([1, 2, 3, 4]) == []\nassert op_inc_neg_clamp10([]) == []\nassert op_inc_neg_clamp10([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_clamp10([5, 5, 5]) == []\nassert op_inc_neg_clamp10([3, 1, 2]) == []\nassert op_inc_neg_clamp10([10]) == []\nassert op_inc_neg_clamp10([2, 4, 6]) == []\nassert op_inc_neg_clamp10([-7, 12, -7]) == [-6, -6]"}
{"id": "op_first3_evens_sorta", "entry_point": "op_first3_evens_sorta", "primitives": ["first3", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the even numbers, then sort ascending.", "solution": "def op_first3_evens_sorta(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_first3_evens_sorta([1, 2, 3, 4]) == [2]\nassert op_first3_evens_sorta([]) == []\nassert op_first3_evens_sorta([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_first3_evens_sorta([5, 5, 5]) == []\nassert op_first3_evens_sorta([3, 1, 2]) == [2]\nassert op_first3_evens_sorta([10]) == [10]\nassert op_first3_evens_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_first3_evens_sorta([-7, 12, -7]) == [12]"}
{"id": "op_trimends_oremptyzero_negate", "entry_point": "op_trimends_oremptyzero_negate", "primitives": ["trimends", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then negate each.", "solution": "def op_trimends_oremptyzero_negate(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_trimends_oremptyzero_negate([1, 2, 3, 4]) == [-2, -3]\nassert op_trimends_oremptyzero_negate([]) == [0]\nassert op_trimends_oremptyzero_negate([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_oremptyzero_negate([5, 5, 5]) == [-5]\nassert op_trimends_oremptyzero_negate([3, 1, 2]) == [-1]\nassert op_trimends_oremptyzero_negate([10]) == [0]\nassert op_trimends_oremptyzero_negate([2, 4, 6]) == [-4]\nassert op_trimends_oremptyzero_negate([-7, 12, -7]) == [-12]"}
{"id": "op_absval_double_gt5", "entry_point": "op_absval_double_gt5", "primitives": ["absval", "double", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then double each, then keep values greater than five.", "solution": "def op_absval_double_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_absval_double_gt5([]) == []\nassert op_absval_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_absval_double_gt5([3, 1, 2]) == [6]\nassert op_absval_double_gt5([10]) == [20]\nassert op_absval_double_gt5([2, 4, 6]) == [8, 12]\nassert op_absval_double_gt5([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_pos_first3_allpos", "entry_point": "op_pos_first3_allpos", "primitives": ["pos", "first3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then return whether all values are positive.", "solution": "def op_pos_first3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_pos_first3_allpos([1, 2, 3, 4]) == True\nassert op_pos_first3_allpos([]) == True\nassert op_pos_first3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_pos_first3_allpos([5, 5, 5]) == True\nassert op_pos_first3_allpos([3, 1, 2]) == True\nassert op_pos_first3_allpos([10]) == True\nassert op_pos_first3_allpos([2, 4, 6]) == True\nassert op_pos_first3_allpos([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_gt5_dropzeros", "entry_point": "op_dropwhileneg_gt5_dropzeros", "primitives": ["dropwhileneg", "gt5", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then drop the zeros.", "solution": "def op_dropwhileneg_gt5_dropzeros(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropwhileneg_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_dropwhileneg_gt5_dropzeros([]) == []\nassert op_dropwhileneg_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_gt5_dropzeros([5, 5, 5]) == []\nassert op_dropwhileneg_gt5_dropzeros([3, 1, 2]) == []\nassert op_dropwhileneg_gt5_dropzeros([10]) == [10]\nassert op_dropwhileneg_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_dropwhileneg_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_square_alldistinct", "entry_point": "op_sortabs_square_alldistinct", "primitives": ["sortabs", "square", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then return whether all values are distinct.", "solution": "def op_sortabs_square_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_square_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_square_alldistinct([]) == True\nassert op_sortabs_square_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_square_alldistinct([5, 5, 5]) == False\nassert op_sortabs_square_alldistinct([3, 1, 2]) == True\nassert op_sortabs_square_alldistinct([10]) == True\nassert op_sortabs_square_alldistinct([2, 4, 6]) == True\nassert op_sortabs_square_alldistinct([-7, 12, -7]) == False"}
{"id": "op_beforezero_takewhilepos_alldistinct", "entry_point": "op_beforezero_takewhilepos_alldistinct", "primitives": ["beforezero", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_beforezero_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_takewhilepos_alldistinct([]) == True\nassert op_beforezero_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_beforezero_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_beforezero_takewhilepos_alldistinct([10]) == True\nassert op_beforezero_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_beforezero_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_oremptyzero_inc", "entry_point": "op_dropwhileneg_oremptyzero_inc", "primitives": ["dropwhileneg", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then add one to each.", "solution": "def op_dropwhileneg_oremptyzero_inc(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropwhileneg_oremptyzero_inc([]) == [1]\nassert op_dropwhileneg_oremptyzero_inc([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_dropwhileneg_oremptyzero_inc([10]) == [11]\nassert op_dropwhileneg_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_dropwhileneg_oremptyzero_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_oremptyzero_double_square", "entry_point": "op_oremptyzero_double_square", "primitives": ["oremptyzero", "double", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then square each.", "solution": "def op_oremptyzero_double_square(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_oremptyzero_double_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_oremptyzero_double_square([]) == [0]\nassert op_oremptyzero_double_square([-2, -1, 0, 1, 2]) == [16, 4, 0, 4, 16]\nassert op_oremptyzero_double_square([5, 5, 5]) == [100, 100, 100]\nassert op_oremptyzero_double_square([3, 1, 2]) == [36, 4, 16]\nassert op_oremptyzero_double_square([10]) == [400]\nassert op_oremptyzero_double_square([2, 4, 6]) == [16, 64, 144]\nassert op_oremptyzero_double_square([-7, 12, -7]) == [196, 576, 196]"}
{"id": "op_ages_dropfirst_square", "entry_point": "op_ages_dropfirst_square", "primitives": ["ages", "dropfirst", "square"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then square each.", "solution": "def op_ages_dropfirst_square(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_ages_dropfirst_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [144]\nassert op_ages_dropfirst_square([]) == []\nassert op_ages_dropfirst_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [4225, 289]\nassert op_ages_dropfirst_square([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_takewhilepos_div3_counteven", "entry_point": "op_takewhilepos_div3_counteven", "primitives": ["takewhilepos", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three, then return how many values are even.", "solution": "def op_takewhilepos_div3_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_div3_counteven([1, 2, 3, 4]) == 0\nassert op_takewhilepos_div3_counteven([]) == 0\nassert op_takewhilepos_div3_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_div3_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_div3_counteven([3, 1, 2]) == 0\nassert op_takewhilepos_div3_counteven([10]) == 0\nassert op_takewhilepos_div3_counteven([2, 4, 6]) == 1\nassert op_takewhilepos_div3_counteven([-7, 12, -7]) == 0"}
{"id": "op_sortabs_double_first3", "entry_point": "op_sortabs_double_first3", "primitives": ["sortabs", "double", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then keep only the first three.", "solution": "def op_sortabs_double_first3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_sortabs_double_first3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_sortabs_double_first3([]) == []\nassert op_sortabs_double_first3([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_double_first3([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double_first3([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_double_first3([10]) == [20]\nassert op_sortabs_double_first3([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_double_first3([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropfirst_evens_trimends", "entry_point": "op_dropfirst_evens_trimends", "primitives": ["dropfirst", "evens", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then drop the first and last elements.", "solution": "def op_dropfirst_evens_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_evens_trimends([1, 2, 3, 4]) == []\nassert op_dropfirst_evens_trimends([]) == []\nassert op_dropfirst_evens_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_evens_trimends([5, 5, 5]) == []\nassert op_dropfirst_evens_trimends([3, 1, 2]) == []\nassert op_dropfirst_evens_trimends([10]) == []\nassert op_dropfirst_evens_trimends([2, 4, 6]) == []\nassert op_dropfirst_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_uniqs_sortalpha_counts", "entry_point": "op_uniqs_sortalpha_counts", "primitives": ["uniqs", "sortalpha", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically, then return how many strings remain.", "solution": "def op_uniqs_sortalpha_counts(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return len(r)", "tests": "assert op_uniqs_sortalpha_counts(['Hello', 'world']) == 2\nassert op_uniqs_sortalpha_counts([]) == 0\nassert op_uniqs_sortalpha_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_uniqs_sortalpha_counts(['one', 'one', 'Two']) == 2\nassert op_uniqs_sortalpha_counts(['x']) == 1\nassert op_uniqs_sortalpha_counts(['abc', 'de', '']) == 3"}
{"id": "op_dropfirst_square_allpos", "entry_point": "op_dropfirst_square_allpos", "primitives": ["dropfirst", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then return whether all values are positive.", "solution": "def op_dropfirst_square_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_square_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_square_allpos([]) == True\nassert op_dropfirst_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_square_allpos([5, 5, 5]) == True\nassert op_dropfirst_square_allpos([3, 1, 2]) == True\nassert op_dropfirst_square_allpos([10]) == True\nassert op_dropfirst_square_allpos([2, 4, 6]) == True\nassert op_dropfirst_square_allpos([-7, 12, -7]) == True"}
{"id": "op_odds_inc_negate", "entry_point": "op_odds_inc_negate", "primitives": ["odds", "inc", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then negate each.", "solution": "def op_odds_inc_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_inc_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_odds_inc_negate([]) == []\nassert op_odds_inc_negate([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_odds_inc_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_odds_inc_negate([3, 1, 2]) == [-4, -2]\nassert op_odds_inc_negate([10]) == []\nassert op_odds_inc_negate([2, 4, 6]) == []\nassert op_odds_inc_negate([-7, 12, -7]) == [6, 6]"}
{"id": "op_ages_rev_min", "entry_point": "op_ages_rev_min", "primitives": ["ages", "rev", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_ages_rev_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_ages_rev_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_rev_min([]) == 0\nassert op_ages_rev_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_rev_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_dropfirst_div3_alldistinct", "entry_point": "op_dropfirst_div3_alldistinct", "primitives": ["dropfirst", "div3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep multiples of three, then return whether all values are distinct.", "solution": "def op_dropfirst_div3_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_div3_alldistinct([]) == True\nassert op_dropfirst_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_div3_alldistinct([5, 5, 5]) == True\nassert op_dropfirst_div3_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_div3_alldistinct([10]) == True\nassert op_dropfirst_div3_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_uniq_dropfirst_haszero", "entry_point": "op_uniq_dropfirst_haszero", "primitives": ["uniq", "dropfirst", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then return whether the list contains a zero.", "solution": "def op_uniq_dropfirst_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return 0 in r", "tests": "assert op_uniq_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_uniq_dropfirst_haszero([]) == False\nassert op_uniq_dropfirst_haszero([-2, -1, 0, 1, 2]) == True\nassert op_uniq_dropfirst_haszero([5, 5, 5]) == False\nassert op_uniq_dropfirst_haszero([3, 1, 2]) == False\nassert op_uniq_dropfirst_haszero([10]) == False\nassert op_uniq_dropfirst_haszero([2, 4, 6]) == False\nassert op_uniq_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_first3_div3", "entry_point": "op_takewhilepos_first3_div3", "primitives": ["takewhilepos", "first3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then keep multiples of three.", "solution": "def op_takewhilepos_first3_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_first3_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_first3_div3([]) == []\nassert op_takewhilepos_first3_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_div3([5, 5, 5]) == []\nassert op_takewhilepos_first3_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_first3_div3([10]) == []\nassert op_takewhilepos_first3_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_first3_div3([-7, 12, -7]) == []"}
{"id": "op_dropfirst_odds_min", "entry_point": "op_dropfirst_odds_min", "primitives": ["dropfirst", "odds", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then return the minimum (0 if empty).", "solution": "def op_dropfirst_odds_min(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return min(r) if r else 0", "tests": "assert op_dropfirst_odds_min([1, 2, 3, 4]) == 3\nassert op_dropfirst_odds_min([]) == 0\nassert op_dropfirst_odds_min([-2, -1, 0, 1, 2]) == -1\nassert op_dropfirst_odds_min([5, 5, 5]) == 5\nassert op_dropfirst_odds_min([3, 1, 2]) == 1\nassert op_dropfirst_odds_min([10]) == 0\nassert op_dropfirst_odds_min([2, 4, 6]) == 0\nassert op_dropfirst_odds_min([-7, 12, -7]) == -7"}
{"id": "op_odds_sorta_takewhilepos", "entry_point": "op_odds_sorta_takewhilepos", "primitives": ["odds", "sorta", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then take values while they are positive.", "solution": "def op_odds_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_odds_sorta_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sorta_takewhilepos([]) == []\nassert op_odds_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_odds_sorta_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sorta_takewhilepos([3, 1, 2]) == [1, 3]\nassert op_odds_sorta_takewhilepos([10]) == []\nassert op_odds_sorta_takewhilepos([2, 4, 6]) == []\nassert op_odds_sorta_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_rev_beforezero_sortabs", "entry_point": "op_rev_beforezero_sortabs", "primitives": ["rev", "beforezero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then sort by absolute value.", "solution": "def op_rev_beforezero_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_beforezero_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_beforezero_sortabs([]) == []\nassert op_rev_beforezero_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_rev_beforezero_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_beforezero_sortabs([10]) == [10]\nassert op_rev_beforezero_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_beforezero_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropwhileneg_gt5_counteven", "entry_point": "op_dropwhileneg_gt5_counteven", "primitives": ["dropwhileneg", "gt5", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then return how many values are even.", "solution": "def op_dropwhileneg_gt5_counteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropwhileneg_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_dropwhileneg_gt5_counteven([]) == 0\nassert op_dropwhileneg_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_gt5_counteven([5, 5, 5]) == 0\nassert op_dropwhileneg_gt5_counteven([3, 1, 2]) == 0\nassert op_dropwhileneg_gt5_counteven([10]) == 1\nassert op_dropwhileneg_gt5_counteven([2, 4, 6]) == 1\nassert op_dropwhileneg_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortabs_dropwhileneg_evens", "entry_point": "op_sortabs_dropwhileneg_evens", "primitives": ["sortabs", "dropwhileneg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then keep the even numbers.", "solution": "def op_sortabs_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_dropwhileneg_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_dropwhileneg_evens([]) == []\nassert op_sortabs_dropwhileneg_evens([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_dropwhileneg_evens([5, 5, 5]) == []\nassert op_sortabs_dropwhileneg_evens([3, 1, 2]) == [2]\nassert op_sortabs_dropwhileneg_evens([10]) == [10]\nassert op_sortabs_dropwhileneg_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropwhileneg_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_beforezero_double", "entry_point": "op_sortabs_beforezero_double", "primitives": ["sortabs", "beforezero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then double each.", "solution": "def op_sortabs_beforezero_double(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortabs_beforezero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_beforezero_double([]) == []\nassert op_sortabs_beforezero_double([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_beforezero_double([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_beforezero_double([10]) == [20]\nassert op_sortabs_beforezero_double([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_beforezero_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_beforezero_last3_div3", "entry_point": "op_beforezero_last3_div3", "primitives": ["beforezero", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then keep multiples of three.", "solution": "def op_beforezero_last3_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_last3_div3([1, 2, 3, 4]) == [3]\nassert op_beforezero_last3_div3([]) == []\nassert op_beforezero_last3_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_last3_div3([5, 5, 5]) == []\nassert op_beforezero_last3_div3([3, 1, 2]) == [3]\nassert op_beforezero_last3_div3([10]) == []\nassert op_beforezero_last3_div3([2, 4, 6]) == [6]\nassert op_beforezero_last3_div3([-7, 12, -7]) == [12]"}
{"id": "op_nonempty_sortalpha_firstchar", "entry_point": "op_nonempty_sortalpha_firstchar", "primitives": ["nonempty", "sortalpha", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort alphabetically, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_sortalpha_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_sortalpha_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_nonempty_sortalpha_firstchar([]) == []\nassert op_nonempty_sortalpha_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_nonempty_sortalpha_firstchar(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_nonempty_sortalpha_firstchar(['x']) == ['x']\nassert op_nonempty_sortalpha_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_pos_beforezero_gt5", "entry_point": "op_pos_beforezero_gt5", "primitives": ["pos", "beforezero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_pos_beforezero_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_pos_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_pos_beforezero_gt5([]) == []\nassert op_pos_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_pos_beforezero_gt5([5, 5, 5]) == []\nassert op_pos_beforezero_gt5([3, 1, 2]) == []\nassert op_pos_beforezero_gt5([10]) == [10]\nassert op_pos_beforezero_gt5([2, 4, 6]) == [6]\nassert op_pos_beforezero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_double_add10_negate", "entry_point": "op_double_add10_negate", "primitives": ["double", "add10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then negate each.", "solution": "def op_double_add10_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_add10_negate([1, 2, 3, 4]) == [-12, -14, -16, -18]\nassert op_double_add10_negate([]) == []\nassert op_double_add10_negate([-2, -1, 0, 1, 2]) == [-6, -8, -10, -12, -14]\nassert op_double_add10_negate([5, 5, 5]) == [-20, -20, -20]\nassert op_double_add10_negate([3, 1, 2]) == [-16, -12, -14]\nassert op_double_add10_negate([10]) == [-30]\nassert op_double_add10_negate([2, 4, 6]) == [-14, -18, -22]\nassert op_double_add10_negate([-7, 12, -7]) == [4, -34, 4]"}
{"id": "op_gt5_padto3_haszero", "entry_point": "op_gt5_padto3_haszero", "primitives": ["gt5", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_gt5_padto3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_gt5_padto3_haszero([1, 2, 3, 4]) == True\nassert op_gt5_padto3_haszero([]) == True\nassert op_gt5_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_gt5_padto3_haszero([5, 5, 5]) == True\nassert op_gt5_padto3_haszero([3, 1, 2]) == True\nassert op_gt5_padto3_haszero([10]) == True\nassert op_gt5_padto3_haszero([2, 4, 6]) == True\nassert op_gt5_padto3_haszero([-7, 12, -7]) == True"}
{"id": "op_square_sorta_dec", "entry_point": "op_square_sorta_dec", "primitives": ["square", "sorta", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then subtract one from each.", "solution": "def op_square_sorta_dec(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_square_sorta_dec([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_square_sorta_dec([]) == []\nassert op_square_sorta_dec([-2, -1, 0, 1, 2]) == [-1, 0, 0, 3, 3]\nassert op_square_sorta_dec([5, 5, 5]) == [24, 24, 24]\nassert op_square_sorta_dec([3, 1, 2]) == [0, 3, 8]\nassert op_square_sorta_dec([10]) == [99]\nassert op_square_sorta_dec([2, 4, 6]) == [3, 15, 35]\nassert op_square_sorta_dec([-7, 12, -7]) == [48, 48, 143]"}
{"id": "op_dec_dropzeros_anyeven", "entry_point": "op_dec_dropzeros_anyeven", "primitives": ["dec", "dropzeros", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then return whether any value is even.", "solution": "def op_dec_dropzeros_anyeven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dec_dropzeros_anyeven([1, 2, 3, 4]) == True\nassert op_dec_dropzeros_anyeven([]) == False\nassert op_dec_dropzeros_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dec_dropzeros_anyeven([5, 5, 5]) == True\nassert op_dec_dropzeros_anyeven([3, 1, 2]) == True\nassert op_dec_dropzeros_anyeven([10]) == False\nassert op_dec_dropzeros_anyeven([2, 4, 6]) == False\nassert op_dec_dropzeros_anyeven([-7, 12, -7]) == True"}
{"id": "op_double_clamp10_oremptyzero", "entry_point": "op_double_clamp10_oremptyzero", "primitives": ["double", "clamp10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_double_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_clamp10_oremptyzero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_clamp10_oremptyzero([]) == [0]\nassert op_double_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_clamp10_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_double_clamp10_oremptyzero([3, 1, 2]) == [6, 2, 4]\nassert op_double_clamp10_oremptyzero([10]) == [10]\nassert op_double_clamp10_oremptyzero([2, 4, 6]) == [4, 8, 10]\nassert op_double_clamp10_oremptyzero([-7, 12, -7]) == [-14, 10, -14]"}
{"id": "op_ages_evens_add10", "entry_point": "op_ages_evens_add10", "primitives": ["ages", "evens", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then add ten to each.", "solution": "def op_ages_evens_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_evens_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_evens_add10([]) == []\nassert op_ages_evens_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28]\nassert op_ages_evens_add10([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_neg_oremptyzero_sortabs", "entry_point": "op_neg_oremptyzero_sortabs", "primitives": ["neg", "oremptyzero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero, then sort by absolute value.", "solution": "def op_neg_oremptyzero_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_oremptyzero_sortabs([1, 2, 3, 4]) == [0]\nassert op_neg_oremptyzero_sortabs([]) == [0]\nassert op_neg_oremptyzero_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_oremptyzero_sortabs([5, 5, 5]) == [0]\nassert op_neg_oremptyzero_sortabs([3, 1, 2]) == [0]\nassert op_neg_oremptyzero_sortabs([10]) == [0]\nassert op_neg_oremptyzero_sortabs([2, 4, 6]) == [0]\nassert op_neg_oremptyzero_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_absval_min", "entry_point": "op_square_absval_min", "primitives": ["square", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_square_absval_min(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_square_absval_min([1, 2, 3, 4]) == 1\nassert op_square_absval_min([]) == 0\nassert op_square_absval_min([-2, -1, 0, 1, 2]) == 0\nassert op_square_absval_min([5, 5, 5]) == 25\nassert op_square_absval_min([3, 1, 2]) == 1\nassert op_square_absval_min([10]) == 100\nassert op_square_absval_min([2, 4, 6]) == 4\nassert op_square_absval_min([-7, 12, -7]) == 49"}
{"id": "op_dropzeros_dec_padto3", "entry_point": "op_dropzeros_dec_padto3", "primitives": ["dropzeros", "dec", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_dec_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_dec_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropzeros_dec_padto3([]) == [0, 0, 0]\nassert op_dropzeros_dec_padto3([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_dropzeros_dec_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dropzeros_dec_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_dropzeros_dec_padto3([10]) == [9, 0, 0]\nassert op_dropzeros_dec_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dropzeros_dec_padto3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_square_pos_dropfirst", "entry_point": "op_square_pos_dropfirst", "primitives": ["square", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then drop the first element.", "solution": "def op_square_pos_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_square_pos_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_pos_dropfirst([]) == []\nassert op_square_pos_dropfirst([-2, -1, 0, 1, 2]) == [1, 1, 4]\nassert op_square_pos_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_pos_dropfirst([3, 1, 2]) == [1, 4]\nassert op_square_pos_dropfirst([10]) == []\nassert op_square_pos_dropfirst([2, 4, 6]) == [16, 36]\nassert op_square_pos_dropfirst([-7, 12, -7]) == [144, 49]"}
{"id": "op_negate_double_firsteven", "entry_point": "op_negate_double_firsteven", "primitives": ["negate", "double", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then return the first even value (0 if none).", "solution": "def op_negate_double_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_double_firsteven([1, 2, 3, 4]) == -2\nassert op_negate_double_firsteven([]) == 0\nassert op_negate_double_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_negate_double_firsteven([5, 5, 5]) == -10\nassert op_negate_double_firsteven([3, 1, 2]) == -6\nassert op_negate_double_firsteven([10]) == -20\nassert op_negate_double_firsteven([2, 4, 6]) == -4\nassert op_negate_double_firsteven([-7, 12, -7]) == 14"}
{"id": "op_beforezero_pos_absval", "entry_point": "op_beforezero_pos_absval", "primitives": ["beforezero", "pos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_beforezero_pos_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_pos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_pos_absval([]) == []\nassert op_beforezero_pos_absval([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_pos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_pos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_pos_absval([10]) == [10]\nassert op_beforezero_pos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_pos_absval([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_odds_uniq", "entry_point": "op_dropfirst_odds_uniq", "primitives": ["dropfirst", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_odds_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_odds_uniq([1, 2, 3, 4]) == [3]\nassert op_dropfirst_odds_uniq([]) == []\nassert op_dropfirst_odds_uniq([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_odds_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_odds_uniq([3, 1, 2]) == [1]\nassert op_dropfirst_odds_uniq([10]) == []\nassert op_dropfirst_odds_uniq([2, 4, 6]) == []\nassert op_dropfirst_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_double_uniq_dropwhileneg", "entry_point": "op_double_uniq_dropwhileneg", "primitives": ["double", "uniq", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_double_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_uniq_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_uniq_dropwhileneg([]) == []\nassert op_double_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_uniq_dropwhileneg([5, 5, 5]) == [10]\nassert op_double_uniq_dropwhileneg([3, 1, 2]) == [6, 2, 4]\nassert op_double_uniq_dropwhileneg([10]) == [20]\nassert op_double_uniq_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_double_uniq_dropwhileneg([-7, 12, -7]) == [24]"}
{"id": "op_sortd_div3_pos", "entry_point": "op_sortd_div3_pos", "primitives": ["sortd", "div3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep multiples of three, then keep the positive numbers.", "solution": "def op_sortd_div3_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_div3_pos([1, 2, 3, 4]) == [3]\nassert op_sortd_div3_pos([]) == []\nassert op_sortd_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_sortd_div3_pos([5, 5, 5]) == []\nassert op_sortd_div3_pos([3, 1, 2]) == [3]\nassert op_sortd_div3_pos([10]) == []\nassert op_sortd_div3_pos([2, 4, 6]) == [6]\nassert op_sortd_div3_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_oremptyzero_gt5", "entry_point": "op_dropzeros_oremptyzero_gt5", "primitives": ["dropzeros", "oremptyzero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then keep values greater than five.", "solution": "def op_dropzeros_oremptyzero_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropzeros_oremptyzero_gt5([1, 2, 3, 4]) == []\nassert op_dropzeros_oremptyzero_gt5([]) == []\nassert op_dropzeros_oremptyzero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_oremptyzero_gt5([5, 5, 5]) == []\nassert op_dropzeros_oremptyzero_gt5([3, 1, 2]) == []\nassert op_dropzeros_oremptyzero_gt5([10]) == [10]\nassert op_dropzeros_oremptyzero_gt5([2, 4, 6]) == [6]\nassert op_dropzeros_oremptyzero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_neg_min", "entry_point": "op_dropzeros_neg_min", "primitives": ["dropzeros", "neg", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_dropzeros_neg_min(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_dropzeros_neg_min([1, 2, 3, 4]) == 0\nassert op_dropzeros_neg_min([]) == 0\nassert op_dropzeros_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_neg_min([5, 5, 5]) == 0\nassert op_dropzeros_neg_min([3, 1, 2]) == 0\nassert op_dropzeros_neg_min([10]) == 0\nassert op_dropzeros_neg_min([2, 4, 6]) == 0\nassert op_dropzeros_neg_min([-7, 12, -7]) == -7"}
{"id": "op_strip_prefixup_dropshort", "entry_point": "op_strip_prefixup_dropshort", "primitives": ["strip", "prefixup", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash, then drop strings shorter than three characters.", "solution": "def op_strip_prefixup_dropshort(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_strip_prefixup_dropshort(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_prefixup_dropshort([]) == []\nassert op_strip_prefixup_dropshort(['  a ', '', 'BC', 'bc']) == ['#BC', '#bc']\nassert op_strip_prefixup_dropshort(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_strip_prefixup_dropshort(['x']) == []\nassert op_strip_prefixup_dropshort(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_padto3_sorta_issorted", "entry_point": "op_padto3_sorta_issorted", "primitives": ["padto3", "sorta", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_padto3_sorta_issorted(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_padto3_sorta_issorted([1, 2, 3, 4]) == True\nassert op_padto3_sorta_issorted([]) == True\nassert op_padto3_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_padto3_sorta_issorted([5, 5, 5]) == True\nassert op_padto3_sorta_issorted([3, 1, 2]) == True\nassert op_padto3_sorta_issorted([10]) == True\nassert op_padto3_sorta_issorted([2, 4, 6]) == True\nassert op_padto3_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_sortabs_rev", "entry_point": "op_sorta_sortabs_rev", "primitives": ["sorta", "sortabs", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then reverse the order.", "solution": "def op_sorta_sortabs_rev(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sorta_sortabs_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_sortabs_rev([]) == []\nassert op_sorta_sortabs_rev([-2, -1, 0, 1, 2]) == [2, -2, 1, -1, 0]\nassert op_sorta_sortabs_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortabs_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_sortabs_rev([10]) == [10]\nassert op_sorta_sortabs_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_sortabs_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortabs_rev_dec", "entry_point": "op_sortabs_rev_dec", "primitives": ["sortabs", "rev", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then subtract one from each.", "solution": "def op_sortabs_rev_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_rev_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortabs_rev_dec([]) == []\nassert op_sortabs_rev_dec([-2, -1, 0, 1, 2]) == [1, -3, 0, -2, -1]\nassert op_sortabs_rev_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_rev_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortabs_rev_dec([10]) == [9]\nassert op_sortabs_rev_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortabs_rev_dec([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_sortabs_oremptyzero_dropzeros", "entry_point": "op_sortabs_oremptyzero_dropzeros", "primitives": ["sortabs", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then drop the zeros.", "solution": "def op_sortabs_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_oremptyzero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_oremptyzero_dropzeros([]) == []\nassert op_sortabs_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_oremptyzero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_oremptyzero_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_oremptyzero_dropzeros([10]) == [10]\nassert op_sortabs_oremptyzero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_inc_sortabs_neg", "entry_point": "op_inc_sortabs_neg", "primitives": ["inc", "sortabs", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then keep the negative numbers.", "solution": "def op_inc_sortabs_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_sortabs_neg([1, 2, 3, 4]) == []\nassert op_inc_sortabs_neg([]) == []\nassert op_inc_sortabs_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_sortabs_neg([5, 5, 5]) == []\nassert op_inc_sortabs_neg([3, 1, 2]) == []\nassert op_inc_sortabs_neg([10]) == []\nassert op_inc_sortabs_neg([2, 4, 6]) == []\nassert op_inc_sortabs_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_trimends_last3_clamp10", "entry_point": "op_trimends_last3_clamp10", "primitives": ["trimends", "last3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then cap each value at 10.", "solution": "def op_trimends_last3_clamp10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_trimends_last3_clamp10([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_last3_clamp10([]) == []\nassert op_trimends_last3_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_last3_clamp10([5, 5, 5]) == [5]\nassert op_trimends_last3_clamp10([3, 1, 2]) == [1]\nassert op_trimends_last3_clamp10([10]) == []\nassert op_trimends_last3_clamp10([2, 4, 6]) == [4]\nassert op_trimends_last3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_add10_dec_min", "entry_point": "op_add10_dec_min", "primitives": ["add10", "dec", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_add10_dec_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_add10_dec_min([1, 2, 3, 4]) == 10\nassert op_add10_dec_min([]) == 0\nassert op_add10_dec_min([-2, -1, 0, 1, 2]) == 7\nassert op_add10_dec_min([5, 5, 5]) == 14\nassert op_add10_dec_min([3, 1, 2]) == 10\nassert op_add10_dec_min([10]) == 19\nassert op_add10_dec_min([2, 4, 6]) == 11\nassert op_add10_dec_min([-7, 12, -7]) == 2"}
{"id": "op_negate_clamp10_first3", "entry_point": "op_negate_clamp10_first3", "primitives": ["negate", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10, then keep only the first three.", "solution": "def op_negate_clamp10_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_negate_clamp10_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_clamp10_first3([]) == []\nassert op_negate_clamp10_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_negate_clamp10_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_clamp10_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_clamp10_first3([10]) == [-10]\nassert op_negate_clamp10_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_clamp10_first3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_square_padto3_prod", "entry_point": "op_square_padto3_prod", "primitives": ["square", "padto3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then return their product.", "solution": "def op_square_padto3_prod(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_square_padto3_prod([1, 2, 3, 4]) == 576\nassert op_square_padto3_prod([]) == 0\nassert op_square_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_square_padto3_prod([5, 5, 5]) == 15625\nassert op_square_padto3_prod([3, 1, 2]) == 36\nassert op_square_padto3_prod([10]) == 0\nassert op_square_padto3_prod([2, 4, 6]) == 2304\nassert op_square_padto3_prod([-7, 12, -7]) == 345744"}
{"id": "op_uniq_gt5_haszero", "entry_point": "op_uniq_gt5_haszero", "primitives": ["uniq", "gt5", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then return whether the list contains a zero.", "solution": "def op_uniq_gt5_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_uniq_gt5_haszero([1, 2, 3, 4]) == False\nassert op_uniq_gt5_haszero([]) == False\nassert op_uniq_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_uniq_gt5_haszero([5, 5, 5]) == False\nassert op_uniq_gt5_haszero([3, 1, 2]) == False\nassert op_uniq_gt5_haszero([10]) == False\nassert op_uniq_gt5_haszero([2, 4, 6]) == False\nassert op_uniq_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_dropzeros_dropfirst_takewhilepos", "entry_point": "op_dropzeros_dropfirst_takewhilepos", "primitives": ["dropzeros", "dropfirst", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then take values while they are positive.", "solution": "def op_dropzeros_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_dropfirst_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropfirst_takewhilepos([]) == []\nassert op_dropzeros_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_dropfirst_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropfirst_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst_takewhilepos([10]) == []\nassert op_dropzeros_dropfirst_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropfirst_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dec_add10_alldistinct", "entry_point": "op_dec_add10_alldistinct", "primitives": ["dec", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then return whether all values are distinct.", "solution": "def op_dec_add10_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dec_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_add10_alldistinct([]) == True\nassert op_dec_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_add10_alldistinct([5, 5, 5]) == False\nassert op_dec_add10_alldistinct([3, 1, 2]) == True\nassert op_dec_add10_alldistinct([10]) == True\nassert op_dec_add10_alldistinct([2, 4, 6]) == True\nassert op_dec_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_clamp10_div3_issorted", "entry_point": "op_clamp10_div3_issorted", "primitives": ["clamp10", "div3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_clamp10_div3_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_clamp10_div3_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_div3_issorted([]) == True\nassert op_clamp10_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_div3_issorted([5, 5, 5]) == True\nassert op_clamp10_div3_issorted([3, 1, 2]) == True\nassert op_clamp10_div3_issorted([10]) == True\nassert op_clamp10_div3_issorted([2, 4, 6]) == True\nassert op_clamp10_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_first3_dropwhileneg", "entry_point": "op_oremptyzero_first3_dropwhileneg", "primitives": ["oremptyzero", "first3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then drop the leading negative values.", "solution": "def op_oremptyzero_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_first3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_first3_dropwhileneg([]) == [0]\nassert op_oremptyzero_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_first3_dropwhileneg([10]) == [10]\nassert op_oremptyzero_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_first3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_div3_gt5_anyeven", "entry_point": "op_div3_gt5_anyeven", "primitives": ["div3", "gt5", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then return whether any value is even.", "solution": "def op_div3_gt5_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_gt5_anyeven([1, 2, 3, 4]) == False\nassert op_div3_gt5_anyeven([]) == False\nassert op_div3_gt5_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_div3_gt5_anyeven([5, 5, 5]) == False\nassert op_div3_gt5_anyeven([3, 1, 2]) == False\nassert op_div3_gt5_anyeven([10]) == False\nassert op_div3_gt5_anyeven([2, 4, 6]) == True\nassert op_div3_gt5_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_negate_counteven", "entry_point": "op_sorta_negate_counteven", "primitives": ["sorta", "negate", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then return how many values are even.", "solution": "def op_sorta_negate_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_negate_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_negate_counteven([]) == 0\nassert op_sorta_negate_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_negate_counteven([5, 5, 5]) == 0\nassert op_sorta_negate_counteven([3, 1, 2]) == 1\nassert op_sorta_negate_counteven([10]) == 1\nassert op_sorta_negate_counteven([2, 4, 6]) == 3\nassert op_sorta_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_odds_rev", "entry_point": "op_dropfirst_odds_rev", "primitives": ["dropfirst", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then reverse the order.", "solution": "def op_dropfirst_odds_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_odds_rev([1, 2, 3, 4]) == [3]\nassert op_dropfirst_odds_rev([]) == []\nassert op_dropfirst_odds_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_dropfirst_odds_rev([5, 5, 5]) == [5, 5]\nassert op_dropfirst_odds_rev([3, 1, 2]) == [1]\nassert op_dropfirst_odds_rev([10]) == []\nassert op_dropfirst_odds_rev([2, 4, 6]) == []\nassert op_dropfirst_odds_rev([-7, 12, -7]) == [-7]"}
{"id": "op_add10_dropfirst_last3", "entry_point": "op_add10_dropfirst_last3", "primitives": ["add10", "dropfirst", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then keep only the last three.", "solution": "def op_add10_dropfirst_last3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_add10_dropfirst_last3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropfirst_last3([]) == []\nassert op_add10_dropfirst_last3([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_add10_dropfirst_last3([5, 5, 5]) == [15, 15]\nassert op_add10_dropfirst_last3([3, 1, 2]) == [11, 12]\nassert op_add10_dropfirst_last3([10]) == []\nassert op_add10_dropfirst_last3([2, 4, 6]) == [14, 16]\nassert op_add10_dropfirst_last3([-7, 12, -7]) == [22, 3]"}
{"id": "op_pos_div3_counteven", "entry_point": "op_pos_div3_counteven", "primitives": ["pos", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then return how many values are even.", "solution": "def op_pos_div3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_div3_counteven([1, 2, 3, 4]) == 0\nassert op_pos_div3_counteven([]) == 0\nassert op_pos_div3_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_pos_div3_counteven([5, 5, 5]) == 0\nassert op_pos_div3_counteven([3, 1, 2]) == 0\nassert op_pos_div3_counteven([10]) == 0\nassert op_pos_div3_counteven([2, 4, 6]) == 1\nassert op_pos_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_dropzeros_gt5", "entry_point": "op_sortd_dropzeros_gt5", "primitives": ["sortd", "dropzeros", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then keep values greater than five.", "solution": "def op_sortd_dropzeros_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_sortd_dropzeros_gt5([]) == []\nassert op_sortd_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortd_dropzeros_gt5([5, 5, 5]) == []\nassert op_sortd_dropzeros_gt5([3, 1, 2]) == []\nassert op_sortd_dropzeros_gt5([10]) == [10]\nassert op_sortd_dropzeros_gt5([2, 4, 6]) == [6]\nassert op_sortd_dropzeros_gt5([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_sorta_absval", "entry_point": "op_clamp10_sorta_absval", "primitives": ["clamp10", "sorta", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then take the absolute value of each.", "solution": "def op_clamp10_sorta_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_sorta_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sorta_absval([]) == []\nassert op_clamp10_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sorta_absval([10]) == [10]\nassert op_clamp10_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sorta_absval([-7, 12, -7]) == [7, 7, 10]"}
{"id": "op_takewhilepos_dropwhileneg_max", "entry_point": "op_takewhilepos_dropwhileneg_max", "primitives": ["takewhilepos", "dropwhileneg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_dropwhileneg_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_dropwhileneg_max([1, 2, 3, 4]) == 4\nassert op_takewhilepos_dropwhileneg_max([]) == 0\nassert op_takewhilepos_dropwhileneg_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropwhileneg_max([5, 5, 5]) == 5\nassert op_takewhilepos_dropwhileneg_max([3, 1, 2]) == 3\nassert op_takewhilepos_dropwhileneg_max([10]) == 10\nassert op_takewhilepos_dropwhileneg_max([2, 4, 6]) == 6\nassert op_takewhilepos_dropwhileneg_max([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_odds_haszero", "entry_point": "op_dropzeros_odds_haszero", "primitives": ["dropzeros", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_dropzeros_odds_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_dropzeros_odds_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_odds_haszero([]) == False\nassert op_dropzeros_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_odds_haszero([5, 5, 5]) == False\nassert op_dropzeros_odds_haszero([3, 1, 2]) == False\nassert op_dropzeros_odds_haszero([10]) == False\nassert op_dropzeros_odds_haszero([2, 4, 6]) == False\nassert op_dropzeros_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_dropfirst_uniq", "entry_point": "op_div3_dropfirst_uniq", "primitives": ["div3", "dropfirst", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then drop duplicates keeping first occurrence.", "solution": "def op_div3_dropfirst_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_dropfirst_uniq([1, 2, 3, 4]) == []\nassert op_div3_dropfirst_uniq([]) == []\nassert op_div3_dropfirst_uniq([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst_uniq([5, 5, 5]) == []\nassert op_div3_dropfirst_uniq([3, 1, 2]) == []\nassert op_div3_dropfirst_uniq([10]) == []\nassert op_div3_dropfirst_uniq([2, 4, 6]) == []\nassert op_div3_dropfirst_uniq([-7, 12, -7]) == []"}
{"id": "op_negate_padto3_len", "entry_point": "op_negate_padto3_len", "primitives": ["negate", "padto3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_negate_padto3_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_negate_padto3_len([1, 2, 3, 4]) == 4\nassert op_negate_padto3_len([]) == 3\nassert op_negate_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_padto3_len([5, 5, 5]) == 3\nassert op_negate_padto3_len([3, 1, 2]) == 3\nassert op_negate_padto3_len([10]) == 3\nassert op_negate_padto3_len([2, 4, 6]) == 3\nassert op_negate_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_sorta_uniq_anyeven", "entry_point": "op_sorta_uniq_anyeven", "primitives": ["sorta", "uniq", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_sorta_uniq_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_uniq_anyeven([]) == False\nassert op_sorta_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_uniq_anyeven([5, 5, 5]) == False\nassert op_sorta_uniq_anyeven([3, 1, 2]) == True\nassert op_sorta_uniq_anyeven([10]) == True\nassert op_sorta_uniq_anyeven([2, 4, 6]) == True\nassert op_sorta_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_dropwhileneg_sortd", "entry_point": "op_last3_dropwhileneg_sortd", "primitives": ["last3", "dropwhileneg", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then sort descending.", "solution": "def op_last3_dropwhileneg_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_dropwhileneg_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_dropwhileneg_sortd([]) == []\nassert op_last3_dropwhileneg_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_dropwhileneg_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropwhileneg_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_dropwhileneg_sortd([10]) == [10]\nassert op_last3_dropwhileneg_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_dropwhileneg_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_square_firsteven", "entry_point": "op_dropfirst_square_firsteven", "primitives": ["dropfirst", "square", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then return the first even value (0 if none).", "solution": "def op_dropfirst_square_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_square_firsteven([1, 2, 3, 4]) == 4\nassert op_dropfirst_square_firsteven([]) == 0\nassert op_dropfirst_square_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_square_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_square_firsteven([3, 1, 2]) == 4\nassert op_dropfirst_square_firsteven([10]) == 0\nassert op_dropfirst_square_firsteven([2, 4, 6]) == 16\nassert op_dropfirst_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_neg_dropfirst_clamp10", "entry_point": "op_neg_dropfirst_clamp10", "primitives": ["neg", "dropfirst", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then cap each value at 10.", "solution": "def op_neg_dropfirst_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_neg_dropfirst_clamp10([1, 2, 3, 4]) == []\nassert op_neg_dropfirst_clamp10([]) == []\nassert op_neg_dropfirst_clamp10([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_dropfirst_clamp10([5, 5, 5]) == []\nassert op_neg_dropfirst_clamp10([3, 1, 2]) == []\nassert op_neg_dropfirst_clamp10([10]) == []\nassert op_neg_dropfirst_clamp10([2, 4, 6]) == []\nassert op_neg_dropfirst_clamp10([-7, 12, -7]) == [-7]"}
{"id": "op_absval_gt5_dropfirst", "entry_point": "op_absval_gt5_dropfirst", "primitives": ["absval", "gt5", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then drop the first element.", "solution": "def op_absval_gt5_dropfirst(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_absval_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_absval_gt5_dropfirst([]) == []\nassert op_absval_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_dropfirst([5, 5, 5]) == []\nassert op_absval_gt5_dropfirst([3, 1, 2]) == []\nassert op_absval_gt5_dropfirst([10]) == []\nassert op_absval_gt5_dropfirst([2, 4, 6]) == []\nassert op_absval_gt5_dropfirst([-7, 12, -7]) == [12, 7]"}
{"id": "op_sorta_pos_len", "entry_point": "op_sorta_pos_len", "primitives": ["sorta", "pos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers, then return how many remain.", "solution": "def op_sorta_pos_len(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return len(r)", "tests": "assert op_sorta_pos_len([1, 2, 3, 4]) == 4\nassert op_sorta_pos_len([]) == 0\nassert op_sorta_pos_len([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_pos_len([5, 5, 5]) == 3\nassert op_sorta_pos_len([3, 1, 2]) == 3\nassert op_sorta_pos_len([10]) == 1\nassert op_sorta_pos_len([2, 4, 6]) == 3\nassert op_sorta_pos_len([-7, 12, -7]) == 1"}
{"id": "op_trimends_add10_dropzeros", "entry_point": "op_trimends_add10_dropzeros", "primitives": ["trimends", "add10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then drop the zeros.", "solution": "def op_trimends_add10_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_add10_dropzeros([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_add10_dropzeros([]) == []\nassert op_trimends_add10_dropzeros([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10_dropzeros([5, 5, 5]) == [15]\nassert op_trimends_add10_dropzeros([3, 1, 2]) == [11]\nassert op_trimends_add10_dropzeros([10]) == []\nassert op_trimends_add10_dropzeros([2, 4, 6]) == [14]\nassert op_trimends_add10_dropzeros([-7, 12, -7]) == [22]"}
{"id": "op_trimends_dropfirst_double", "entry_point": "op_trimends_dropfirst_double", "primitives": ["trimends", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the first element, then double each.", "solution": "def op_trimends_dropfirst_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_dropfirst_double([1, 2, 3, 4]) == [6]\nassert op_trimends_dropfirst_double([]) == []\nassert op_trimends_dropfirst_double([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_trimends_dropfirst_double([5, 5, 5]) == []\nassert op_trimends_dropfirst_double([3, 1, 2]) == []\nassert op_trimends_dropfirst_double([10]) == []\nassert op_trimends_dropfirst_double([2, 4, 6]) == []\nassert op_trimends_dropfirst_double([-7, 12, -7]) == []"}
{"id": "op_dropfirst_sortabs_min", "entry_point": "op_dropfirst_sortabs_min", "primitives": ["dropfirst", "sortabs", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_dropfirst_sortabs_min(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_dropfirst_sortabs_min([1, 2, 3, 4]) == 2\nassert op_dropfirst_sortabs_min([]) == 0\nassert op_dropfirst_sortabs_min([-2, -1, 0, 1, 2]) == -1\nassert op_dropfirst_sortabs_min([5, 5, 5]) == 5\nassert op_dropfirst_sortabs_min([3, 1, 2]) == 1\nassert op_dropfirst_sortabs_min([10]) == 0\nassert op_dropfirst_sortabs_min([2, 4, 6]) == 4\nassert op_dropfirst_sortabs_min([-7, 12, -7]) == -7"}
{"id": "op_double_clamp10_add10", "entry_point": "op_double_clamp10_add10", "primitives": ["double", "clamp10", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10, then add ten to each.", "solution": "def op_double_clamp10_add10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_double_clamp10_add10([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_clamp10_add10([]) == []\nassert op_double_clamp10_add10([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_double_clamp10_add10([5, 5, 5]) == [20, 20, 20]\nassert op_double_clamp10_add10([3, 1, 2]) == [16, 12, 14]\nassert op_double_clamp10_add10([10]) == [20]\nassert op_double_clamp10_add10([2, 4, 6]) == [14, 18, 20]\nassert op_double_clamp10_add10([-7, 12, -7]) == [-4, 20, -4]"}
{"id": "op_padto3_dropfirst_issorted", "entry_point": "op_padto3_dropfirst_issorted", "primitives": ["padto3", "dropfirst", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element, then return whether the list is sorted ascending.", "solution": "def op_padto3_dropfirst_issorted(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r == sorted(r)", "tests": "assert op_padto3_dropfirst_issorted([1, 2, 3, 4]) == True\nassert op_padto3_dropfirst_issorted([]) == True\nassert op_padto3_dropfirst_issorted([-2, -1, 0, 1, 2]) == True\nassert op_padto3_dropfirst_issorted([5, 5, 5]) == True\nassert op_padto3_dropfirst_issorted([3, 1, 2]) == True\nassert op_padto3_dropfirst_issorted([10]) == True\nassert op_padto3_dropfirst_issorted([2, 4, 6]) == True\nassert op_padto3_dropfirst_issorted([-7, 12, -7]) == False"}
{"id": "op_rev_pos_sortabs", "entry_point": "op_rev_pos_sortabs", "primitives": ["rev", "pos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the positive numbers, then sort by absolute value.", "solution": "def op_rev_pos_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_pos_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_pos_sortabs([]) == []\nassert op_rev_pos_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_rev_pos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_pos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_pos_sortabs([10]) == [10]\nassert op_rev_pos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_double_allpos", "entry_point": "op_beforezero_double_allpos", "primitives": ["beforezero", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then return whether all values are positive.", "solution": "def op_beforezero_double_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_double_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_double_allpos([]) == True\nassert op_beforezero_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_double_allpos([5, 5, 5]) == True\nassert op_beforezero_double_allpos([3, 1, 2]) == True\nassert op_beforezero_double_allpos([10]) == True\nassert op_beforezero_double_allpos([2, 4, 6]) == True\nassert op_beforezero_double_allpos([-7, 12, -7]) == False"}
{"id": "op_dec_takewhilepos_rev", "entry_point": "op_dec_takewhilepos_rev", "primitives": ["dec", "takewhilepos", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then reverse the order.", "solution": "def op_dec_takewhilepos_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_takewhilepos_rev([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos_rev([]) == []\nassert op_dec_takewhilepos_rev([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_takewhilepos_rev([3, 1, 2]) == [2]\nassert op_dec_takewhilepos_rev([10]) == [9]\nassert op_dec_takewhilepos_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_takewhilepos_rev([-7, 12, -7]) == []"}
{"id": "op_trimends_takewhilepos_beforezero", "entry_point": "op_trimends_takewhilepos_beforezero", "primitives": ["trimends", "takewhilepos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_trimends_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_trimends_takewhilepos_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_takewhilepos_beforezero([]) == []\nassert op_trimends_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_trimends_takewhilepos_beforezero([5, 5, 5]) == [5]\nassert op_trimends_takewhilepos_beforezero([3, 1, 2]) == [1]\nassert op_trimends_takewhilepos_beforezero([10]) == []\nassert op_trimends_takewhilepos_beforezero([2, 4, 6]) == [4]\nassert op_trimends_takewhilepos_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_padto3_last3_negate", "entry_point": "op_padto3_last3_negate", "primitives": ["padto3", "last3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then negate each.", "solution": "def op_padto3_last3_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_last3_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_padto3_last3_negate([]) == [0, 0, 0]\nassert op_padto3_last3_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_padto3_last3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_last3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_last3_negate([10]) == [-10, 0, 0]\nassert op_padto3_last3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_last3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_dropfirst_add10_uniq", "entry_point": "op_dropfirst_add10_uniq", "primitives": ["dropfirst", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_add10_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_add10_uniq([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_add10_uniq([]) == []\nassert op_dropfirst_add10_uniq([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_dropfirst_add10_uniq([5, 5, 5]) == [15]\nassert op_dropfirst_add10_uniq([3, 1, 2]) == [11, 12]\nassert op_dropfirst_add10_uniq([10]) == []\nassert op_dropfirst_add10_uniq([2, 4, 6]) == [14, 16]\nassert op_dropfirst_add10_uniq([-7, 12, -7]) == [22, 3]"}
{"id": "op_first3_sortabs_pos", "entry_point": "op_first3_sortabs_pos", "primitives": ["first3", "sortabs", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then keep the positive numbers.", "solution": "def op_first3_sortabs_pos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_first3_sortabs_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs_pos([]) == []\nassert op_first3_sortabs_pos([-2, -1, 0, 1, 2]) == []\nassert op_first3_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs_pos([10]) == [10]\nassert op_first3_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs_pos([-7, 12, -7]) == [12]"}
{"id": "op_sortlen_nonempty_joinc", "entry_point": "op_sortlen_nonempty_joinc", "primitives": ["sortlen", "nonempty", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop empty strings, then join them with commas.", "solution": "def op_sortlen_nonempty_joinc(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s for s in r if s]\n    return ','.join(r)", "tests": "assert op_sortlen_nonempty_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortlen_nonempty_joinc([]) == ''\nassert op_sortlen_nonempty_joinc(['  a ', '', 'BC', 'bc']) == 'BC,bc,  a '\nassert op_sortlen_nonempty_joinc(['one', 'one', 'Two']) == 'one,one,Two'\nassert op_sortlen_nonempty_joinc(['x']) == 'x'\nassert op_sortlen_nonempty_joinc(['abc', 'de', '']) == 'de,abc'"}
{"id": "op_sortabs_dropwhileneg_neg", "entry_point": "op_sortabs_dropwhileneg_neg", "primitives": ["sortabs", "dropwhileneg", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_sortabs_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortabs_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_sortabs_dropwhileneg_neg([]) == []\nassert op_sortabs_dropwhileneg_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_dropwhileneg_neg([5, 5, 5]) == []\nassert op_sortabs_dropwhileneg_neg([3, 1, 2]) == []\nassert op_sortabs_dropwhileneg_neg([10]) == []\nassert op_sortabs_dropwhileneg_neg([2, 4, 6]) == []\nassert op_sortabs_dropwhileneg_neg([-7, 12, -7]) == []"}
{"id": "op_gt5_sorta_double", "entry_point": "op_gt5_sorta_double", "primitives": ["gt5", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then double each.", "solution": "def op_gt5_sorta_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_gt5_sorta_double([1, 2, 3, 4]) == []\nassert op_gt5_sorta_double([]) == []\nassert op_gt5_sorta_double([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_double([5, 5, 5]) == []\nassert op_gt5_sorta_double([3, 1, 2]) == []\nassert op_gt5_sorta_double([10]) == [20]\nassert op_gt5_sorta_double([2, 4, 6]) == [12]\nassert op_gt5_sorta_double([-7, 12, -7]) == [24]"}
{"id": "op_dec_dropwhileneg_last3", "entry_point": "op_dec_dropwhileneg_last3", "primitives": ["dec", "dropwhileneg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then keep only the last three.", "solution": "def op_dec_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_dropwhileneg_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropwhileneg_last3([]) == []\nassert op_dec_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dec_dropwhileneg_last3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropwhileneg_last3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_dropwhileneg_last3([10]) == [9]\nassert op_dec_dropwhileneg_last3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropwhileneg_last3([-7, 12, -7]) == [11, -8]"}
{"id": "op_dropwhileneg_neg_sortabs", "entry_point": "op_dropwhileneg_neg_sortabs", "primitives": ["dropwhileneg", "neg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then sort by absolute value.", "solution": "def op_dropwhileneg_neg_sortabs(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropwhileneg_neg_sortabs([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg_sortabs([]) == []\nassert op_dropwhileneg_neg_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg_sortabs([5, 5, 5]) == []\nassert op_dropwhileneg_neg_sortabs([3, 1, 2]) == []\nassert op_dropwhileneg_neg_sortabs([10]) == []\nassert op_dropwhileneg_neg_sortabs([2, 4, 6]) == []\nassert op_dropwhileneg_neg_sortabs([-7, 12, -7]) == [-7]"}
{"id": "op_sorta_negate_issorted", "entry_point": "op_sorta_negate_issorted", "primitives": ["sorta", "negate", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then return whether the list is sorted ascending.", "solution": "def op_sorta_negate_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_sorta_negate_issorted([1, 2, 3, 4]) == False\nassert op_sorta_negate_issorted([]) == True\nassert op_sorta_negate_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sorta_negate_issorted([5, 5, 5]) == True\nassert op_sorta_negate_issorted([3, 1, 2]) == False\nassert op_sorta_negate_issorted([10]) == True\nassert op_sorta_negate_issorted([2, 4, 6]) == False\nassert op_sorta_negate_issorted([-7, 12, -7]) == False"}
{"id": "op_add10_gt5_trimends", "entry_point": "op_add10_gt5_trimends", "primitives": ["add10", "gt5", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then drop the first and last elements.", "solution": "def op_add10_gt5_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_gt5_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_add10_gt5_trimends([]) == []\nassert op_add10_gt5_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_gt5_trimends([5, 5, 5]) == [15]\nassert op_add10_gt5_trimends([3, 1, 2]) == [11]\nassert op_add10_gt5_trimends([10]) == []\nassert op_add10_gt5_trimends([2, 4, 6]) == [14]\nassert op_add10_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_pos_sorta_max", "entry_point": "op_pos_sorta_max", "primitives": ["pos", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_pos_sorta_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_pos_sorta_max([1, 2, 3, 4]) == 4\nassert op_pos_sorta_max([]) == 0\nassert op_pos_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_pos_sorta_max([5, 5, 5]) == 5\nassert op_pos_sorta_max([3, 1, 2]) == 3\nassert op_pos_sorta_max([10]) == 10\nassert op_pos_sorta_max([2, 4, 6]) == 6\nassert op_pos_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_first3_max", "entry_point": "op_takewhilepos_first3_max", "primitives": ["takewhilepos", "first3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_first3_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_first3_max([1, 2, 3, 4]) == 3\nassert op_takewhilepos_first3_max([]) == 0\nassert op_takewhilepos_first3_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_first3_max([5, 5, 5]) == 5\nassert op_takewhilepos_first3_max([3, 1, 2]) == 3\nassert op_takewhilepos_first3_max([10]) == 10\nassert op_takewhilepos_first3_max([2, 4, 6]) == 6\nassert op_takewhilepos_first3_max([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_rev_add10", "entry_point": "op_dropfirst_rev_add10", "primitives": ["dropfirst", "rev", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then add ten to each.", "solution": "def op_dropfirst_rev_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_rev_add10([1, 2, 3, 4]) == [14, 13, 12]\nassert op_dropfirst_rev_add10([]) == []\nassert op_dropfirst_rev_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9]\nassert op_dropfirst_rev_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_rev_add10([3, 1, 2]) == [12, 11]\nassert op_dropfirst_rev_add10([10]) == []\nassert op_dropfirst_rev_add10([2, 4, 6]) == [16, 14]\nassert op_dropfirst_rev_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_ages_oremptyzero_neg", "entry_point": "op_ages_oremptyzero_neg", "primitives": ["ages", "oremptyzero", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then keep the negative numbers.", "solution": "def op_ages_oremptyzero_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_oremptyzero_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_oremptyzero_neg([]) == []\nassert op_ages_oremptyzero_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_oremptyzero_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_add10_last3_sorta", "entry_point": "op_add10_last3_sorta", "primitives": ["add10", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then sort ascending.", "solution": "def op_add10_last3_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_add10_last3_sorta([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_last3_sorta([]) == []\nassert op_add10_last3_sorta([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_add10_last3_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_last3_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_last3_sorta([10]) == [20]\nassert op_add10_last3_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_last3_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_square_add10_neg", "entry_point": "op_square_add10_neg", "primitives": ["square", "add10", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each, then keep the negative numbers.", "solution": "def op_square_add10_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_add10_neg([1, 2, 3, 4]) == []\nassert op_square_add10_neg([]) == []\nassert op_square_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_add10_neg([5, 5, 5]) == []\nassert op_square_add10_neg([3, 1, 2]) == []\nassert op_square_add10_neg([10]) == []\nassert op_square_add10_neg([2, 4, 6]) == []\nassert op_square_add10_neg([-7, 12, -7]) == []"}
{"id": "op_pos_clamp10_padto3", "entry_point": "op_pos_clamp10_padto3", "primitives": ["pos", "clamp10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_pos_clamp10_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_pos_clamp10_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_clamp10_padto3([]) == [0, 0, 0]\nassert op_pos_clamp10_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_clamp10_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_clamp10_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10_padto3([10]) == [10, 0, 0]\nassert op_pos_clamp10_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10_padto3([-7, 12, -7]) == [10, 0, 0]"}
{"id": "op_evens_takewhilepos_absval", "entry_point": "op_evens_takewhilepos_absval", "primitives": ["evens", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then take the absolute value of each.", "solution": "def op_evens_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_evens_takewhilepos_absval([1, 2, 3, 4]) == [2, 4]\nassert op_evens_takewhilepos_absval([]) == []\nassert op_evens_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_absval([5, 5, 5]) == []\nassert op_evens_takewhilepos_absval([3, 1, 2]) == [2]\nassert op_evens_takewhilepos_absval([10]) == [10]\nassert op_evens_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_evens_takewhilepos_absval([-7, 12, -7]) == [12]"}
{"id": "op_double_sortabs_issorted", "entry_point": "op_double_sortabs_issorted", "primitives": ["double", "sortabs", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_double_sortabs_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_double_sortabs_issorted([1, 2, 3, 4]) == True\nassert op_double_sortabs_issorted([]) == True\nassert op_double_sortabs_issorted([-2, -1, 0, 1, 2]) == False\nassert op_double_sortabs_issorted([5, 5, 5]) == True\nassert op_double_sortabs_issorted([3, 1, 2]) == True\nassert op_double_sortabs_issorted([10]) == True\nassert op_double_sortabs_issorted([2, 4, 6]) == True\nassert op_double_sortabs_issorted([-7, 12, -7]) == True"}
{"id": "op_evens_oremptyzero_first3", "entry_point": "op_evens_oremptyzero_first3", "primitives": ["evens", "oremptyzero", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then keep only the first three.", "solution": "def op_evens_oremptyzero_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    r = r[:3]\n    return r", "tests": "assert op_evens_oremptyzero_first3([1, 2, 3, 4]) == [2, 4]\nassert op_evens_oremptyzero_first3([]) == [0]\nassert op_evens_oremptyzero_first3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_oremptyzero_first3([5, 5, 5]) == [0]\nassert op_evens_oremptyzero_first3([3, 1, 2]) == [2]\nassert op_evens_oremptyzero_first3([10]) == [10]\nassert op_evens_oremptyzero_first3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_oremptyzero_first3([-7, 12, -7]) == [12]"}
{"id": "op_padto3_sortabs_dec", "entry_point": "op_padto3_sortabs_dec", "primitives": ["padto3", "sortabs", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then subtract one from each.", "solution": "def op_padto3_sortabs_dec(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_padto3_sortabs_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_padto3_sortabs_dec([]) == [-1, -1, -1]\nassert op_padto3_sortabs_dec([-2, -1, 0, 1, 2]) == [-1, -2, 0, -3, 1]\nassert op_padto3_sortabs_dec([5, 5, 5]) == [4, 4, 4]\nassert op_padto3_sortabs_dec([3, 1, 2]) == [0, 1, 2]\nassert op_padto3_sortabs_dec([10]) == [-1, -1, 9]\nassert op_padto3_sortabs_dec([2, 4, 6]) == [1, 3, 5]\nassert op_padto3_sortabs_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_pos_dec_issorted", "entry_point": "op_pos_dec_issorted", "primitives": ["pos", "dec", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then return whether the list is sorted ascending.", "solution": "def op_pos_dec_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_pos_dec_issorted([1, 2, 3, 4]) == True\nassert op_pos_dec_issorted([]) == True\nassert op_pos_dec_issorted([-2, -1, 0, 1, 2]) == True\nassert op_pos_dec_issorted([5, 5, 5]) == True\nassert op_pos_dec_issorted([3, 1, 2]) == False\nassert op_pos_dec_issorted([10]) == True\nassert op_pos_dec_issorted([2, 4, 6]) == True\nassert op_pos_dec_issorted([-7, 12, -7]) == True"}
{"id": "op_double_last3_anyeven", "entry_point": "op_double_last3_anyeven", "primitives": ["double", "last3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three, then return whether any value is even.", "solution": "def op_double_last3_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_last3_anyeven([1, 2, 3, 4]) == True\nassert op_double_last3_anyeven([]) == False\nassert op_double_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_double_last3_anyeven([5, 5, 5]) == True\nassert op_double_last3_anyeven([3, 1, 2]) == True\nassert op_double_last3_anyeven([10]) == True\nassert op_double_last3_anyeven([2, 4, 6]) == True\nassert op_double_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_clamp10_oremptyzero", "entry_point": "op_evens_clamp10_oremptyzero", "primitives": ["evens", "clamp10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_evens_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_clamp10_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_clamp10_oremptyzero([]) == [0]\nassert op_evens_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_clamp10_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_clamp10_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_clamp10_oremptyzero([10]) == [10]\nassert op_evens_clamp10_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_clamp10_oremptyzero([-7, 12, -7]) == [10]"}
{"id": "op_ages_sorta_clamp10", "entry_point": "op_ages_sorta_clamp10", "primitives": ["ages", "sorta", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then cap each value at 10.", "solution": "def op_ages_sorta_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_sorta_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_sorta_clamp10([]) == []\nassert op_ages_sorta_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_sorta_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_sortabs_takewhilepos_neg", "entry_point": "op_sortabs_takewhilepos_neg", "primitives": ["sortabs", "takewhilepos", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then keep the negative numbers.", "solution": "def op_sortabs_takewhilepos_neg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortabs_takewhilepos_neg([1, 2, 3, 4]) == []\nassert op_sortabs_takewhilepos_neg([]) == []\nassert op_sortabs_takewhilepos_neg([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_takewhilepos_neg([5, 5, 5]) == []\nassert op_sortabs_takewhilepos_neg([3, 1, 2]) == []\nassert op_sortabs_takewhilepos_neg([10]) == []\nassert op_sortabs_takewhilepos_neg([2, 4, 6]) == []\nassert op_sortabs_takewhilepos_neg([-7, 12, -7]) == []"}
{"id": "op_sortabs_rev_anyeven", "entry_point": "op_sortabs_rev_anyeven", "primitives": ["sortabs", "rev", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then return whether any value is even.", "solution": "def op_sortabs_rev_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_rev_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_rev_anyeven([]) == False\nassert op_sortabs_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_rev_anyeven([5, 5, 5]) == False\nassert op_sortabs_rev_anyeven([3, 1, 2]) == True\nassert op_sortabs_rev_anyeven([10]) == True\nassert op_sortabs_rev_anyeven([2, 4, 6]) == True\nassert op_sortabs_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_ages_negate_issorted", "entry_point": "op_ages_negate_issorted", "primitives": ["ages", "negate", "issorted"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then return whether the list is sorted ascending.", "solution": "def op_ages_negate_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_ages_negate_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_negate_issorted([]) == True\nassert op_ages_negate_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_negate_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_oremptyzero_dropfirst_allpos", "entry_point": "op_oremptyzero_dropfirst_allpos", "primitives": ["oremptyzero", "dropfirst", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then return whether all values are positive.", "solution": "def op_oremptyzero_dropfirst_allpos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_oremptyzero_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_oremptyzero_dropfirst_allpos([]) == True\nassert op_oremptyzero_dropfirst_allpos([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_dropfirst_allpos([5, 5, 5]) == True\nassert op_oremptyzero_dropfirst_allpos([3, 1, 2]) == True\nassert op_oremptyzero_dropfirst_allpos([10]) == True\nassert op_oremptyzero_dropfirst_allpos([2, 4, 6]) == True\nassert op_oremptyzero_dropfirst_allpos([-7, 12, -7]) == False"}
{"id": "op_inc_add10_padto3", "entry_point": "op_inc_add10_padto3", "primitives": ["inc", "add10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_inc_add10_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_add10_padto3([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_add10_padto3([]) == [0, 0, 0]\nassert op_inc_add10_padto3([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_add10_padto3([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10_padto3([3, 1, 2]) == [14, 12, 13]\nassert op_inc_add10_padto3([10]) == [21, 0, 0]\nassert op_inc_add10_padto3([2, 4, 6]) == [13, 15, 17]\nassert op_inc_add10_padto3([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_pos_dropfirst_odds", "entry_point": "op_pos_dropfirst_odds", "primitives": ["pos", "dropfirst", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first element, then keep the odd numbers.", "solution": "def op_pos_dropfirst_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_pos_dropfirst_odds([1, 2, 3, 4]) == [3]\nassert op_pos_dropfirst_odds([]) == []\nassert op_pos_dropfirst_odds([-2, -1, 0, 1, 2]) == []\nassert op_pos_dropfirst_odds([5, 5, 5]) == [5, 5]\nassert op_pos_dropfirst_odds([3, 1, 2]) == [1]\nassert op_pos_dropfirst_odds([10]) == []\nassert op_pos_dropfirst_odds([2, 4, 6]) == []\nassert op_pos_dropfirst_odds([-7, 12, -7]) == []"}
{"id": "op_last3_sortabs_sorta", "entry_point": "op_last3_sortabs_sorta", "primitives": ["last3", "sortabs", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then sort ascending.", "solution": "def op_last3_sortabs_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_last3_sortabs_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortabs_sorta([]) == []\nassert op_last3_sortabs_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortabs_sorta([10]) == [10]\nassert op_last3_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortabs_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortd_negate_issorted", "entry_point": "op_sortd_negate_issorted", "primitives": ["sortd", "negate", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then negate each, then return whether the list is sorted ascending.", "solution": "def op_sortd_negate_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_sortd_negate_issorted([1, 2, 3, 4]) == True\nassert op_sortd_negate_issorted([]) == True\nassert op_sortd_negate_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sortd_negate_issorted([5, 5, 5]) == True\nassert op_sortd_negate_issorted([3, 1, 2]) == True\nassert op_sortd_negate_issorted([10]) == True\nassert op_sortd_negate_issorted([2, 4, 6]) == True\nassert op_sortd_negate_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_rev_div3", "entry_point": "op_dec_rev_div3", "primitives": ["dec", "rev", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then keep multiples of three.", "solution": "def op_dec_rev_div3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dec_rev_div3([1, 2, 3, 4]) == [3, 0]\nassert op_dec_rev_div3([]) == []\nassert op_dec_rev_div3([-2, -1, 0, 1, 2]) == [0, -3]\nassert op_dec_rev_div3([5, 5, 5]) == []\nassert op_dec_rev_div3([3, 1, 2]) == [0]\nassert op_dec_rev_div3([10]) == [9]\nassert op_dec_rev_div3([2, 4, 6]) == [3]\nassert op_dec_rev_div3([-7, 12, -7]) == []"}
{"id": "op_sortabs_padto3_sum", "entry_point": "op_sortabs_padto3_sum", "primitives": ["sortabs", "padto3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then return their sum.", "solution": "def op_sortabs_padto3_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(r)", "tests": "assert op_sortabs_padto3_sum([1, 2, 3, 4]) == 10\nassert op_sortabs_padto3_sum([]) == 0\nassert op_sortabs_padto3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_padto3_sum([5, 5, 5]) == 15\nassert op_sortabs_padto3_sum([3, 1, 2]) == 6\nassert op_sortabs_padto3_sum([10]) == 10\nassert op_sortabs_padto3_sum([2, 4, 6]) == 12\nassert op_sortabs_padto3_sum([-7, 12, -7]) == -2"}
{"id": "op_square_dropfirst_sortabs", "entry_point": "op_square_dropfirst_sortabs", "primitives": ["square", "dropfirst", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then sort by absolute value.", "solution": "def op_square_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_square_dropfirst_sortabs([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_dropfirst_sortabs([]) == []\nassert op_square_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4]\nassert op_square_dropfirst_sortabs([5, 5, 5]) == [25, 25]\nassert op_square_dropfirst_sortabs([3, 1, 2]) == [1, 4]\nassert op_square_dropfirst_sortabs([10]) == []\nassert op_square_dropfirst_sortabs([2, 4, 6]) == [16, 36]\nassert op_square_dropfirst_sortabs([-7, 12, -7]) == [49, 144]"}
{"id": "op_trimends_neg_dropzeros", "entry_point": "op_trimends_neg_dropzeros", "primitives": ["trimends", "neg", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then drop the zeros.", "solution": "def op_trimends_neg_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_trimends_neg_dropzeros([]) == []\nassert op_trimends_neg_dropzeros([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_neg_dropzeros([5, 5, 5]) == []\nassert op_trimends_neg_dropzeros([3, 1, 2]) == []\nassert op_trimends_neg_dropzeros([10]) == []\nassert op_trimends_neg_dropzeros([2, 4, 6]) == []\nassert op_trimends_neg_dropzeros([-7, 12, -7]) == []"}
{"id": "op_trimends_add10_last3", "entry_point": "op_trimends_add10_last3", "primitives": ["trimends", "add10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then keep only the last three.", "solution": "def op_trimends_add10_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_add10_last3([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_add10_last3([]) == []\nassert op_trimends_add10_last3([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10_last3([5, 5, 5]) == [15]\nassert op_trimends_add10_last3([3, 1, 2]) == [11]\nassert op_trimends_add10_last3([10]) == []\nassert op_trimends_add10_last3([2, 4, 6]) == [14]\nassert op_trimends_add10_last3([-7, 12, -7]) == [22]"}
{"id": "op_beforezero_neg_sortabs", "entry_point": "op_beforezero_neg_sortabs", "primitives": ["beforezero", "neg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then sort by absolute value.", "solution": "def op_beforezero_neg_sortabs(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_beforezero_neg_sortabs([1, 2, 3, 4]) == []\nassert op_beforezero_neg_sortabs([]) == []\nassert op_beforezero_neg_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_neg_sortabs([5, 5, 5]) == []\nassert op_beforezero_neg_sortabs([3, 1, 2]) == []\nassert op_beforezero_neg_sortabs([10]) == []\nassert op_beforezero_neg_sortabs([2, 4, 6]) == []\nassert op_beforezero_neg_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dec_neg_inc", "entry_point": "op_dec_neg_inc", "primitives": ["dec", "neg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then add one to each.", "solution": "def op_dec_neg_inc(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dec_neg_inc([1, 2, 3, 4]) == []\nassert op_dec_neg_inc([]) == []\nassert op_dec_neg_inc([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_dec_neg_inc([5, 5, 5]) == []\nassert op_dec_neg_inc([3, 1, 2]) == []\nassert op_dec_neg_inc([10]) == []\nassert op_dec_neg_inc([2, 4, 6]) == []\nassert op_dec_neg_inc([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero_dropwhileneg_firsteven", "entry_point": "op_oremptyzero_dropwhileneg_firsteven", "primitives": ["oremptyzero", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_oremptyzero_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_dropwhileneg_firsteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_dropwhileneg_firsteven([]) == 0\nassert op_oremptyzero_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_dropwhileneg_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_dropwhileneg_firsteven([10]) == 10\nassert op_oremptyzero_dropwhileneg_firsteven([2, 4, 6]) == 2\nassert op_oremptyzero_dropwhileneg_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_trimends_div3", "entry_point": "op_evens_trimends_div3", "primitives": ["evens", "trimends", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then keep multiples of three.", "solution": "def op_evens_trimends_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_trimends_div3([1, 2, 3, 4]) == []\nassert op_evens_trimends_div3([]) == []\nassert op_evens_trimends_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_trimends_div3([5, 5, 5]) == []\nassert op_evens_trimends_div3([3, 1, 2]) == []\nassert op_evens_trimends_div3([10]) == []\nassert op_evens_trimends_div3([2, 4, 6]) == []\nassert op_evens_trimends_div3([-7, 12, -7]) == []"}
{"id": "op_dropfirst_takewhilepos_len", "entry_point": "op_dropfirst_takewhilepos_len", "primitives": ["dropfirst", "takewhilepos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then return how many remain.", "solution": "def op_dropfirst_takewhilepos_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_dropfirst_takewhilepos_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_takewhilepos_len([]) == 0\nassert op_dropfirst_takewhilepos_len([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_takewhilepos_len([5, 5, 5]) == 2\nassert op_dropfirst_takewhilepos_len([3, 1, 2]) == 2\nassert op_dropfirst_takewhilepos_len([10]) == 0\nassert op_dropfirst_takewhilepos_len([2, 4, 6]) == 2\nassert op_dropfirst_takewhilepos_len([-7, 12, -7]) == 1"}
{"id": "op_last3_square_div3", "entry_point": "op_last3_square_div3", "primitives": ["last3", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then keep multiples of three.", "solution": "def op_last3_square_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_square_div3([1, 2, 3, 4]) == [9]\nassert op_last3_square_div3([]) == []\nassert op_last3_square_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_square_div3([5, 5, 5]) == []\nassert op_last3_square_div3([3, 1, 2]) == [9]\nassert op_last3_square_div3([10]) == []\nassert op_last3_square_div3([2, 4, 6]) == [36]\nassert op_last3_square_div3([-7, 12, -7]) == [144]"}
{"id": "op_neg_dropfirst_gt5", "entry_point": "op_neg_dropfirst_gt5", "primitives": ["neg", "dropfirst", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then keep values greater than five.", "solution": "def op_neg_dropfirst_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_dropfirst_gt5([1, 2, 3, 4]) == []\nassert op_neg_dropfirst_gt5([]) == []\nassert op_neg_dropfirst_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropfirst_gt5([5, 5, 5]) == []\nassert op_neg_dropfirst_gt5([3, 1, 2]) == []\nassert op_neg_dropfirst_gt5([10]) == []\nassert op_neg_dropfirst_gt5([2, 4, 6]) == []\nassert op_neg_dropfirst_gt5([-7, 12, -7]) == []"}
{"id": "op_absval_negate_gt5", "entry_point": "op_absval_negate_gt5", "primitives": ["absval", "negate", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then keep values greater than five.", "solution": "def op_absval_negate_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_negate_gt5([1, 2, 3, 4]) == []\nassert op_absval_negate_gt5([]) == []\nassert op_absval_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_negate_gt5([5, 5, 5]) == []\nassert op_absval_negate_gt5([3, 1, 2]) == []\nassert op_absval_negate_gt5([10]) == []\nassert op_absval_negate_gt5([2, 4, 6]) == []\nassert op_absval_negate_gt5([-7, 12, -7]) == []"}
{"id": "op_odds_clamp10_square", "entry_point": "op_odds_clamp10_square", "primitives": ["odds", "clamp10", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then square each.", "solution": "def op_odds_clamp10_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_odds_clamp10_square([1, 2, 3, 4]) == [1, 9]\nassert op_odds_clamp10_square([]) == []\nassert op_odds_clamp10_square([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_clamp10_square([5, 5, 5]) == [25, 25, 25]\nassert op_odds_clamp10_square([3, 1, 2]) == [9, 1]\nassert op_odds_clamp10_square([10]) == []\nassert op_odds_clamp10_square([2, 4, 6]) == []\nassert op_odds_clamp10_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_add10_trimends_evens", "entry_point": "op_add10_trimends_evens", "primitives": ["add10", "trimends", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then keep the even numbers.", "solution": "def op_add10_trimends_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_trimends_evens([1, 2, 3, 4]) == [12]\nassert op_add10_trimends_evens([]) == []\nassert op_add10_trimends_evens([-2, -1, 0, 1, 2]) == [10]\nassert op_add10_trimends_evens([5, 5, 5]) == []\nassert op_add10_trimends_evens([3, 1, 2]) == []\nassert op_add10_trimends_evens([10]) == []\nassert op_add10_trimends_evens([2, 4, 6]) == [14]\nassert op_add10_trimends_evens([-7, 12, -7]) == [22]"}
{"id": "op_beforezero_neg_clamp10", "entry_point": "op_beforezero_neg_clamp10", "primitives": ["beforezero", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then cap each value at 10.", "solution": "def op_beforezero_neg_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_neg_clamp10([1, 2, 3, 4]) == []\nassert op_beforezero_neg_clamp10([]) == []\nassert op_beforezero_neg_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_neg_clamp10([5, 5, 5]) == []\nassert op_beforezero_neg_clamp10([3, 1, 2]) == []\nassert op_beforezero_neg_clamp10([10]) == []\nassert op_beforezero_neg_clamp10([2, 4, 6]) == []\nassert op_beforezero_neg_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_ages_double_trimends", "entry_point": "op_ages_double_trimends", "primitives": ["ages", "double", "trimends"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then double each, then drop the first and last elements.", "solution": "def op_ages_double_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_double_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_double_trimends([]) == []\nassert op_ages_double_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [130]\nassert op_ages_double_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sortabs_gt5_dropzeros", "entry_point": "op_sortabs_gt5_dropzeros", "primitives": ["sortabs", "gt5", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then drop the zeros.", "solution": "def op_sortabs_gt5_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_sortabs_gt5_dropzeros([]) == []\nassert op_sortabs_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_gt5_dropzeros([5, 5, 5]) == []\nassert op_sortabs_gt5_dropzeros([3, 1, 2]) == []\nassert op_sortabs_gt5_dropzeros([10]) == [10]\nassert op_sortabs_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_sortabs_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_last3_trimends_haszero", "entry_point": "op_last3_trimends_haszero", "primitives": ["last3", "trimends", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then return whether the list contains a zero.", "solution": "def op_last3_trimends_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    return 0 in r", "tests": "assert op_last3_trimends_haszero([1, 2, 3, 4]) == False\nassert op_last3_trimends_haszero([]) == False\nassert op_last3_trimends_haszero([-2, -1, 0, 1, 2]) == False\nassert op_last3_trimends_haszero([5, 5, 5]) == False\nassert op_last3_trimends_haszero([3, 1, 2]) == False\nassert op_last3_trimends_haszero([10]) == False\nassert op_last3_trimends_haszero([2, 4, 6]) == False\nassert op_last3_trimends_haszero([-7, 12, -7]) == False"}
{"id": "op_add10_pos_haszero", "entry_point": "op_add10_pos_haszero", "primitives": ["add10", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_add10_pos_haszero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_add10_pos_haszero([1, 2, 3, 4]) == False\nassert op_add10_pos_haszero([]) == False\nassert op_add10_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_add10_pos_haszero([5, 5, 5]) == False\nassert op_add10_pos_haszero([3, 1, 2]) == False\nassert op_add10_pos_haszero([10]) == False\nassert op_add10_pos_haszero([2, 4, 6]) == False\nassert op_add10_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_square_sortabs_max", "entry_point": "op_square_sortabs_max", "primitives": ["square", "sortabs", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_square_sortabs_max(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_square_sortabs_max([1, 2, 3, 4]) == 16\nassert op_square_sortabs_max([]) == 0\nassert op_square_sortabs_max([-2, -1, 0, 1, 2]) == 4\nassert op_square_sortabs_max([5, 5, 5]) == 25\nassert op_square_sortabs_max([3, 1, 2]) == 9\nassert op_square_sortabs_max([10]) == 100\nassert op_square_sortabs_max([2, 4, 6]) == 36\nassert op_square_sortabs_max([-7, 12, -7]) == 144"}
{"id": "op_gt5_dropfirst_haszero", "entry_point": "op_gt5_dropfirst_haszero", "primitives": ["gt5", "dropfirst", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then return whether the list contains a zero.", "solution": "def op_gt5_dropfirst_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return 0 in r", "tests": "assert op_gt5_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_gt5_dropfirst_haszero([]) == False\nassert op_gt5_dropfirst_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_dropfirst_haszero([5, 5, 5]) == False\nassert op_gt5_dropfirst_haszero([3, 1, 2]) == False\nassert op_gt5_dropfirst_haszero([10]) == False\nassert op_gt5_dropfirst_haszero([2, 4, 6]) == False\nassert op_gt5_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_takewhilepos_min", "entry_point": "op_trimends_takewhilepos_min", "primitives": ["trimends", "takewhilepos", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_trimends_takewhilepos_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_trimends_takewhilepos_min([1, 2, 3, 4]) == 2\nassert op_trimends_takewhilepos_min([]) == 0\nassert op_trimends_takewhilepos_min([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_takewhilepos_min([5, 5, 5]) == 5\nassert op_trimends_takewhilepos_min([3, 1, 2]) == 1\nassert op_trimends_takewhilepos_min([10]) == 0\nassert op_trimends_takewhilepos_min([2, 4, 6]) == 4\nassert op_trimends_takewhilepos_min([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_odds_rev", "entry_point": "op_oremptyzero_odds_rev", "primitives": ["oremptyzero", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then reverse the order.", "solution": "def op_oremptyzero_odds_rev(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_oremptyzero_odds_rev([1, 2, 3, 4]) == [3, 1]\nassert op_oremptyzero_odds_rev([]) == []\nassert op_oremptyzero_odds_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_oremptyzero_odds_rev([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_odds_rev([3, 1, 2]) == [1, 3]\nassert op_oremptyzero_odds_rev([10]) == []\nassert op_oremptyzero_odds_rev([2, 4, 6]) == []\nassert op_oremptyzero_odds_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_negate_last3", "entry_point": "op_dropwhileneg_negate_last3", "primitives": ["dropwhileneg", "negate", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then keep only the last three.", "solution": "def op_dropwhileneg_negate_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropwhileneg_negate_last3([]) == []\nassert op_dropwhileneg_negate_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropwhileneg_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_dropwhileneg_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_dropwhileneg_negate_last3([10]) == [-10]\nassert op_dropwhileneg_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_dropwhileneg_negate_last3([-7, 12, -7]) == [-12, 7]"}
{"id": "op_square_clamp10_add10", "entry_point": "op_square_clamp10_add10", "primitives": ["square", "clamp10", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then add ten to each.", "solution": "def op_square_clamp10_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_clamp10_add10([1, 2, 3, 4]) == [11, 14, 19, 20]\nassert op_square_clamp10_add10([]) == []\nassert op_square_clamp10_add10([-2, -1, 0, 1, 2]) == [14, 11, 10, 11, 14]\nassert op_square_clamp10_add10([5, 5, 5]) == [20, 20, 20]\nassert op_square_clamp10_add10([3, 1, 2]) == [19, 11, 14]\nassert op_square_clamp10_add10([10]) == [20]\nassert op_square_clamp10_add10([2, 4, 6]) == [14, 20, 20]\nassert op_square_clamp10_add10([-7, 12, -7]) == [20, 20, 20]"}
{"id": "op_beforezero_add10_dropzeros", "entry_point": "op_beforezero_add10_dropzeros", "primitives": ["beforezero", "add10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then drop the zeros.", "solution": "def op_beforezero_add10_dropzeros(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_beforezero_add10_dropzeros([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_beforezero_add10_dropzeros([]) == []\nassert op_beforezero_add10_dropzeros([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_beforezero_add10_dropzeros([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_add10_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_beforezero_add10_dropzeros([10]) == [20]\nassert op_beforezero_add10_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_beforezero_add10_dropzeros([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_oremptyzero_sortabs_first3", "entry_point": "op_oremptyzero_sortabs_first3", "primitives": ["oremptyzero", "sortabs", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then keep only the first three.", "solution": "def op_oremptyzero_sortabs_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_sortabs_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_sortabs_first3([]) == [0]\nassert op_oremptyzero_sortabs_first3([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_oremptyzero_sortabs_first3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortabs_first3([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sortabs_first3([10]) == [10]\nassert op_oremptyzero_sortabs_first3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sortabs_first3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_rev_last3", "entry_point": "op_pos_rev_last3", "primitives": ["pos", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then keep only the last three.", "solution": "def op_pos_rev_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_pos_rev_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_pos_rev_last3([]) == []\nassert op_pos_rev_last3([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_rev_last3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_rev_last3([3, 1, 2]) == [2, 1, 3]\nassert op_pos_rev_last3([10]) == [10]\nassert op_pos_rev_last3([2, 4, 6]) == [6, 4, 2]\nassert op_pos_rev_last3([-7, 12, -7]) == [12]"}
{"id": "op_rev_dropfirst_last3", "entry_point": "op_rev_dropfirst_last3", "primitives": ["rev", "dropfirst", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element, then keep only the last three.", "solution": "def op_rev_dropfirst_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_rev_dropfirst_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dropfirst_last3([]) == []\nassert op_rev_dropfirst_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_rev_dropfirst_last3([5, 5, 5]) == [5, 5]\nassert op_rev_dropfirst_last3([3, 1, 2]) == [1, 3]\nassert op_rev_dropfirst_last3([10]) == []\nassert op_rev_dropfirst_last3([2, 4, 6]) == [4, 2]\nassert op_rev_dropfirst_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_dec_gt5", "entry_point": "op_absval_dec_gt5", "primitives": ["absval", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then keep values greater than five.", "solution": "def op_absval_dec_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_dec_gt5([1, 2, 3, 4]) == []\nassert op_absval_dec_gt5([]) == []\nassert op_absval_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_dec_gt5([5, 5, 5]) == []\nassert op_absval_dec_gt5([3, 1, 2]) == []\nassert op_absval_dec_gt5([10]) == [9]\nassert op_absval_dec_gt5([2, 4, 6]) == []\nassert op_absval_dec_gt5([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_sortd_dropwhileneg_alldistinct", "entry_point": "op_sortd_dropwhileneg_alldistinct", "primitives": ["sortd", "dropwhileneg", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then return whether all values are distinct.", "solution": "def op_sortd_dropwhileneg_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_dropwhileneg_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_dropwhileneg_alldistinct([]) == True\nassert op_sortd_dropwhileneg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_dropwhileneg_alldistinct([5, 5, 5]) == False\nassert op_sortd_dropwhileneg_alldistinct([3, 1, 2]) == True\nassert op_sortd_dropwhileneg_alldistinct([10]) == True\nassert op_sortd_dropwhileneg_alldistinct([2, 4, 6]) == True\nassert op_sortd_dropwhileneg_alldistinct([-7, 12, -7]) == False"}
{"id": "op_first3_add10_alldistinct", "entry_point": "op_first3_add10_alldistinct", "primitives": ["first3", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then return whether all values are distinct.", "solution": "def op_first3_add10_alldistinct(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_first3_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_first3_add10_alldistinct([]) == True\nassert op_first3_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_first3_add10_alldistinct([5, 5, 5]) == False\nassert op_first3_add10_alldistinct([3, 1, 2]) == True\nassert op_first3_add10_alldistinct([10]) == True\nassert op_first3_add10_alldistinct([2, 4, 6]) == True\nassert op_first3_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_div3_absval_odds", "entry_point": "op_div3_absval_odds", "primitives": ["div3", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_div3_absval_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_absval_odds([1, 2, 3, 4]) == [3]\nassert op_div3_absval_odds([]) == []\nassert op_div3_absval_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_absval_odds([5, 5, 5]) == []\nassert op_div3_absval_odds([3, 1, 2]) == [3]\nassert op_div3_absval_odds([10]) == []\nassert op_div3_absval_odds([2, 4, 6]) == []\nassert op_div3_absval_odds([-7, 12, -7]) == []"}
{"id": "op_sortd_square_rev", "entry_point": "op_sortd_square_rev", "primitives": ["sortd", "square", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then reverse the order.", "solution": "def op_sortd_square_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_square_rev([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortd_square_rev([]) == []\nassert op_sortd_square_rev([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sortd_square_rev([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_rev([3, 1, 2]) == [1, 4, 9]\nassert op_sortd_square_rev([10]) == [100]\nassert op_sortd_square_rev([2, 4, 6]) == [4, 16, 36]\nassert op_sortd_square_rev([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_last3_dropwhileneg_min", "entry_point": "op_last3_dropwhileneg_min", "primitives": ["last3", "dropwhileneg", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then return the minimum (0 if empty).", "solution": "def op_last3_dropwhileneg_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return min(r) if r else 0", "tests": "assert op_last3_dropwhileneg_min([1, 2, 3, 4]) == 2\nassert op_last3_dropwhileneg_min([]) == 0\nassert op_last3_dropwhileneg_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_dropwhileneg_min([5, 5, 5]) == 5\nassert op_last3_dropwhileneg_min([3, 1, 2]) == 1\nassert op_last3_dropwhileneg_min([10]) == 10\nassert op_last3_dropwhileneg_min([2, 4, 6]) == 2\nassert op_last3_dropwhileneg_min([-7, 12, -7]) == -7"}
{"id": "op_first3_rev_allpos", "entry_point": "op_first3_rev_allpos", "primitives": ["first3", "rev", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then return whether all values are positive.", "solution": "def op_first3_rev_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    return all(x > 0 for x in r)", "tests": "assert op_first3_rev_allpos([1, 2, 3, 4]) == True\nassert op_first3_rev_allpos([]) == True\nassert op_first3_rev_allpos([-2, -1, 0, 1, 2]) == False\nassert op_first3_rev_allpos([5, 5, 5]) == True\nassert op_first3_rev_allpos([3, 1, 2]) == True\nassert op_first3_rev_allpos([10]) == True\nassert op_first3_rev_allpos([2, 4, 6]) == True\nassert op_first3_rev_allpos([-7, 12, -7]) == False"}
{"id": "op_negate_sortd_oremptyzero", "entry_point": "op_negate_sortd_oremptyzero", "primitives": ["negate", "sortd", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending, then if empty, use a single zero.", "solution": "def op_negate_sortd_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_sortd_oremptyzero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_sortd_oremptyzero([]) == [0]\nassert op_negate_sortd_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_sortd_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sortd_oremptyzero([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sortd_oremptyzero([10]) == [-10]\nassert op_negate_sortd_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sortd_oremptyzero([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_double_takewhilepos_gt5", "entry_point": "op_double_takewhilepos_gt5", "primitives": ["double", "takewhilepos", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then keep values greater than five.", "solution": "def op_double_takewhilepos_gt5(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_double_takewhilepos_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_double_takewhilepos_gt5([]) == []\nassert op_double_takewhilepos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_double_takewhilepos_gt5([3, 1, 2]) == [6]\nassert op_double_takewhilepos_gt5([10]) == [20]\nassert op_double_takewhilepos_gt5([2, 4, 6]) == [8, 12]\nassert op_double_takewhilepos_gt5([-7, 12, -7]) == []"}
{"id": "op_gt5_pos_first3", "entry_point": "op_gt5_pos_first3", "primitives": ["gt5", "pos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then keep only the first three.", "solution": "def op_gt5_pos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_pos_first3([1, 2, 3, 4]) == []\nassert op_gt5_pos_first3([]) == []\nassert op_gt5_pos_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_first3([5, 5, 5]) == []\nassert op_gt5_pos_first3([3, 1, 2]) == []\nassert op_gt5_pos_first3([10]) == [10]\nassert op_gt5_pos_first3([2, 4, 6]) == [6]\nassert op_gt5_pos_first3([-7, 12, -7]) == [12]"}
{"id": "op_last3_dropwhileneg_negate", "entry_point": "op_last3_dropwhileneg_negate", "primitives": ["last3", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then negate each.", "solution": "def op_last3_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_dropwhileneg_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_dropwhileneg_negate([]) == []\nassert op_last3_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_dropwhileneg_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_last3_dropwhileneg_negate([10]) == [-10]\nassert op_last3_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_rev_dropzeros_neg", "entry_point": "op_rev_dropzeros_neg", "primitives": ["rev", "dropzeros", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then keep the negative numbers.", "solution": "def op_rev_dropzeros_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_dropzeros_neg([1, 2, 3, 4]) == []\nassert op_rev_dropzeros_neg([]) == []\nassert op_rev_dropzeros_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_rev_dropzeros_neg([5, 5, 5]) == []\nassert op_rev_dropzeros_neg([3, 1, 2]) == []\nassert op_rev_dropzeros_neg([10]) == []\nassert op_rev_dropzeros_neg([2, 4, 6]) == []\nassert op_rev_dropzeros_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_trimends_div3", "entry_point": "op_padto3_trimends_div3", "primitives": ["padto3", "trimends", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then keep multiples of three.", "solution": "def op_padto3_trimends_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_trimends_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_trimends_div3([]) == [0]\nassert op_padto3_trimends_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_trimends_div3([5, 5, 5]) == []\nassert op_padto3_trimends_div3([3, 1, 2]) == []\nassert op_padto3_trimends_div3([10]) == [0]\nassert op_padto3_trimends_div3([2, 4, 6]) == []\nassert op_padto3_trimends_div3([-7, 12, -7]) == [12]"}
{"id": "op_div3_inc_evens", "entry_point": "op_div3_inc_evens", "primitives": ["div3", "inc", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then keep the even numbers.", "solution": "def op_div3_inc_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_div3_inc_evens([1, 2, 3, 4]) == [4]\nassert op_div3_inc_evens([]) == []\nassert op_div3_inc_evens([-2, -1, 0, 1, 2]) == []\nassert op_div3_inc_evens([5, 5, 5]) == []\nassert op_div3_inc_evens([3, 1, 2]) == [4]\nassert op_div3_inc_evens([10]) == []\nassert op_div3_inc_evens([2, 4, 6]) == []\nassert op_div3_inc_evens([-7, 12, -7]) == []"}
{"id": "op_dropfirst_neg_counteven", "entry_point": "op_dropfirst_neg_counteven", "primitives": ["dropfirst", "neg", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then return how many values are even.", "solution": "def op_dropfirst_neg_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_neg_counteven([1, 2, 3, 4]) == 0\nassert op_dropfirst_neg_counteven([]) == 0\nassert op_dropfirst_neg_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_neg_counteven([5, 5, 5]) == 0\nassert op_dropfirst_neg_counteven([3, 1, 2]) == 0\nassert op_dropfirst_neg_counteven([10]) == 0\nassert op_dropfirst_neg_counteven([2, 4, 6]) == 0\nassert op_dropfirst_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_absval_sorta_anyeven", "entry_point": "op_absval_sorta_anyeven", "primitives": ["absval", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then return whether any value is even.", "solution": "def op_absval_sorta_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_absval_sorta_anyeven([]) == False\nassert op_absval_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_sorta_anyeven([5, 5, 5]) == False\nassert op_absval_sorta_anyeven([3, 1, 2]) == True\nassert op_absval_sorta_anyeven([10]) == True\nassert op_absval_sorta_anyeven([2, 4, 6]) == True\nassert op_absval_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_rev_clamp10_issorted", "entry_point": "op_rev_clamp10_issorted", "primitives": ["rev", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_rev_clamp10_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_rev_clamp10_issorted([1, 2, 3, 4]) == False\nassert op_rev_clamp10_issorted([]) == True\nassert op_rev_clamp10_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_clamp10_issorted([5, 5, 5]) == True\nassert op_rev_clamp10_issorted([3, 1, 2]) == False\nassert op_rev_clamp10_issorted([10]) == True\nassert op_rev_clamp10_issorted([2, 4, 6]) == False\nassert op_rev_clamp10_issorted([-7, 12, -7]) == False"}
{"id": "op_square_evens_add10", "entry_point": "op_square_evens_add10", "primitives": ["square", "evens", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then add ten to each.", "solution": "def op_square_evens_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_evens_add10([1, 2, 3, 4]) == [14, 26]\nassert op_square_evens_add10([]) == []\nassert op_square_evens_add10([-2, -1, 0, 1, 2]) == [14, 10, 14]\nassert op_square_evens_add10([5, 5, 5]) == []\nassert op_square_evens_add10([3, 1, 2]) == [14]\nassert op_square_evens_add10([10]) == [110]\nassert op_square_evens_add10([2, 4, 6]) == [14, 26, 46]\nassert op_square_evens_add10([-7, 12, -7]) == [154]"}
{"id": "op_padto3_takewhilepos_first3", "entry_point": "op_padto3_takewhilepos_first3", "primitives": ["padto3", "takewhilepos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then keep only the first three.", "solution": "def op_padto3_takewhilepos_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_takewhilepos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_takewhilepos_first3([]) == []\nassert op_padto3_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_first3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos_first3([10]) == [10]\nassert op_padto3_takewhilepos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_negate_last3_absval", "entry_point": "op_negate_last3_absval", "primitives": ["negate", "last3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then take the absolute value of each.", "solution": "def op_negate_last3_absval(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_negate_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_negate_last3_absval([]) == []\nassert op_negate_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_negate_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_negate_last3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_negate_last3_absval([10]) == [10]\nassert op_negate_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_negate_last3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_beforezero_sorta_anyeven", "entry_point": "op_beforezero_sorta_anyeven", "primitives": ["beforezero", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then return whether any value is even.", "solution": "def op_beforezero_sorta_anyeven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_beforezero_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_beforezero_sorta_anyeven([]) == False\nassert op_beforezero_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_sorta_anyeven([5, 5, 5]) == False\nassert op_beforezero_sorta_anyeven([3, 1, 2]) == True\nassert op_beforezero_sorta_anyeven([10]) == True\nassert op_beforezero_sorta_anyeven([2, 4, 6]) == True\nassert op_beforezero_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_padto3_uniq_trimends", "entry_point": "op_padto3_uniq_trimends", "primitives": ["padto3", "uniq", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then drop the first and last elements.", "solution": "def op_padto3_uniq_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_uniq_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_uniq_trimends([]) == []\nassert op_padto3_uniq_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_uniq_trimends([5, 5, 5]) == []\nassert op_padto3_uniq_trimends([3, 1, 2]) == [1]\nassert op_padto3_uniq_trimends([10]) == []\nassert op_padto3_uniq_trimends([2, 4, 6]) == [4]\nassert op_padto3_uniq_trimends([-7, 12, -7]) == []"}
{"id": "op_dec_gt5_counteven", "entry_point": "op_dec_gt5_counteven", "primitives": ["dec", "gt5", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then return how many values are even.", "solution": "def op_dec_gt5_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_dec_gt5_counteven([]) == 0\nassert op_dec_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dec_gt5_counteven([5, 5, 5]) == 0\nassert op_dec_gt5_counteven([3, 1, 2]) == 0\nassert op_dec_gt5_counteven([10]) == 0\nassert op_dec_gt5_counteven([2, 4, 6]) == 0\nassert op_dec_gt5_counteven([-7, 12, -7]) == 0"}
{"id": "op_sortd_last3_clamp10", "entry_point": "op_sortd_last3_clamp10", "primitives": ["sortd", "last3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three, then cap each value at 10.", "solution": "def op_sortd_last3_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortd_last3_clamp10([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_last3_clamp10([]) == []\nassert op_sortd_last3_clamp10([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_sortd_last3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_last3_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_last3_clamp10([10]) == [10]\nassert op_sortd_last3_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_last3_clamp10([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_dropzeros_oremptyzero_anyeven", "entry_point": "op_dropzeros_oremptyzero_anyeven", "primitives": ["dropzeros", "oremptyzero", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then return whether any value is even.", "solution": "def op_dropzeros_oremptyzero_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_oremptyzero_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_oremptyzero_anyeven([]) == True\nassert op_dropzeros_oremptyzero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_oremptyzero_anyeven([5, 5, 5]) == False\nassert op_dropzeros_oremptyzero_anyeven([3, 1, 2]) == True\nassert op_dropzeros_oremptyzero_anyeven([10]) == True\nassert op_dropzeros_oremptyzero_anyeven([2, 4, 6]) == True\nassert op_dropzeros_oremptyzero_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_odds_negate", "entry_point": "op_evens_odds_negate", "primitives": ["evens", "odds", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then negate each.", "solution": "def op_evens_odds_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_odds_negate([1, 2, 3, 4]) == []\nassert op_evens_odds_negate([]) == []\nassert op_evens_odds_negate([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_negate([5, 5, 5]) == []\nassert op_evens_odds_negate([3, 1, 2]) == []\nassert op_evens_odds_negate([10]) == []\nassert op_evens_odds_negate([2, 4, 6]) == []\nassert op_evens_odds_negate([-7, 12, -7]) == []"}
{"id": "op_uniq_square_haszero", "entry_point": "op_uniq_square_haszero", "primitives": ["uniq", "square", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then return whether the list contains a zero.", "solution": "def op_uniq_square_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_uniq_square_haszero([1, 2, 3, 4]) == False\nassert op_uniq_square_haszero([]) == False\nassert op_uniq_square_haszero([-2, -1, 0, 1, 2]) == True\nassert op_uniq_square_haszero([5, 5, 5]) == False\nassert op_uniq_square_haszero([3, 1, 2]) == False\nassert op_uniq_square_haszero([10]) == False\nassert op_uniq_square_haszero([2, 4, 6]) == False\nassert op_uniq_square_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_takewhilepos_absval", "entry_point": "op_padto3_takewhilepos_absval", "primitives": ["padto3", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then take the absolute value of each.", "solution": "def op_padto3_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_takewhilepos_absval([]) == []\nassert op_padto3_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos_absval([10]) == [10]\nassert op_padto3_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_double_first3_dropzeros", "entry_point": "op_double_first3_dropzeros", "primitives": ["double", "first3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three, then drop the zeros.", "solution": "def op_double_first3_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_first3_dropzeros([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_first3_dropzeros([]) == []\nassert op_double_first3_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_first3_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_double_first3_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_double_first3_dropzeros([10]) == [20]\nassert op_double_first3_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_double_first3_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_neg_square_dropfirst", "entry_point": "op_neg_square_dropfirst", "primitives": ["neg", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each, then drop the first element.", "solution": "def op_neg_square_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_neg_square_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_square_dropfirst([]) == []\nassert op_neg_square_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_neg_square_dropfirst([5, 5, 5]) == []\nassert op_neg_square_dropfirst([3, 1, 2]) == []\nassert op_neg_square_dropfirst([10]) == []\nassert op_neg_square_dropfirst([2, 4, 6]) == []\nassert op_neg_square_dropfirst([-7, 12, -7]) == [49]"}
{"id": "op_clamp10_neg_issorted", "entry_point": "op_clamp10_neg_issorted", "primitives": ["clamp10", "neg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_clamp10_neg_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_clamp10_neg_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_neg_issorted([]) == True\nassert op_clamp10_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_neg_issorted([5, 5, 5]) == True\nassert op_clamp10_neg_issorted([3, 1, 2]) == True\nassert op_clamp10_neg_issorted([10]) == True\nassert op_clamp10_neg_issorted([2, 4, 6]) == True\nassert op_clamp10_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_ages_last3_neg", "entry_point": "op_ages_last3_neg", "primitives": ["ages", "last3", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then keep the negative numbers.", "solution": "def op_ages_last3_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_last3_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_last3_neg([]) == []\nassert op_ages_last3_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_last3_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dec_double_add10", "entry_point": "op_dec_double_add10", "primitives": ["dec", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then add ten to each.", "solution": "def op_dec_double_add10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dec_double_add10([1, 2, 3, 4]) == [10, 12, 14, 16]\nassert op_dec_double_add10([]) == []\nassert op_dec_double_add10([-2, -1, 0, 1, 2]) == [4, 6, 8, 10, 12]\nassert op_dec_double_add10([5, 5, 5]) == [18, 18, 18]\nassert op_dec_double_add10([3, 1, 2]) == [14, 10, 12]\nassert op_dec_double_add10([10]) == [28]\nassert op_dec_double_add10([2, 4, 6]) == [12, 16, 20]\nassert op_dec_double_add10([-7, 12, -7]) == [-6, 32, -6]"}
{"id": "op_trimends_neg_takewhilepos", "entry_point": "op_trimends_neg_takewhilepos", "primitives": ["trimends", "neg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then take values while they are positive.", "solution": "def op_trimends_neg_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_trimends_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_trimends_neg_takewhilepos([]) == []\nassert op_trimends_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_trimends_neg_takewhilepos([5, 5, 5]) == []\nassert op_trimends_neg_takewhilepos([3, 1, 2]) == []\nassert op_trimends_neg_takewhilepos([10]) == []\nassert op_trimends_neg_takewhilepos([2, 4, 6]) == []\nassert op_trimends_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sortd_double_takewhilepos", "entry_point": "op_sortd_double_takewhilepos", "primitives": ["sortd", "double", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then take values while they are positive.", "solution": "def op_sortd_double_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_double_takewhilepos([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_double_takewhilepos([]) == []\nassert op_sortd_double_takewhilepos([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_sortd_double_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_double_takewhilepos([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_double_takewhilepos([10]) == [20]\nassert op_sortd_double_takewhilepos([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_double_takewhilepos([-7, 12, -7]) == [24]"}
{"id": "op_inc_pos_neg", "entry_point": "op_inc_pos_neg", "primitives": ["inc", "pos", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then keep the negative numbers.", "solution": "def op_inc_pos_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_pos_neg([1, 2, 3, 4]) == []\nassert op_inc_pos_neg([]) == []\nassert op_inc_pos_neg([-2, -1, 0, 1, 2]) == []\nassert op_inc_pos_neg([5, 5, 5]) == []\nassert op_inc_pos_neg([3, 1, 2]) == []\nassert op_inc_pos_neg([10]) == []\nassert op_inc_pos_neg([2, 4, 6]) == []\nassert op_inc_pos_neg([-7, 12, -7]) == []"}
{"id": "op_last3_dropzeros_len", "entry_point": "op_last3_dropzeros_len", "primitives": ["last3", "dropzeros", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then return how many remain.", "solution": "def op_last3_dropzeros_len(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_last3_dropzeros_len([1, 2, 3, 4]) == 3\nassert op_last3_dropzeros_len([]) == 0\nassert op_last3_dropzeros_len([-2, -1, 0, 1, 2]) == 2\nassert op_last3_dropzeros_len([5, 5, 5]) == 3\nassert op_last3_dropzeros_len([3, 1, 2]) == 3\nassert op_last3_dropzeros_len([10]) == 1\nassert op_last3_dropzeros_len([2, 4, 6]) == 3\nassert op_last3_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_square_div3_absval", "entry_point": "op_square_div3_absval", "primitives": ["square", "div3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then take the absolute value of each.", "solution": "def op_square_div3_absval(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_square_div3_absval([1, 2, 3, 4]) == [9]\nassert op_square_div3_absval([]) == []\nassert op_square_div3_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_square_div3_absval([5, 5, 5]) == []\nassert op_square_div3_absval([3, 1, 2]) == [9]\nassert op_square_div3_absval([10]) == []\nassert op_square_div3_absval([2, 4, 6]) == [36]\nassert op_square_div3_absval([-7, 12, -7]) == [144]"}
{"id": "op_gt5_div3_counteven", "entry_point": "op_gt5_div3_counteven", "primitives": ["gt5", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then return how many values are even.", "solution": "def op_gt5_div3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_div3_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_div3_counteven([]) == 0\nassert op_gt5_div3_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_div3_counteven([5, 5, 5]) == 0\nassert op_gt5_div3_counteven([3, 1, 2]) == 0\nassert op_gt5_div3_counteven([10]) == 0\nassert op_gt5_div3_counteven([2, 4, 6]) == 1\nassert op_gt5_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_odds_padto3_anyeven", "entry_point": "op_odds_padto3_anyeven", "primitives": ["odds", "padto3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_odds_padto3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_odds_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_odds_padto3_anyeven([]) == True\nassert op_odds_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_odds_padto3_anyeven([5, 5, 5]) == False\nassert op_odds_padto3_anyeven([3, 1, 2]) == True\nassert op_odds_padto3_anyeven([10]) == True\nassert op_odds_padto3_anyeven([2, 4, 6]) == True\nassert op_odds_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropzeros_pos_counteven", "entry_point": "op_dropzeros_pos_counteven", "primitives": ["dropzeros", "pos", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the positive numbers, then return how many values are even.", "solution": "def op_dropzeros_pos_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_pos_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_pos_counteven([]) == 0\nassert op_dropzeros_pos_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_dropzeros_pos_counteven([5, 5, 5]) == 0\nassert op_dropzeros_pos_counteven([3, 1, 2]) == 1\nassert op_dropzeros_pos_counteven([10]) == 1\nassert op_dropzeros_pos_counteven([2, 4, 6]) == 3\nassert op_dropzeros_pos_counteven([-7, 12, -7]) == 1"}
{"id": "op_absval_sortabs_pos", "entry_point": "op_absval_sortabs_pos", "primitives": ["absval", "sortabs", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then keep the positive numbers.", "solution": "def op_absval_sortabs_pos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_absval_sortabs_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_sortabs_pos([]) == []\nassert op_absval_sortabs_pos([-2, -1, 0, 1, 2]) == [1, 1, 2, 2]\nassert op_absval_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortabs_pos([10]) == [10]\nassert op_absval_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortabs_pos([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_clamp10_double_dropwhileneg", "entry_point": "op_clamp10_double_dropwhileneg", "primitives": ["clamp10", "double", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then drop the leading negative values.", "solution": "def op_clamp10_double_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_double_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_clamp10_double_dropwhileneg([]) == []\nassert op_clamp10_double_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_clamp10_double_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_clamp10_double_dropwhileneg([3, 1, 2]) == [6, 2, 4]\nassert op_clamp10_double_dropwhileneg([10]) == [20]\nassert op_clamp10_double_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_clamp10_double_dropwhileneg([-7, 12, -7]) == [20, -14]"}
{"id": "op_takewhilepos_absval_issorted", "entry_point": "op_takewhilepos_absval_issorted", "primitives": ["takewhilepos", "absval", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_takewhilepos_absval_issorted(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_takewhilepos_absval_issorted([1, 2, 3, 4]) == True\nassert op_takewhilepos_absval_issorted([]) == True\nassert op_takewhilepos_absval_issorted([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_absval_issorted([5, 5, 5]) == True\nassert op_takewhilepos_absval_issorted([3, 1, 2]) == False\nassert op_takewhilepos_absval_issorted([10]) == True\nassert op_takewhilepos_absval_issorted([2, 4, 6]) == True\nassert op_takewhilepos_absval_issorted([-7, 12, -7]) == True"}
{"id": "op_inc_odds_rev", "entry_point": "op_inc_odds_rev", "primitives": ["inc", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then reverse the order.", "solution": "def op_inc_odds_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_odds_rev([1, 2, 3, 4]) == [5, 3]\nassert op_inc_odds_rev([]) == []\nassert op_inc_odds_rev([-2, -1, 0, 1, 2]) == [3, 1, -1]\nassert op_inc_odds_rev([5, 5, 5]) == []\nassert op_inc_odds_rev([3, 1, 2]) == [3]\nassert op_inc_odds_rev([10]) == [11]\nassert op_inc_odds_rev([2, 4, 6]) == [7, 5, 3]\nassert op_inc_odds_rev([-7, 12, -7]) == [13]"}
{"id": "op_gt5_sortd_sortabs", "entry_point": "op_gt5_sortd_sortabs", "primitives": ["gt5", "sortd", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then sort by absolute value.", "solution": "def op_gt5_sortd_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_sortd_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_sortd_sortabs([]) == []\nassert op_gt5_sortd_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd_sortabs([5, 5, 5]) == []\nassert op_gt5_sortd_sortabs([3, 1, 2]) == []\nassert op_gt5_sortd_sortabs([10]) == [10]\nassert op_gt5_sortd_sortabs([2, 4, 6]) == [6]\nassert op_gt5_sortd_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_evens_odds_beforezero", "entry_point": "op_evens_odds_beforezero", "primitives": ["evens", "odds", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then keep everything before the first zero.", "solution": "def op_evens_odds_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_odds_beforezero([1, 2, 3, 4]) == []\nassert op_evens_odds_beforezero([]) == []\nassert op_evens_odds_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_beforezero([5, 5, 5]) == []\nassert op_evens_odds_beforezero([3, 1, 2]) == []\nassert op_evens_odds_beforezero([10]) == []\nassert op_evens_odds_beforezero([2, 4, 6]) == []\nassert op_evens_odds_beforezero([-7, 12, -7]) == []"}
{"id": "op_trimends_sortabs_firsteven", "entry_point": "op_trimends_sortabs_firsteven", "primitives": ["trimends", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_trimends_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_trimends_sortabs_firsteven([]) == 0\nassert op_trimends_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_sortabs_firsteven([5, 5, 5]) == 0\nassert op_trimends_sortabs_firsteven([3, 1, 2]) == 0\nassert op_trimends_sortabs_firsteven([10]) == 0\nassert op_trimends_sortabs_firsteven([2, 4, 6]) == 4\nassert op_trimends_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_inc_clamp10_evens", "entry_point": "op_inc_clamp10_evens", "primitives": ["inc", "clamp10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then keep the even numbers.", "solution": "def op_inc_clamp10_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_clamp10_evens([1, 2, 3, 4]) == [2, 4]\nassert op_inc_clamp10_evens([]) == []\nassert op_inc_clamp10_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_inc_clamp10_evens([5, 5, 5]) == [6, 6, 6]\nassert op_inc_clamp10_evens([3, 1, 2]) == [4, 2]\nassert op_inc_clamp10_evens([10]) == [10]\nassert op_inc_clamp10_evens([2, 4, 6]) == []\nassert op_inc_clamp10_evens([-7, 12, -7]) == [-6, 10, -6]"}
{"id": "op_first3_clamp10_sortabs", "entry_point": "op_first3_clamp10_sortabs", "primitives": ["first3", "clamp10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then sort by absolute value.", "solution": "def op_first3_clamp10_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_clamp10_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10_sortabs([]) == []\nassert op_first3_clamp10_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_clamp10_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_clamp10_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_clamp10_sortabs([10]) == [10]\nassert op_first3_clamp10_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10_sortabs([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_padto3_first3_absval", "entry_point": "op_padto3_first3_absval", "primitives": ["padto3", "first3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then take the absolute value of each.", "solution": "def op_padto3_first3_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_first3_absval([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_first3_absval([]) == [0, 0, 0]\nassert op_padto3_first3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_padto3_first3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_first3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_first3_absval([10]) == [10, 0, 0]\nassert op_padto3_first3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_first3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_uniq_pos_evens", "entry_point": "op_uniq_pos_evens", "primitives": ["uniq", "pos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then keep the even numbers.", "solution": "def op_uniq_pos_evens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_uniq_pos_evens([1, 2, 3, 4]) == [2, 4]\nassert op_uniq_pos_evens([]) == []\nassert op_uniq_pos_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_uniq_pos_evens([5, 5, 5]) == []\nassert op_uniq_pos_evens([3, 1, 2]) == [2]\nassert op_uniq_pos_evens([10]) == [10]\nassert op_uniq_pos_evens([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_pos_evens([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_oremptyzero_absval", "entry_point": "op_takewhilepos_oremptyzero_absval", "primitives": ["takewhilepos", "oremptyzero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then take the absolute value of each.", "solution": "def op_takewhilepos_oremptyzero_absval(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_takewhilepos_oremptyzero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_oremptyzero_absval([]) == [0]\nassert op_takewhilepos_oremptyzero_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_oremptyzero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_oremptyzero_absval([10]) == [10]\nassert op_takewhilepos_oremptyzero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_oremptyzero_absval([-7, 12, -7]) == [0]"}
{"id": "op_absval_dropzeros_dec", "entry_point": "op_absval_dropzeros_dec", "primitives": ["absval", "dropzeros", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then subtract one from each.", "solution": "def op_absval_dropzeros_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_absval_dropzeros_dec([]) == []\nassert op_absval_dropzeros_dec([-2, -1, 0, 1, 2]) == [1, 0, 0, 1]\nassert op_absval_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_dropzeros_dec([3, 1, 2]) == [2, 0, 1]\nassert op_absval_dropzeros_dec([10]) == [9]\nassert op_absval_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_absval_dropzeros_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_oremptyzero_absval_haszero", "entry_point": "op_oremptyzero_absval_haszero", "primitives": ["oremptyzero", "absval", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_oremptyzero_absval_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_oremptyzero_absval_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_absval_haszero([]) == True\nassert op_oremptyzero_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_absval_haszero([5, 5, 5]) == False\nassert op_oremptyzero_absval_haszero([3, 1, 2]) == False\nassert op_oremptyzero_absval_haszero([10]) == False\nassert op_oremptyzero_absval_haszero([2, 4, 6]) == False\nassert op_oremptyzero_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_rev_padto3_max", "entry_point": "op_rev_padto3_max", "primitives": ["rev", "padto3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_rev_padto3_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_rev_padto3_max([1, 2, 3, 4]) == 4\nassert op_rev_padto3_max([]) == 0\nassert op_rev_padto3_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_padto3_max([5, 5, 5]) == 5\nassert op_rev_padto3_max([3, 1, 2]) == 3\nassert op_rev_padto3_max([10]) == 10\nassert op_rev_padto3_max([2, 4, 6]) == 6\nassert op_rev_padto3_max([-7, 12, -7]) == 12"}
{"id": "op_gt5_last3_sorta", "entry_point": "op_gt5_last3_sorta", "primitives": ["gt5", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three, then sort ascending.", "solution": "def op_gt5_last3_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_last3_sorta([1, 2, 3, 4]) == []\nassert op_gt5_last3_sorta([]) == []\nassert op_gt5_last3_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_last3_sorta([5, 5, 5]) == []\nassert op_gt5_last3_sorta([3, 1, 2]) == []\nassert op_gt5_last3_sorta([10]) == [10]\nassert op_gt5_last3_sorta([2, 4, 6]) == [6]\nassert op_gt5_last3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_dropwhileneg_evens", "entry_point": "op_clamp10_dropwhileneg_evens", "primitives": ["clamp10", "dropwhileneg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then keep the even numbers.", "solution": "def op_clamp10_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_clamp10_dropwhileneg_evens([1, 2, 3, 4]) == [2, 4]\nassert op_clamp10_dropwhileneg_evens([]) == []\nassert op_clamp10_dropwhileneg_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_clamp10_dropwhileneg_evens([5, 5, 5]) == []\nassert op_clamp10_dropwhileneg_evens([3, 1, 2]) == [2]\nassert op_clamp10_dropwhileneg_evens([10]) == [10]\nassert op_clamp10_dropwhileneg_evens([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg_evens([-7, 12, -7]) == [10]"}
{"id": "op_first3_sortd_gt5", "entry_point": "op_first3_sortd_gt5", "primitives": ["first3", "sortd", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then keep values greater than five.", "solution": "def op_first3_sortd_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_sortd_gt5([1, 2, 3, 4]) == []\nassert op_first3_sortd_gt5([]) == []\nassert op_first3_sortd_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_sortd_gt5([5, 5, 5]) == []\nassert op_first3_sortd_gt5([3, 1, 2]) == []\nassert op_first3_sortd_gt5([10]) == [10]\nassert op_first3_sortd_gt5([2, 4, 6]) == [6]\nassert op_first3_sortd_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dec_gt5_square", "entry_point": "op_dec_gt5_square", "primitives": ["dec", "gt5", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then square each.", "solution": "def op_dec_gt5_square(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dec_gt5_square([1, 2, 3, 4]) == []\nassert op_dec_gt5_square([]) == []\nassert op_dec_gt5_square([-2, -1, 0, 1, 2]) == []\nassert op_dec_gt5_square([5, 5, 5]) == []\nassert op_dec_gt5_square([3, 1, 2]) == []\nassert op_dec_gt5_square([10]) == [81]\nassert op_dec_gt5_square([2, 4, 6]) == []\nassert op_dec_gt5_square([-7, 12, -7]) == [121]"}
{"id": "op_clamp10_absval_anyeven", "entry_point": "op_clamp10_absval_anyeven", "primitives": ["clamp10", "absval", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then return whether any value is even.", "solution": "def op_clamp10_absval_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_absval_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_absval_anyeven([]) == False\nassert op_clamp10_absval_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_absval_anyeven([5, 5, 5]) == False\nassert op_clamp10_absval_anyeven([3, 1, 2]) == True\nassert op_clamp10_absval_anyeven([10]) == True\nassert op_clamp10_absval_anyeven([2, 4, 6]) == True\nassert op_clamp10_absval_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_sortd_clamp10", "entry_point": "op_absval_sortd_clamp10", "primitives": ["absval", "sortd", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then cap each value at 10.", "solution": "def op_absval_sortd_clamp10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_absval_sortd_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_sortd_clamp10([]) == []\nassert op_absval_sortd_clamp10([-2, -1, 0, 1, 2]) == [2, 2, 1, 1, 0]\nassert op_absval_sortd_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortd_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_absval_sortd_clamp10([10]) == [10]\nassert op_absval_sortd_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_absval_sortd_clamp10([-7, 12, -7]) == [10, 7, 7]"}
{"id": "op_sortabs_odds_rev", "entry_point": "op_sortabs_odds_rev", "primitives": ["sortabs", "odds", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the odd numbers, then reverse the order.", "solution": "def op_sortabs_odds_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_odds_rev([1, 2, 3, 4]) == [3, 1]\nassert op_sortabs_odds_rev([]) == []\nassert op_sortabs_odds_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortabs_odds_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_odds_rev([3, 1, 2]) == [3, 1]\nassert op_sortabs_odds_rev([10]) == []\nassert op_sortabs_odds_rev([2, 4, 6]) == []\nassert op_sortabs_odds_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_takewhilepos_sortd", "entry_point": "op_div3_takewhilepos_sortd", "primitives": ["div3", "takewhilepos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then sort descending.", "solution": "def op_div3_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_div3_takewhilepos_sortd([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos_sortd([]) == []\nassert op_div3_takewhilepos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_sortd([5, 5, 5]) == []\nassert op_div3_takewhilepos_sortd([3, 1, 2]) == [3]\nassert op_div3_takewhilepos_sortd([10]) == []\nassert op_div3_takewhilepos_sortd([2, 4, 6]) == [6]\nassert op_div3_takewhilepos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_square_gt5_len", "entry_point": "op_square_gt5_len", "primitives": ["square", "gt5", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then return how many remain.", "solution": "def op_square_gt5_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_square_gt5_len([1, 2, 3, 4]) == 2\nassert op_square_gt5_len([]) == 0\nassert op_square_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_square_gt5_len([5, 5, 5]) == 3\nassert op_square_gt5_len([3, 1, 2]) == 1\nassert op_square_gt5_len([10]) == 1\nassert op_square_gt5_len([2, 4, 6]) == 2\nassert op_square_gt5_len([-7, 12, -7]) == 3"}
{"id": "op_clamp10_odds_sortd", "entry_point": "op_clamp10_odds_sortd", "primitives": ["clamp10", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then sort descending.", "solution": "def op_clamp10_odds_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_clamp10_odds_sortd([]) == []\nassert op_clamp10_odds_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_clamp10_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_clamp10_odds_sortd([10]) == []\nassert op_clamp10_odds_sortd([2, 4, 6]) == []\nassert op_clamp10_odds_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dec_oremptyzero_rev", "entry_point": "op_dec_oremptyzero_rev", "primitives": ["dec", "oremptyzero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then reverse the order.", "solution": "def op_dec_oremptyzero_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_oremptyzero_rev([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_oremptyzero_rev([]) == [0]\nassert op_dec_oremptyzero_rev([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_dec_oremptyzero_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_oremptyzero_rev([3, 1, 2]) == [1, 0, 2]\nassert op_dec_oremptyzero_rev([10]) == [9]\nassert op_dec_oremptyzero_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_oremptyzero_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_gt5_negate_max", "entry_point": "op_gt5_negate_max", "primitives": ["gt5", "negate", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then return the maximum (0 if empty).", "solution": "def op_gt5_negate_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return max(r) if r else 0", "tests": "assert op_gt5_negate_max([1, 2, 3, 4]) == 0\nassert op_gt5_negate_max([]) == 0\nassert op_gt5_negate_max([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_negate_max([5, 5, 5]) == 0\nassert op_gt5_negate_max([3, 1, 2]) == 0\nassert op_gt5_negate_max([10]) == -10\nassert op_gt5_negate_max([2, 4, 6]) == -6\nassert op_gt5_negate_max([-7, 12, -7]) == -12"}
{"id": "op_padto3_sortabs_haszero", "entry_point": "op_padto3_sortabs_haszero", "primitives": ["padto3", "sortabs", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then return whether the list contains a zero.", "solution": "def op_padto3_sortabs_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_padto3_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_padto3_sortabs_haszero([]) == True\nassert op_padto3_sortabs_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_sortabs_haszero([5, 5, 5]) == False\nassert op_padto3_sortabs_haszero([3, 1, 2]) == False\nassert op_padto3_sortabs_haszero([10]) == True\nassert op_padto3_sortabs_haszero([2, 4, 6]) == False\nassert op_padto3_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_gt5_pos", "entry_point": "op_dec_gt5_pos", "primitives": ["dec", "gt5", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then keep the positive numbers.", "solution": "def op_dec_gt5_pos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dec_gt5_pos([1, 2, 3, 4]) == []\nassert op_dec_gt5_pos([]) == []\nassert op_dec_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_dec_gt5_pos([5, 5, 5]) == []\nassert op_dec_gt5_pos([3, 1, 2]) == []\nassert op_dec_gt5_pos([10]) == [9]\nassert op_dec_gt5_pos([2, 4, 6]) == []\nassert op_dec_gt5_pos([-7, 12, -7]) == [11]"}
{"id": "op_square_clamp10_counteven", "entry_point": "op_square_clamp10_counteven", "primitives": ["square", "clamp10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then return how many values are even.", "solution": "def op_square_clamp10_counteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_square_clamp10_counteven([1, 2, 3, 4]) == 2\nassert op_square_clamp10_counteven([]) == 0\nassert op_square_clamp10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_square_clamp10_counteven([5, 5, 5]) == 3\nassert op_square_clamp10_counteven([3, 1, 2]) == 1\nassert op_square_clamp10_counteven([10]) == 1\nassert op_square_clamp10_counteven([2, 4, 6]) == 3\nassert op_square_clamp10_counteven([-7, 12, -7]) == 3"}
{"id": "op_sorta_dropfirst_alldistinct", "entry_point": "op_sorta_dropfirst_alldistinct", "primitives": ["sorta", "dropfirst", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first element, then return whether all values are distinct.", "solution": "def op_sorta_dropfirst_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:]\n    return len(r) == len(set(r))", "tests": "assert op_sorta_dropfirst_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_dropfirst_alldistinct([]) == True\nassert op_sorta_dropfirst_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sorta_dropfirst_alldistinct([5, 5, 5]) == False\nassert op_sorta_dropfirst_alldistinct([3, 1, 2]) == True\nassert op_sorta_dropfirst_alldistinct([10]) == True\nassert op_sorta_dropfirst_alldistinct([2, 4, 6]) == True\nassert op_sorta_dropfirst_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortd_absval_dec", "entry_point": "op_sortd_absval_dec", "primitives": ["sortd", "absval", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then subtract one from each.", "solution": "def op_sortd_absval_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_absval_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortd_absval_dec([]) == []\nassert op_sortd_absval_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, 0, 1]\nassert op_sortd_absval_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_absval_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_absval_dec([10]) == [9]\nassert op_sortd_absval_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_absval_dec([-7, 12, -7]) == [11, 6, 6]"}
{"id": "op_ages_sortd_clamp10", "entry_point": "op_ages_sortd_clamp10", "primitives": ["ages", "sortd", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then cap each value at 10.", "solution": "def op_ages_sortd_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_sortd_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_sortd_clamp10([]) == []\nassert op_ages_sortd_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_sortd_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_double_odds_sorta", "entry_point": "op_double_odds_sorta", "primitives": ["double", "odds", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then sort ascending.", "solution": "def op_double_odds_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_double_odds_sorta([1, 2, 3, 4]) == []\nassert op_double_odds_sorta([]) == []\nassert op_double_odds_sorta([-2, -1, 0, 1, 2]) == []\nassert op_double_odds_sorta([5, 5, 5]) == []\nassert op_double_odds_sorta([3, 1, 2]) == []\nassert op_double_odds_sorta([10]) == []\nassert op_double_odds_sorta([2, 4, 6]) == []\nassert op_double_odds_sorta([-7, 12, -7]) == []"}
{"id": "op_negate_gt5_uniq", "entry_point": "op_negate_gt5_uniq", "primitives": ["negate", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_negate_gt5_uniq(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_negate_gt5_uniq([1, 2, 3, 4]) == []\nassert op_negate_gt5_uniq([]) == []\nassert op_negate_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_negate_gt5_uniq([5, 5, 5]) == []\nassert op_negate_gt5_uniq([3, 1, 2]) == []\nassert op_negate_gt5_uniq([10]) == []\nassert op_negate_gt5_uniq([2, 4, 6]) == []\nassert op_negate_gt5_uniq([-7, 12, -7]) == [7]"}
{"id": "op_inc_sortd_takewhilepos", "entry_point": "op_inc_sortd_takewhilepos", "primitives": ["inc", "sortd", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then take values while they are positive.", "solution": "def op_inc_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_sortd_takewhilepos([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_sortd_takewhilepos([]) == []\nassert op_inc_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_inc_sortd_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortd_takewhilepos([3, 1, 2]) == [4, 3, 2]\nassert op_inc_sortd_takewhilepos([10]) == [11]\nassert op_inc_sortd_takewhilepos([2, 4, 6]) == [7, 5, 3]\nassert op_inc_sortd_takewhilepos([-7, 12, -7]) == [13]"}
{"id": "op_beforezero_sortabs_last3", "entry_point": "op_beforezero_sortabs_last3", "primitives": ["beforezero", "sortabs", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then keep only the last three.", "solution": "def op_beforezero_sortabs_last3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_beforezero_sortabs_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_sortabs_last3([]) == []\nassert op_beforezero_sortabs_last3([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortabs_last3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortabs_last3([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortabs_last3([10]) == [10]\nassert op_beforezero_sortabs_last3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortabs_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortlen_strip_lens", "entry_point": "op_sortlen_strip_lens", "primitives": ["sortlen", "strip", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then trim whitespace from each, then return the total number of characters.", "solution": "def op_sortlen_strip_lens(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_sortlen_strip_lens(['Hello', 'world']) == 10\nassert op_sortlen_strip_lens([]) == 0\nassert op_sortlen_strip_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_sortlen_strip_lens(['one', 'one', 'Two']) == 9\nassert op_sortlen_strip_lens(['x']) == 1\nassert op_sortlen_strip_lens(['abc', 'de', '']) == 5"}
{"id": "op_takewhilepos_double_beforezero", "entry_point": "op_takewhilepos_double_beforezero", "primitives": ["takewhilepos", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then keep everything before the first zero.", "solution": "def op_takewhilepos_double_beforezero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_takewhilepos_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_double_beforezero([]) == []\nassert op_takewhilepos_double_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_double_beforezero([10]) == [20]\nassert op_takewhilepos_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_double_beforezero([-7, 12, -7]) == []"}
{"id": "op_inc_evens_sum", "entry_point": "op_inc_evens_sum", "primitives": ["inc", "evens", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then return their sum.", "solution": "def op_inc_evens_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_inc_evens_sum([1, 2, 3, 4]) == 6\nassert op_inc_evens_sum([]) == 0\nassert op_inc_evens_sum([-2, -1, 0, 1, 2]) == 2\nassert op_inc_evens_sum([5, 5, 5]) == 18\nassert op_inc_evens_sum([3, 1, 2]) == 6\nassert op_inc_evens_sum([10]) == 0\nassert op_inc_evens_sum([2, 4, 6]) == 0\nassert op_inc_evens_sum([-7, 12, -7]) == -12"}
{"id": "op_double_takewhilepos_inc", "entry_point": "op_double_takewhilepos_inc", "primitives": ["double", "takewhilepos", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then add one to each.", "solution": "def op_double_takewhilepos_inc(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_double_takewhilepos_inc([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_double_takewhilepos_inc([]) == []\nassert op_double_takewhilepos_inc([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos_inc([5, 5, 5]) == [11, 11, 11]\nassert op_double_takewhilepos_inc([3, 1, 2]) == [7, 3, 5]\nassert op_double_takewhilepos_inc([10]) == [21]\nassert op_double_takewhilepos_inc([2, 4, 6]) == [5, 9, 13]\nassert op_double_takewhilepos_inc([-7, 12, -7]) == []"}
{"id": "op_add10_takewhilepos_sortd", "entry_point": "op_add10_takewhilepos_sortd", "primitives": ["add10", "takewhilepos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then sort descending.", "solution": "def op_add10_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_takewhilepos_sortd([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_takewhilepos_sortd([]) == []\nassert op_add10_takewhilepos_sortd([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_takewhilepos_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_add10_takewhilepos_sortd([10]) == [20]\nassert op_add10_takewhilepos_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_add10_takewhilepos_sortd([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_dropfirst_dropzeros_oremptyzero", "entry_point": "op_dropfirst_dropzeros_oremptyzero", "primitives": ["dropfirst", "dropzeros", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then if empty, use a single zero.", "solution": "def op_dropfirst_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_dropzeros_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropzeros_oremptyzero([]) == [0]\nassert op_dropfirst_dropzeros_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropfirst_dropzeros_oremptyzero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dropzeros_oremptyzero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dropzeros_oremptyzero([10]) == [0]\nassert op_dropfirst_dropzeros_oremptyzero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dropzeros_oremptyzero([-7, 12, -7]) == [12, -7]"}
{"id": "op_sorta_padto3_clamp10", "entry_point": "op_sorta_padto3_clamp10", "primitives": ["sorta", "padto3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then cap each value at 10.", "solution": "def op_sorta_padto3_clamp10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sorta_padto3_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_padto3_clamp10([]) == [0, 0, 0]\nassert op_sorta_padto3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_padto3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_padto3_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_padto3_clamp10([10]) == [10, 0, 0]\nassert op_sorta_padto3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_padto3_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_odds_rev_first3", "entry_point": "op_odds_rev_first3", "primitives": ["odds", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then keep only the first three.", "solution": "def op_odds_rev_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_odds_rev_first3([1, 2, 3, 4]) == [3, 1]\nassert op_odds_rev_first3([]) == []\nassert op_odds_rev_first3([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_rev_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_rev_first3([3, 1, 2]) == [1, 3]\nassert op_odds_rev_first3([10]) == []\nassert op_odds_rev_first3([2, 4, 6]) == []\nassert op_odds_rev_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_rev_evens", "entry_point": "op_div3_rev_evens", "primitives": ["div3", "rev", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then keep the even numbers.", "solution": "def op_div3_rev_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_div3_rev_evens([1, 2, 3, 4]) == []\nassert op_div3_rev_evens([]) == []\nassert op_div3_rev_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev_evens([5, 5, 5]) == []\nassert op_div3_rev_evens([3, 1, 2]) == []\nassert op_div3_rev_evens([10]) == []\nassert op_div3_rev_evens([2, 4, 6]) == [6]\nassert op_div3_rev_evens([-7, 12, -7]) == [12]"}
{"id": "op_rev_neg_trimends", "entry_point": "op_rev_neg_trimends", "primitives": ["rev", "neg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_rev_neg_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_neg_trimends([1, 2, 3, 4]) == []\nassert op_rev_neg_trimends([]) == []\nassert op_rev_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_rev_neg_trimends([5, 5, 5]) == []\nassert op_rev_neg_trimends([3, 1, 2]) == []\nassert op_rev_neg_trimends([10]) == []\nassert op_rev_neg_trimends([2, 4, 6]) == []\nassert op_rev_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_evens_sorta_gt5", "entry_point": "op_evens_sorta_gt5", "primitives": ["evens", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then keep values greater than five.", "solution": "def op_evens_sorta_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_sorta_gt5([1, 2, 3, 4]) == []\nassert op_evens_sorta_gt5([]) == []\nassert op_evens_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_sorta_gt5([5, 5, 5]) == []\nassert op_evens_sorta_gt5([3, 1, 2]) == []\nassert op_evens_sorta_gt5([10]) == [10]\nassert op_evens_sorta_gt5([2, 4, 6]) == [6]\nassert op_evens_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_negate_add10_dropwhileneg", "entry_point": "op_negate_add10_dropwhileneg", "primitives": ["negate", "add10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then drop the leading negative values.", "solution": "def op_negate_add10_dropwhileneg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_negate_add10_dropwhileneg([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_add10_dropwhileneg([]) == []\nassert op_negate_add10_dropwhileneg([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_negate_add10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_negate_add10_dropwhileneg([3, 1, 2]) == [7, 9, 8]\nassert op_negate_add10_dropwhileneg([10]) == [0]\nassert op_negate_add10_dropwhileneg([2, 4, 6]) == [8, 6, 4]\nassert op_negate_add10_dropwhileneg([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_inc_absval_odds", "entry_point": "op_inc_absval_odds", "primitives": ["inc", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_inc_absval_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_absval_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_absval_odds([]) == []\nassert op_inc_absval_odds([-2, -1, 0, 1, 2]) == [1, 1, 3]\nassert op_inc_absval_odds([5, 5, 5]) == []\nassert op_inc_absval_odds([3, 1, 2]) == [3]\nassert op_inc_absval_odds([10]) == [11]\nassert op_inc_absval_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_absval_odds([-7, 12, -7]) == [13]"}
{"id": "op_sortalpha_dropshort_strip", "entry_point": "op_sortalpha_dropshort_strip", "primitives": ["sortalpha", "dropshort", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters, then trim whitespace from each.", "solution": "def op_sortalpha_dropshort_strip(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_sortalpha_dropshort_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_dropshort_strip([]) == []\nassert op_sortalpha_dropshort_strip(['  a ', '', 'BC', 'bc']) == ['a']\nassert op_sortalpha_dropshort_strip(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_dropshort_strip(['x']) == []\nassert op_sortalpha_dropshort_strip(['abc', 'de', '']) == ['abc']"}
{"id": "op_double_sorta_counteven", "entry_point": "op_double_sorta_counteven", "primitives": ["double", "sorta", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending, then return how many values are even.", "solution": "def op_double_sorta_counteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_double_sorta_counteven([1, 2, 3, 4]) == 4\nassert op_double_sorta_counteven([]) == 0\nassert op_double_sorta_counteven([-2, -1, 0, 1, 2]) == 5\nassert op_double_sorta_counteven([5, 5, 5]) == 3\nassert op_double_sorta_counteven([3, 1, 2]) == 3\nassert op_double_sorta_counteven([10]) == 1\nassert op_double_sorta_counteven([2, 4, 6]) == 3\nassert op_double_sorta_counteven([-7, 12, -7]) == 3"}
{"id": "op_square_odds_haszero", "entry_point": "op_square_odds_haszero", "primitives": ["square", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_square_odds_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_square_odds_haszero([1, 2, 3, 4]) == False\nassert op_square_odds_haszero([]) == False\nassert op_square_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_square_odds_haszero([5, 5, 5]) == False\nassert op_square_odds_haszero([3, 1, 2]) == False\nassert op_square_odds_haszero([10]) == False\nassert op_square_odds_haszero([2, 4, 6]) == False\nassert op_square_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_square_allpos", "entry_point": "op_dropwhileneg_square_allpos", "primitives": ["dropwhileneg", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then return whether all values are positive.", "solution": "def op_dropwhileneg_square_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_square_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_square_allpos([]) == True\nassert op_dropwhileneg_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_square_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_square_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_square_allpos([10]) == True\nassert op_dropwhileneg_square_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_square_allpos([-7, 12, -7]) == True"}
{"id": "op_rev_negate_neg", "entry_point": "op_rev_negate_neg", "primitives": ["rev", "negate", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then keep the negative numbers.", "solution": "def op_rev_negate_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_negate_neg([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_rev_negate_neg([]) == []\nassert op_rev_negate_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_rev_negate_neg([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_negate_neg([3, 1, 2]) == [-2, -1, -3]\nassert op_rev_negate_neg([10]) == [-10]\nassert op_rev_negate_neg([2, 4, 6]) == [-6, -4, -2]\nassert op_rev_negate_neg([-7, 12, -7]) == [-12]"}
{"id": "op_sortabs_evens_gt5", "entry_point": "op_sortabs_evens_gt5", "primitives": ["sortabs", "evens", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then keep values greater than five.", "solution": "def op_sortabs_evens_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_evens_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_evens_gt5([]) == []\nassert op_sortabs_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_evens_gt5([5, 5, 5]) == []\nassert op_sortabs_evens_gt5([3, 1, 2]) == []\nassert op_sortabs_evens_gt5([10]) == [10]\nassert op_sortabs_evens_gt5([2, 4, 6]) == [6]\nassert op_sortabs_evens_gt5([-7, 12, -7]) == [12]"}
{"id": "op_evens_div3_rev", "entry_point": "op_evens_div3_rev", "primitives": ["evens", "div3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then reverse the order.", "solution": "def op_evens_div3_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_evens_div3_rev([1, 2, 3, 4]) == []\nassert op_evens_div3_rev([]) == []\nassert op_evens_div3_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_div3_rev([5, 5, 5]) == []\nassert op_evens_div3_rev([3, 1, 2]) == []\nassert op_evens_div3_rev([10]) == []\nassert op_evens_div3_rev([2, 4, 6]) == [6]\nassert op_evens_div3_rev([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_rev_dropfirst", "entry_point": "op_dropzeros_rev_dropfirst", "primitives": ["dropzeros", "rev", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then drop the first element.", "solution": "def op_dropzeros_rev_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_rev_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dropzeros_rev_dropfirst([]) == []\nassert op_dropzeros_rev_dropfirst([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_dropzeros_rev_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_rev_dropfirst([3, 1, 2]) == [1, 3]\nassert op_dropzeros_rev_dropfirst([10]) == []\nassert op_dropzeros_rev_dropfirst([2, 4, 6]) == [4, 2]\nassert op_dropzeros_rev_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortabs_clamp10_firsteven", "entry_point": "op_sortabs_clamp10_firsteven", "primitives": ["sortabs", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_sortabs_clamp10_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_sortabs_clamp10_firsteven([]) == 0\nassert op_sortabs_clamp10_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_clamp10_firsteven([5, 5, 5]) == 0\nassert op_sortabs_clamp10_firsteven([3, 1, 2]) == 2\nassert op_sortabs_clamp10_firsteven([10]) == 10\nassert op_sortabs_clamp10_firsteven([2, 4, 6]) == 2\nassert op_sortabs_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_absval_beforezero_max", "entry_point": "op_absval_beforezero_max", "primitives": ["absval", "beforezero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_absval_beforezero_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_absval_beforezero_max([1, 2, 3, 4]) == 4\nassert op_absval_beforezero_max([]) == 0\nassert op_absval_beforezero_max([-2, -1, 0, 1, 2]) == 2\nassert op_absval_beforezero_max([5, 5, 5]) == 5\nassert op_absval_beforezero_max([3, 1, 2]) == 3\nassert op_absval_beforezero_max([10]) == 10\nassert op_absval_beforezero_max([2, 4, 6]) == 6\nassert op_absval_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_clamp10_oremptyzero_last3", "entry_point": "op_clamp10_oremptyzero_last3", "primitives": ["clamp10", "oremptyzero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then if empty, use a single zero, then keep only the last three.", "solution": "def op_clamp10_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_oremptyzero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_oremptyzero_last3([]) == [0]\nassert op_clamp10_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_oremptyzero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_oremptyzero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_oremptyzero_last3([10]) == [10]\nassert op_clamp10_oremptyzero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_oremptyzero_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_div3_rev_dec", "entry_point": "op_div3_rev_dec", "primitives": ["div3", "rev", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then subtract one from each.", "solution": "def op_div3_rev_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_rev_dec([1, 2, 3, 4]) == [2]\nassert op_div3_rev_dec([]) == []\nassert op_div3_rev_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_rev_dec([5, 5, 5]) == []\nassert op_div3_rev_dec([3, 1, 2]) == [2]\nassert op_div3_rev_dec([10]) == []\nassert op_div3_rev_dec([2, 4, 6]) == [5]\nassert op_div3_rev_dec([-7, 12, -7]) == [11]"}
{"id": "op_inc_sorta_first3", "entry_point": "op_inc_sorta_first3", "primitives": ["inc", "sorta", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then keep only the first three.", "solution": "def op_inc_sorta_first3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = r[:3]\n    return r", "tests": "assert op_inc_sorta_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_sorta_first3([]) == []\nassert op_inc_sorta_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_sorta_first3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sorta_first3([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sorta_first3([10]) == [11]\nassert op_inc_sorta_first3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta_first3([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_ages_dropwhileneg_neg", "entry_point": "op_ages_dropwhileneg_neg", "primitives": ["ages", "dropwhileneg", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_ages_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_dropwhileneg_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_dropwhileneg_neg([]) == []\nassert op_ages_dropwhileneg_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_dropwhileneg_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_trimends_dropzeros_rev", "entry_point": "op_trimends_dropzeros_rev", "primitives": ["trimends", "dropzeros", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then reverse the order.", "solution": "def op_trimends_dropzeros_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_dropzeros_rev([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_dropzeros_rev([]) == []\nassert op_trimends_dropzeros_rev([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_trimends_dropzeros_rev([5, 5, 5]) == [5]\nassert op_trimends_dropzeros_rev([3, 1, 2]) == [1]\nassert op_trimends_dropzeros_rev([10]) == []\nassert op_trimends_dropzeros_rev([2, 4, 6]) == [4]\nassert op_trimends_dropzeros_rev([-7, 12, -7]) == [12]"}
{"id": "op_gt5_add10_takewhilepos", "entry_point": "op_gt5_add10_takewhilepos", "primitives": ["gt5", "add10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then take values while they are positive.", "solution": "def op_gt5_add10_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_add10_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_add10_takewhilepos([]) == []\nassert op_gt5_add10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_takewhilepos([5, 5, 5]) == []\nassert op_gt5_add10_takewhilepos([3, 1, 2]) == []\nassert op_gt5_add10_takewhilepos([10]) == [20]\nassert op_gt5_add10_takewhilepos([2, 4, 6]) == [16]\nassert op_gt5_add10_takewhilepos([-7, 12, -7]) == [22]"}
{"id": "op_square_div3_add10", "entry_point": "op_square_div3_add10", "primitives": ["square", "div3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then add ten to each.", "solution": "def op_square_div3_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_div3_add10([1, 2, 3, 4]) == [19]\nassert op_square_div3_add10([]) == []\nassert op_square_div3_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_square_div3_add10([5, 5, 5]) == []\nassert op_square_div3_add10([3, 1, 2]) == [19]\nassert op_square_div3_add10([10]) == []\nassert op_square_div3_add10([2, 4, 6]) == [46]\nassert op_square_div3_add10([-7, 12, -7]) == [154]"}
{"id": "op_takewhilepos_dropfirst_haszero", "entry_point": "op_takewhilepos_dropfirst_haszero", "primitives": ["takewhilepos", "dropfirst", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element, then return whether the list contains a zero.", "solution": "def op_takewhilepos_dropfirst_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return 0 in r", "tests": "assert op_takewhilepos_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_dropfirst_haszero([]) == False\nassert op_takewhilepos_dropfirst_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_dropfirst_haszero([5, 5, 5]) == False\nassert op_takewhilepos_dropfirst_haszero([3, 1, 2]) == False\nassert op_takewhilepos_dropfirst_haszero([10]) == False\nassert op_takewhilepos_dropfirst_haszero([2, 4, 6]) == False\nassert op_takewhilepos_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_dropzeros_haszero", "entry_point": "op_dropwhileneg_dropzeros_haszero", "primitives": ["dropwhileneg", "dropzeros", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_dropzeros_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_dropwhileneg_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_dropzeros_haszero([]) == False\nassert op_dropwhileneg_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_dropzeros_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_dropzeros_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_dropzeros_haszero([10]) == False\nassert op_dropwhileneg_dropzeros_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_rev_clamp10_len", "entry_point": "op_rev_clamp10_len", "primitives": ["rev", "clamp10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then return how many remain.", "solution": "def op_rev_clamp10_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_rev_clamp10_len([1, 2, 3, 4]) == 4\nassert op_rev_clamp10_len([]) == 0\nassert op_rev_clamp10_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_clamp10_len([5, 5, 5]) == 3\nassert op_rev_clamp10_len([3, 1, 2]) == 3\nassert op_rev_clamp10_len([10]) == 1\nassert op_rev_clamp10_len([2, 4, 6]) == 3\nassert op_rev_clamp10_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_uniq_dropwhileneg", "entry_point": "op_sortd_uniq_dropwhileneg", "primitives": ["sortd", "uniq", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_sortd_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_uniq_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_uniq_dropwhileneg([]) == []\nassert op_sortd_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_uniq_dropwhileneg([5, 5, 5]) == [5]\nassert op_sortd_uniq_dropwhileneg([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_uniq_dropwhileneg([10]) == [10]\nassert op_sortd_uniq_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_uniq_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_beforezero_takewhilepos_div3", "entry_point": "op_beforezero_takewhilepos_div3", "primitives": ["beforezero", "takewhilepos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then keep multiples of three.", "solution": "def op_beforezero_takewhilepos_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_takewhilepos_div3([1, 2, 3, 4]) == [3]\nassert op_beforezero_takewhilepos_div3([]) == []\nassert op_beforezero_takewhilepos_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_div3([5, 5, 5]) == []\nassert op_beforezero_takewhilepos_div3([3, 1, 2]) == [3]\nassert op_beforezero_takewhilepos_div3([10]) == []\nassert op_beforezero_takewhilepos_div3([2, 4, 6]) == [6]\nassert op_beforezero_takewhilepos_div3([-7, 12, -7]) == []"}
{"id": "op_neg_negate_padto3", "entry_point": "op_neg_negate_padto3", "primitives": ["neg", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then pad with zeros to at least three elements.", "solution": "def op_neg_negate_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_negate_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_negate_padto3([]) == [0, 0, 0]\nassert op_neg_negate_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_neg_negate_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_negate_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_negate_padto3([10]) == [0, 0, 0]\nassert op_neg_negate_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_negate_padto3([-7, 12, -7]) == [7, 7, 0]"}
{"id": "op_div3_padto3_min", "entry_point": "op_div3_padto3_min", "primitives": ["div3", "padto3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_div3_padto3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_div3_padto3_min([1, 2, 3, 4]) == 0\nassert op_div3_padto3_min([]) == 0\nassert op_div3_padto3_min([-2, -1, 0, 1, 2]) == 0\nassert op_div3_padto3_min([5, 5, 5]) == 0\nassert op_div3_padto3_min([3, 1, 2]) == 0\nassert op_div3_padto3_min([10]) == 0\nassert op_div3_padto3_min([2, 4, 6]) == 0\nassert op_div3_padto3_min([-7, 12, -7]) == 0"}
{"id": "op_dec_dropfirst_counteven", "entry_point": "op_dec_dropfirst_counteven", "primitives": ["dec", "dropfirst", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first element, then return how many values are even.", "solution": "def op_dec_dropfirst_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_dropfirst_counteven([1, 2, 3, 4]) == 1\nassert op_dec_dropfirst_counteven([]) == 0\nassert op_dec_dropfirst_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dec_dropfirst_counteven([5, 5, 5]) == 2\nassert op_dec_dropfirst_counteven([3, 1, 2]) == 1\nassert op_dec_dropfirst_counteven([10]) == 0\nassert op_dec_dropfirst_counteven([2, 4, 6]) == 0\nassert op_dec_dropfirst_counteven([-7, 12, -7]) == 1"}
{"id": "op_takewhilepos_square_dropfirst", "entry_point": "op_takewhilepos_square_dropfirst", "primitives": ["takewhilepos", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then drop the first element.", "solution": "def op_takewhilepos_square_dropfirst(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_takewhilepos_square_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_takewhilepos_square_dropfirst([]) == []\nassert op_takewhilepos_square_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_takewhilepos_square_dropfirst([3, 1, 2]) == [1, 4]\nassert op_takewhilepos_square_dropfirst([10]) == []\nassert op_takewhilepos_square_dropfirst([2, 4, 6]) == [16, 36]\nassert op_takewhilepos_square_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_div3_clamp10", "entry_point": "op_add10_div3_clamp10", "primitives": ["add10", "div3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then cap each value at 10.", "solution": "def op_add10_div3_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_div3_clamp10([1, 2, 3, 4]) == [10]\nassert op_add10_div3_clamp10([]) == []\nassert op_add10_div3_clamp10([-2, -1, 0, 1, 2]) == [9, 10]\nassert op_add10_div3_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_add10_div3_clamp10([3, 1, 2]) == [10]\nassert op_add10_div3_clamp10([10]) == []\nassert op_add10_div3_clamp10([2, 4, 6]) == [10]\nassert op_add10_div3_clamp10([-7, 12, -7]) == [3, 3]"}
{"id": "op_ages_uniq_beforezero", "entry_point": "op_ages_uniq_beforezero", "primitives": ["ages", "uniq", "beforezero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then keep everything before the first zero.", "solution": "def op_ages_uniq_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_uniq_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_uniq_beforezero([]) == []\nassert op_ages_uniq_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_uniq_beforezero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropfirst_trimends_sortabs", "entry_point": "op_dropfirst_trimends_sortabs", "primitives": ["dropfirst", "trimends", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then sort by absolute value.", "solution": "def op_dropfirst_trimends_sortabs(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropfirst_trimends_sortabs([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_sortabs([]) == []\nassert op_dropfirst_trimends_sortabs([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dropfirst_trimends_sortabs([5, 5, 5]) == []\nassert op_dropfirst_trimends_sortabs([3, 1, 2]) == []\nassert op_dropfirst_trimends_sortabs([10]) == []\nassert op_dropfirst_trimends_sortabs([2, 4, 6]) == []\nassert op_dropfirst_trimends_sortabs([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_negate_uniq", "entry_point": "op_oremptyzero_negate_uniq", "primitives": ["oremptyzero", "negate", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_negate_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_negate_uniq([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_oremptyzero_negate_uniq([]) == [0]\nassert op_oremptyzero_negate_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_oremptyzero_negate_uniq([5, 5, 5]) == [-5]\nassert op_oremptyzero_negate_uniq([3, 1, 2]) == [-3, -1, -2]\nassert op_oremptyzero_negate_uniq([10]) == [-10]\nassert op_oremptyzero_negate_uniq([2, 4, 6]) == [-2, -4, -6]\nassert op_oremptyzero_negate_uniq([-7, 12, -7]) == [7, -12]"}
{"id": "op_div3_square_pos", "entry_point": "op_div3_square_pos", "primitives": ["div3", "square", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then keep the positive numbers.", "solution": "def op_div3_square_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_div3_square_pos([1, 2, 3, 4]) == [9]\nassert op_div3_square_pos([]) == []\nassert op_div3_square_pos([-2, -1, 0, 1, 2]) == []\nassert op_div3_square_pos([5, 5, 5]) == []\nassert op_div3_square_pos([3, 1, 2]) == [9]\nassert op_div3_square_pos([10]) == []\nassert op_div3_square_pos([2, 4, 6]) == [36]\nassert op_div3_square_pos([-7, 12, -7]) == [144]"}
{"id": "op_absval_add10_padto3", "entry_point": "op_absval_add10_padto3", "primitives": ["absval", "add10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_absval_add10_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_add10_padto3([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_absval_add10_padto3([]) == [0, 0, 0]\nassert op_absval_add10_padto3([-2, -1, 0, 1, 2]) == [12, 11, 10, 11, 12]\nassert op_absval_add10_padto3([5, 5, 5]) == [15, 15, 15]\nassert op_absval_add10_padto3([3, 1, 2]) == [13, 11, 12]\nassert op_absval_add10_padto3([10]) == [20, 0, 0]\nassert op_absval_add10_padto3([2, 4, 6]) == [12, 14, 16]\nassert op_absval_add10_padto3([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_sortabs_dec_alldistinct", "entry_point": "op_sortabs_dec_alldistinct", "primitives": ["sortabs", "dec", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then return whether all values are distinct.", "solution": "def op_sortabs_dec_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_dec_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_dec_alldistinct([]) == True\nassert op_sortabs_dec_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_dec_alldistinct([5, 5, 5]) == False\nassert op_sortabs_dec_alldistinct([3, 1, 2]) == True\nassert op_sortabs_dec_alldistinct([10]) == True\nassert op_sortabs_dec_alldistinct([2, 4, 6]) == True\nassert op_sortabs_dec_alldistinct([-7, 12, -7]) == False"}
{"id": "op_uniq_dec_add10", "entry_point": "op_uniq_dec_add10", "primitives": ["uniq", "dec", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then add ten to each.", "solution": "def op_uniq_dec_add10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_uniq_dec_add10([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_uniq_dec_add10([]) == []\nassert op_uniq_dec_add10([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_uniq_dec_add10([5, 5, 5]) == [14]\nassert op_uniq_dec_add10([3, 1, 2]) == [12, 10, 11]\nassert op_uniq_dec_add10([10]) == [19]\nassert op_uniq_dec_add10([2, 4, 6]) == [11, 13, 15]\nassert op_uniq_dec_add10([-7, 12, -7]) == [2, 21]"}
{"id": "op_double_dropzeros_trimends", "entry_point": "op_double_dropzeros_trimends", "primitives": ["double", "dropzeros", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then drop the first and last elements.", "solution": "def op_double_dropzeros_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_dropzeros_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_double_dropzeros_trimends([]) == []\nassert op_double_dropzeros_trimends([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_double_dropzeros_trimends([5, 5, 5]) == [10]\nassert op_double_dropzeros_trimends([3, 1, 2]) == [2]\nassert op_double_dropzeros_trimends([10]) == []\nassert op_double_dropzeros_trimends([2, 4, 6]) == [8]\nassert op_double_dropzeros_trimends([-7, 12, -7]) == [24]"}
{"id": "op_first3_absval_len", "entry_point": "op_first3_absval_len", "primitives": ["first3", "absval", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then return how many remain.", "solution": "def op_first3_absval_len(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return len(r)", "tests": "assert op_first3_absval_len([1, 2, 3, 4]) == 3\nassert op_first3_absval_len([]) == 0\nassert op_first3_absval_len([-2, -1, 0, 1, 2]) == 3\nassert op_first3_absval_len([5, 5, 5]) == 3\nassert op_first3_absval_len([3, 1, 2]) == 3\nassert op_first3_absval_len([10]) == 1\nassert op_first3_absval_len([2, 4, 6]) == 3\nassert op_first3_absval_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_padto3_add10", "entry_point": "op_sortd_padto3_add10", "primitives": ["sortd", "padto3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then add ten to each.", "solution": "def op_sortd_padto3_add10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortd_padto3_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sortd_padto3_add10([]) == [10, 10, 10]\nassert op_sortd_padto3_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sortd_padto3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sortd_padto3_add10([3, 1, 2]) == [13, 12, 11]\nassert op_sortd_padto3_add10([10]) == [20, 10, 10]\nassert op_sortd_padto3_add10([2, 4, 6]) == [16, 14, 12]\nassert op_sortd_padto3_add10([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_absval_sortd_dec", "entry_point": "op_absval_sortd_dec", "primitives": ["absval", "sortd", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then subtract one from each.", "solution": "def op_absval_sortd_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_sortd_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_absval_sortd_dec([]) == []\nassert op_absval_sortd_dec([-2, -1, 0, 1, 2]) == [1, 1, 0, 0, -1]\nassert op_absval_sortd_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_sortd_dec([3, 1, 2]) == [2, 1, 0]\nassert op_absval_sortd_dec([10]) == [9]\nassert op_absval_sortd_dec([2, 4, 6]) == [5, 3, 1]\nassert op_absval_sortd_dec([-7, 12, -7]) == [11, 6, 6]"}
{"id": "op_double_pos_sortd", "entry_point": "op_double_pos_sortd", "primitives": ["double", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then sort descending.", "solution": "def op_double_pos_sortd(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_double_pos_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_pos_sortd([]) == []\nassert op_double_pos_sortd([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_double_pos_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_double_pos_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_double_pos_sortd([10]) == [20]\nassert op_double_pos_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_double_pos_sortd([-7, 12, -7]) == [24]"}
{"id": "op_evens_clamp10_len", "entry_point": "op_evens_clamp10_len", "primitives": ["evens", "clamp10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10, then return how many remain.", "solution": "def op_evens_clamp10_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_evens_clamp10_len([1, 2, 3, 4]) == 2\nassert op_evens_clamp10_len([]) == 0\nassert op_evens_clamp10_len([-2, -1, 0, 1, 2]) == 3\nassert op_evens_clamp10_len([5, 5, 5]) == 0\nassert op_evens_clamp10_len([3, 1, 2]) == 1\nassert op_evens_clamp10_len([10]) == 1\nassert op_evens_clamp10_len([2, 4, 6]) == 3\nassert op_evens_clamp10_len([-7, 12, -7]) == 1"}
{"id": "op_evens_dropfirst_square", "entry_point": "op_evens_dropfirst_square", "primitives": ["evens", "dropfirst", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then square each.", "solution": "def op_evens_dropfirst_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_evens_dropfirst_square([1, 2, 3, 4]) == [16]\nassert op_evens_dropfirst_square([]) == []\nassert op_evens_dropfirst_square([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_evens_dropfirst_square([5, 5, 5]) == []\nassert op_evens_dropfirst_square([3, 1, 2]) == []\nassert op_evens_dropfirst_square([10]) == []\nassert op_evens_dropfirst_square([2, 4, 6]) == [16, 36]\nassert op_evens_dropfirst_square([-7, 12, -7]) == []"}
{"id": "op_sortalpha_prefixup_firstchar", "entry_point": "op_sortalpha_prefixup_firstchar", "primitives": ["sortalpha", "prefixup", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then prefix each with a hash, then keep the first character of each (dropping empties).", "solution": "def op_sortalpha_prefixup_firstchar(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortalpha_prefixup_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_sortalpha_prefixup_firstchar([]) == []\nassert op_sortalpha_prefixup_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_sortalpha_prefixup_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_sortalpha_prefixup_firstchar(['x']) == ['#']\nassert op_sortalpha_prefixup_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_rev_odds_issorted", "entry_point": "op_rev_odds_issorted", "primitives": ["rev", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_rev_odds_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_rev_odds_issorted([1, 2, 3, 4]) == False\nassert op_rev_odds_issorted([]) == True\nassert op_rev_odds_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_odds_issorted([5, 5, 5]) == True\nassert op_rev_odds_issorted([3, 1, 2]) == True\nassert op_rev_odds_issorted([10]) == True\nassert op_rev_odds_issorted([2, 4, 6]) == True\nassert op_rev_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_dropzeros_padto3_sorta", "entry_point": "op_dropzeros_padto3_sorta", "primitives": ["dropzeros", "padto3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then sort ascending.", "solution": "def op_dropzeros_padto3_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_padto3_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_padto3_sorta([]) == [0, 0, 0]\nassert op_dropzeros_padto3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_padto3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_padto3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_padto3_sorta([10]) == [0, 0, 10]\nassert op_dropzeros_padto3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_padto3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_absval_last3", "entry_point": "op_beforezero_absval_last3", "primitives": ["beforezero", "absval", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then keep only the last three.", "solution": "def op_beforezero_absval_last3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_beforezero_absval_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_absval_last3([]) == []\nassert op_beforezero_absval_last3([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_absval_last3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_absval_last3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_absval_last3([10]) == [10]\nassert op_beforezero_absval_last3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_absval_last3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_pos_absval_sortd", "entry_point": "op_pos_absval_sortd", "primitives": ["pos", "absval", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then sort descending.", "solution": "def op_pos_absval_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_pos_absval_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_absval_sortd([]) == []\nassert op_pos_absval_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_absval_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_pos_absval_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_pos_absval_sortd([10]) == [10]\nassert op_pos_absval_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_pos_absval_sortd([-7, 12, -7]) == [12]"}
{"id": "op_ages_negate_dropzeros", "entry_point": "op_ages_negate_dropzeros", "primitives": ["ages", "negate", "dropzeros"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then drop the zeros.", "solution": "def op_ages_negate_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_negate_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_negate_dropzeros([]) == []\nassert op_ages_negate_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_negate_dropzeros([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_double_pos_issorted", "entry_point": "op_double_pos_issorted", "primitives": ["double", "pos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_double_pos_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_double_pos_issorted([1, 2, 3, 4]) == True\nassert op_double_pos_issorted([]) == True\nassert op_double_pos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_pos_issorted([5, 5, 5]) == True\nassert op_double_pos_issorted([3, 1, 2]) == False\nassert op_double_pos_issorted([10]) == True\nassert op_double_pos_issorted([2, 4, 6]) == True\nassert op_double_pos_issorted([-7, 12, -7]) == True"}
{"id": "op_evens_absval_neg", "entry_point": "op_evens_absval_neg", "primitives": ["evens", "absval", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take the absolute value of each, then keep the negative numbers.", "solution": "def op_evens_absval_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_absval_neg([1, 2, 3, 4]) == []\nassert op_evens_absval_neg([]) == []\nassert op_evens_absval_neg([-2, -1, 0, 1, 2]) == []\nassert op_evens_absval_neg([5, 5, 5]) == []\nassert op_evens_absval_neg([3, 1, 2]) == []\nassert op_evens_absval_neg([10]) == []\nassert op_evens_absval_neg([2, 4, 6]) == []\nassert op_evens_absval_neg([-7, 12, -7]) == []"}
{"id": "op_negate_dropfirst_haszero", "entry_point": "op_negate_dropfirst_haszero", "primitives": ["negate", "dropfirst", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then return whether the list contains a zero.", "solution": "def op_negate_dropfirst_haszero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    return 0 in r", "tests": "assert op_negate_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_negate_dropfirst_haszero([]) == False\nassert op_negate_dropfirst_haszero([-2, -1, 0, 1, 2]) == True\nassert op_negate_dropfirst_haszero([5, 5, 5]) == False\nassert op_negate_dropfirst_haszero([3, 1, 2]) == False\nassert op_negate_dropfirst_haszero([10]) == False\nassert op_negate_dropfirst_haszero([2, 4, 6]) == False\nassert op_negate_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_add10_rev_firsteven", "entry_point": "op_add10_rev_firsteven", "primitives": ["add10", "rev", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then return the first even value (0 if none).", "solution": "def op_add10_rev_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_rev_firsteven([1, 2, 3, 4]) == 14\nassert op_add10_rev_firsteven([]) == 0\nassert op_add10_rev_firsteven([-2, -1, 0, 1, 2]) == 12\nassert op_add10_rev_firsteven([5, 5, 5]) == 0\nassert op_add10_rev_firsteven([3, 1, 2]) == 12\nassert op_add10_rev_firsteven([10]) == 20\nassert op_add10_rev_firsteven([2, 4, 6]) == 16\nassert op_add10_rev_firsteven([-7, 12, -7]) == 22"}
{"id": "op_uniq_trimends_len", "entry_point": "op_uniq_trimends_len", "primitives": ["uniq", "trimends", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then return how many remain.", "solution": "def op_uniq_trimends_len(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_uniq_trimends_len([1, 2, 3, 4]) == 2\nassert op_uniq_trimends_len([]) == 0\nassert op_uniq_trimends_len([-2, -1, 0, 1, 2]) == 3\nassert op_uniq_trimends_len([5, 5, 5]) == 0\nassert op_uniq_trimends_len([3, 1, 2]) == 1\nassert op_uniq_trimends_len([10]) == 0\nassert op_uniq_trimends_len([2, 4, 6]) == 1\nassert op_uniq_trimends_len([-7, 12, -7]) == 0"}
{"id": "op_neg_dec_dropwhileneg", "entry_point": "op_neg_dec_dropwhileneg", "primitives": ["neg", "dec", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then drop the leading negative values.", "solution": "def op_neg_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_dec_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_dec_dropwhileneg([]) == []\nassert op_neg_dec_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_dec_dropwhileneg([5, 5, 5]) == []\nassert op_neg_dec_dropwhileneg([3, 1, 2]) == []\nassert op_neg_dec_dropwhileneg([10]) == []\nassert op_neg_dec_dropwhileneg([2, 4, 6]) == []\nassert op_neg_dec_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_last3_rev_trimends", "entry_point": "op_last3_rev_trimends", "primitives": ["last3", "rev", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then drop the first and last elements.", "solution": "def op_last3_rev_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_rev_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_rev_trimends([]) == []\nassert op_last3_rev_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_rev_trimends([5, 5, 5]) == [5]\nassert op_last3_rev_trimends([3, 1, 2]) == [1]\nassert op_last3_rev_trimends([10]) == []\nassert op_last3_rev_trimends([2, 4, 6]) == [4]\nassert op_last3_rev_trimends([-7, 12, -7]) == [12]"}
{"id": "op_dec_pos_alldistinct", "entry_point": "op_dec_pos_alldistinct", "primitives": ["dec", "pos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then return whether all values are distinct.", "solution": "def op_dec_pos_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_dec_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_pos_alldistinct([]) == True\nassert op_dec_pos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_pos_alldistinct([5, 5, 5]) == False\nassert op_dec_pos_alldistinct([3, 1, 2]) == True\nassert op_dec_pos_alldistinct([10]) == True\nassert op_dec_pos_alldistinct([2, 4, 6]) == True\nassert op_dec_pos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_uniq_add10_first3", "entry_point": "op_uniq_add10_first3", "primitives": ["uniq", "add10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then keep only the first three.", "solution": "def op_uniq_add10_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_uniq_add10_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_uniq_add10_first3([]) == []\nassert op_uniq_add10_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_uniq_add10_first3([5, 5, 5]) == [15]\nassert op_uniq_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10_first3([10]) == [20]\nassert op_uniq_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_first3([-7, 12, -7]) == [3, 22]"}
{"id": "op_div3_oremptyzero_padto3", "entry_point": "op_div3_oremptyzero_padto3", "primitives": ["div3", "oremptyzero", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_div3_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_oremptyzero_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_div3_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_div3_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_oremptyzero_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_oremptyzero_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_div3_oremptyzero_padto3([10]) == [0, 0, 0]\nassert op_div3_oremptyzero_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_div3_oremptyzero_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_pos_oremptyzero_last3", "entry_point": "op_pos_oremptyzero_last3", "primitives": ["pos", "oremptyzero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero, then keep only the last three.", "solution": "def op_pos_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_pos_oremptyzero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_oremptyzero_last3([]) == [0]\nassert op_pos_oremptyzero_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_oremptyzero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_oremptyzero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_oremptyzero_last3([10]) == [10]\nassert op_pos_oremptyzero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_oremptyzero_last3([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dropfirst_absval", "entry_point": "op_oremptyzero_dropfirst_absval", "primitives": ["oremptyzero", "dropfirst", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then take the absolute value of each.", "solution": "def op_oremptyzero_dropfirst_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_dropfirst_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_dropfirst_absval([]) == []\nassert op_oremptyzero_dropfirst_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_oremptyzero_dropfirst_absval([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_dropfirst_absval([3, 1, 2]) == [1, 2]\nassert op_oremptyzero_dropfirst_absval([10]) == []\nassert op_oremptyzero_dropfirst_absval([2, 4, 6]) == [4, 6]\nassert op_oremptyzero_dropfirst_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_square_gt5_first3", "entry_point": "op_square_gt5_first3", "primitives": ["square", "gt5", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then keep only the first three.", "solution": "def op_square_gt5_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_square_gt5_first3([1, 2, 3, 4]) == [9, 16]\nassert op_square_gt5_first3([]) == []\nassert op_square_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_square_gt5_first3([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5_first3([3, 1, 2]) == [9]\nassert op_square_gt5_first3([10]) == [100]\nassert op_square_gt5_first3([2, 4, 6]) == [16, 36]\nassert op_square_gt5_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_div3_gt5_dropwhileneg", "entry_point": "op_div3_gt5_dropwhileneg", "primitives": ["div3", "gt5", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then drop the leading negative values.", "solution": "def op_div3_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_div3_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_div3_gt5_dropwhileneg([]) == []\nassert op_div3_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_div3_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_div3_gt5_dropwhileneg([10]) == []\nassert op_div3_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_div3_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_odds_len", "entry_point": "op_beforezero_odds_len", "primitives": ["beforezero", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the odd numbers, then return how many remain.", "solution": "def op_beforezero_odds_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_beforezero_odds_len([1, 2, 3, 4]) == 2\nassert op_beforezero_odds_len([]) == 0\nassert op_beforezero_odds_len([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_odds_len([5, 5, 5]) == 3\nassert op_beforezero_odds_len([3, 1, 2]) == 2\nassert op_beforezero_odds_len([10]) == 0\nassert op_beforezero_odds_len([2, 4, 6]) == 0\nassert op_beforezero_odds_len([-7, 12, -7]) == 2"}
{"id": "op_uniq_beforezero_pos", "entry_point": "op_uniq_beforezero_pos", "primitives": ["uniq", "beforezero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_uniq_beforezero_pos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_uniq_beforezero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_beforezero_pos([]) == []\nassert op_uniq_beforezero_pos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_beforezero_pos([5, 5, 5]) == [5]\nassert op_uniq_beforezero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_beforezero_pos([10]) == [10]\nassert op_uniq_beforezero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_sortd_dropfirst_oremptyzero", "entry_point": "op_sortd_dropfirst_oremptyzero", "primitives": ["sortd", "dropfirst", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then if empty, use a single zero.", "solution": "def op_sortd_dropfirst_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_dropfirst_oremptyzero([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dropfirst_oremptyzero([]) == [0]\nassert op_sortd_dropfirst_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_sortd_dropfirst_oremptyzero([5, 5, 5]) == [5, 5]\nassert op_sortd_dropfirst_oremptyzero([3, 1, 2]) == [2, 1]\nassert op_sortd_dropfirst_oremptyzero([10]) == [0]\nassert op_sortd_dropfirst_oremptyzero([2, 4, 6]) == [4, 2]\nassert op_sortd_dropfirst_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_gt5_dropwhileneg_first3", "entry_point": "op_gt5_dropwhileneg_first3", "primitives": ["gt5", "dropwhileneg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the leading negative values, then keep only the first three.", "solution": "def op_gt5_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_dropwhileneg_first3([1, 2, 3, 4]) == []\nassert op_gt5_dropwhileneg_first3([]) == []\nassert op_gt5_dropwhileneg_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropwhileneg_first3([5, 5, 5]) == []\nassert op_gt5_dropwhileneg_first3([3, 1, 2]) == []\nassert op_gt5_dropwhileneg_first3([10]) == [10]\nassert op_gt5_dropwhileneg_first3([2, 4, 6]) == [6]\nassert op_gt5_dropwhileneg_first3([-7, 12, -7]) == [12]"}
{"id": "op_neg_pos_sortabs", "entry_point": "op_neg_pos_sortabs", "primitives": ["neg", "pos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers, then sort by absolute value.", "solution": "def op_neg_pos_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_pos_sortabs([1, 2, 3, 4]) == []\nassert op_neg_pos_sortabs([]) == []\nassert op_neg_pos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_neg_pos_sortabs([5, 5, 5]) == []\nassert op_neg_pos_sortabs([3, 1, 2]) == []\nassert op_neg_pos_sortabs([10]) == []\nassert op_neg_pos_sortabs([2, 4, 6]) == []\nassert op_neg_pos_sortabs([-7, 12, -7]) == []"}
{"id": "op_padto3_square_counteven", "entry_point": "op_padto3_square_counteven", "primitives": ["padto3", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then return how many values are even.", "solution": "def op_padto3_square_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_square_counteven([1, 2, 3, 4]) == 2\nassert op_padto3_square_counteven([]) == 3\nassert op_padto3_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_padto3_square_counteven([5, 5, 5]) == 0\nassert op_padto3_square_counteven([3, 1, 2]) == 1\nassert op_padto3_square_counteven([10]) == 3\nassert op_padto3_square_counteven([2, 4, 6]) == 3\nassert op_padto3_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_uniq_add10_oremptyzero", "entry_point": "op_uniq_add10_oremptyzero", "primitives": ["uniq", "add10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then if empty, use a single zero.", "solution": "def op_uniq_add10_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_add10_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10_oremptyzero([]) == [0]\nassert op_uniq_add10_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10_oremptyzero([5, 5, 5]) == [15]\nassert op_uniq_add10_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10_oremptyzero([10]) == [20]\nassert op_uniq_add10_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_oremptyzero([-7, 12, -7]) == [3, 22]"}
{"id": "op_first3_double_add10", "entry_point": "op_first3_double_add10", "primitives": ["first3", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then add ten to each.", "solution": "def op_first3_double_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_double_add10([1, 2, 3, 4]) == [12, 14, 16]\nassert op_first3_double_add10([]) == []\nassert op_first3_double_add10([-2, -1, 0, 1, 2]) == [6, 8, 10]\nassert op_first3_double_add10([5, 5, 5]) == [20, 20, 20]\nassert op_first3_double_add10([3, 1, 2]) == [16, 12, 14]\nassert op_first3_double_add10([10]) == [30]\nassert op_first3_double_add10([2, 4, 6]) == [14, 18, 22]\nassert op_first3_double_add10([-7, 12, -7]) == [-4, 34, -4]"}
{"id": "op_takewhilepos_first3_rev", "entry_point": "op_takewhilepos_first3_rev", "primitives": ["takewhilepos", "first3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then reverse the order.", "solution": "def op_takewhilepos_first3_rev(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = list(reversed(r))\n    return r", "tests": "assert op_takewhilepos_first3_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_takewhilepos_first3_rev([]) == []\nassert op_takewhilepos_first3_rev([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_takewhilepos_first3_rev([10]) == [10]\nassert op_takewhilepos_first3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_first3_rev([-7, 12, -7]) == []"}
{"id": "op_first3_clamp10_double", "entry_point": "op_first3_clamp10_double", "primitives": ["first3", "clamp10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then double each.", "solution": "def op_first3_clamp10_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_clamp10_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_clamp10_double([]) == []\nassert op_first3_clamp10_double([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_first3_clamp10_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_clamp10_double([3, 1, 2]) == [6, 2, 4]\nassert op_first3_clamp10_double([10]) == [20]\nassert op_first3_clamp10_double([2, 4, 6]) == [4, 8, 12]\nassert op_first3_clamp10_double([-7, 12, -7]) == [-14, 20, -14]"}
{"id": "op_dropfirst_rev_oremptyzero", "entry_point": "op_dropfirst_rev_oremptyzero", "primitives": ["dropfirst", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then if empty, use a single zero.", "solution": "def op_dropfirst_rev_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_rev_oremptyzero([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev_oremptyzero([]) == [0]\nassert op_dropfirst_rev_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_rev_oremptyzero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_rev_oremptyzero([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev_oremptyzero([10]) == [0]\nassert op_dropfirst_rev_oremptyzero([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_oremptyzero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_firstchar_prefixup_strip", "entry_point": "op_firstchar_prefixup_strip", "primitives": ["firstchar", "prefixup", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then prefix each with a hash, then trim whitespace from each.", "solution": "def op_firstchar_prefixup_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_prefixup_strip(['Hello', 'world']) == ['#H', '#w']\nassert op_firstchar_prefixup_strip([]) == []\nassert op_firstchar_prefixup_strip(['  a ', '', 'BC', 'bc']) == ['#', '#B', '#b']\nassert op_firstchar_prefixup_strip(['one', 'one', 'Two']) == ['#o', '#o', '#T']\nassert op_firstchar_prefixup_strip(['x']) == ['#x']\nassert op_firstchar_prefixup_strip(['abc', 'de', '']) == ['#a', '#d']"}
{"id": "op_last3_negate_uniq", "entry_point": "op_last3_negate_uniq", "primitives": ["last3", "negate", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_last3_negate_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_negate_uniq([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_negate_uniq([]) == []\nassert op_last3_negate_uniq([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_negate_uniq([5, 5, 5]) == [-5]\nassert op_last3_negate_uniq([3, 1, 2]) == [-3, -1, -2]\nassert op_last3_negate_uniq([10]) == [-10]\nassert op_last3_negate_uniq([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_negate_uniq([-7, 12, -7]) == [7, -12]"}
{"id": "op_dropshort_sortlen_anyempty", "entry_point": "op_dropshort_sortlen_anyempty", "primitives": ["dropshort", "sortlen", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then sort by length, shortest first, then return whether any string is empty.", "solution": "def op_dropshort_sortlen_anyempty(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r, key=len)\n    return any(s == '' for s in r)", "tests": "assert op_dropshort_sortlen_anyempty(['Hello', 'world']) == False\nassert op_dropshort_sortlen_anyempty([]) == False\nassert op_dropshort_sortlen_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_dropshort_sortlen_anyempty(['one', 'one', 'Two']) == False\nassert op_dropshort_sortlen_anyempty(['x']) == False\nassert op_dropshort_sortlen_anyempty(['abc', 'de', '']) == False"}
{"id": "op_first3_add10_prod", "entry_point": "op_first3_add10_prod", "primitives": ["first3", "add10", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then return their product.", "solution": "def op_first3_add10_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_first3_add10_prod([1, 2, 3, 4]) == 1716\nassert op_first3_add10_prod([]) == 1\nassert op_first3_add10_prod([-2, -1, 0, 1, 2]) == 720\nassert op_first3_add10_prod([5, 5, 5]) == 3375\nassert op_first3_add10_prod([3, 1, 2]) == 1716\nassert op_first3_add10_prod([10]) == 20\nassert op_first3_add10_prod([2, 4, 6]) == 2688\nassert op_first3_add10_prod([-7, 12, -7]) == 198"}
{"id": "op_uniq_dropzeros_dropwhileneg", "entry_point": "op_uniq_dropzeros_dropwhileneg", "primitives": ["uniq", "dropzeros", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then drop the leading negative values.", "solution": "def op_uniq_dropzeros_dropwhileneg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_uniq_dropzeros_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_dropzeros_dropwhileneg([]) == []\nassert op_uniq_dropzeros_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_dropzeros_dropwhileneg([5, 5, 5]) == [5]\nassert op_uniq_dropzeros_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_dropzeros_dropwhileneg([10]) == [10]\nassert op_uniq_dropzeros_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_dropzeros_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_prefixup_nonempty_firstchar", "entry_point": "op_prefixup_nonempty_firstchar", "primitives": ["prefixup", "nonempty", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop empty strings, then keep the first character of each (dropping empties).", "solution": "def op_prefixup_nonempty_firstchar(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_prefixup_nonempty_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_prefixup_nonempty_firstchar([]) == []\nassert op_prefixup_nonempty_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_prefixup_nonempty_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_prefixup_nonempty_firstchar(['x']) == ['#']\nassert op_prefixup_nonempty_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_dec_gt5_alldistinct", "entry_point": "op_dec_gt5_alldistinct", "primitives": ["dec", "gt5", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then return whether all values are distinct.", "solution": "def op_dec_gt5_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return len(r) == len(set(r))", "tests": "assert op_dec_gt5_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_gt5_alldistinct([]) == True\nassert op_dec_gt5_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_gt5_alldistinct([5, 5, 5]) == True\nassert op_dec_gt5_alldistinct([3, 1, 2]) == True\nassert op_dec_gt5_alldistinct([10]) == True\nassert op_dec_gt5_alldistinct([2, 4, 6]) == True\nassert op_dec_gt5_alldistinct([-7, 12, -7]) == True"}
{"id": "op_padto3_pos_dropfirst", "entry_point": "op_padto3_pos_dropfirst", "primitives": ["padto3", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then drop the first element.", "solution": "def op_padto3_pos_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_pos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_pos_dropfirst([]) == []\nassert op_padto3_pos_dropfirst([-2, -1, 0, 1, 2]) == [2]\nassert op_padto3_pos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_pos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_padto3_pos_dropfirst([10]) == []\nassert op_padto3_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_pos_padto3_first3", "entry_point": "op_pos_padto3_first3", "primitives": ["pos", "padto3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then keep only the first three.", "solution": "def op_pos_padto3_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return r", "tests": "assert op_pos_padto3_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_padto3_first3([]) == [0, 0, 0]\nassert op_pos_padto3_first3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_padto3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_padto3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_padto3_first3([10]) == [10, 0, 0]\nassert op_pos_padto3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_padto3_first3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_evens_dropzeros_add10", "entry_point": "op_evens_dropzeros_add10", "primitives": ["evens", "dropzeros", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then add ten to each.", "solution": "def op_evens_dropzeros_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_evens_dropzeros_add10([1, 2, 3, 4]) == [12, 14]\nassert op_evens_dropzeros_add10([]) == []\nassert op_evens_dropzeros_add10([-2, -1, 0, 1, 2]) == [8, 12]\nassert op_evens_dropzeros_add10([5, 5, 5]) == []\nassert op_evens_dropzeros_add10([3, 1, 2]) == [12]\nassert op_evens_dropzeros_add10([10]) == [20]\nassert op_evens_dropzeros_add10([2, 4, 6]) == [12, 14, 16]\nassert op_evens_dropzeros_add10([-7, 12, -7]) == [22]"}
{"id": "op_pos_negate_min", "entry_point": "op_pos_negate_min", "primitives": ["pos", "negate", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then return the minimum (0 if empty).", "solution": "def op_pos_negate_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return min(r) if r else 0", "tests": "assert op_pos_negate_min([1, 2, 3, 4]) == -4\nassert op_pos_negate_min([]) == 0\nassert op_pos_negate_min([-2, -1, 0, 1, 2]) == -2\nassert op_pos_negate_min([5, 5, 5]) == -5\nassert op_pos_negate_min([3, 1, 2]) == -3\nassert op_pos_negate_min([10]) == -10\nassert op_pos_negate_min([2, 4, 6]) == -6\nassert op_pos_negate_min([-7, 12, -7]) == -12"}
{"id": "op_sortd_uniq_firsteven", "entry_point": "op_sortd_uniq_firsteven", "primitives": ["sortd", "uniq", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_sortd_uniq_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortd_uniq_firsteven([1, 2, 3, 4]) == 4\nassert op_sortd_uniq_firsteven([]) == 0\nassert op_sortd_uniq_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_uniq_firsteven([5, 5, 5]) == 0\nassert op_sortd_uniq_firsteven([3, 1, 2]) == 2\nassert op_sortd_uniq_firsteven([10]) == 10\nassert op_sortd_uniq_firsteven([2, 4, 6]) == 6\nassert op_sortd_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_absval_sorta_gt5", "entry_point": "op_absval_sorta_gt5", "primitives": ["absval", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then keep values greater than five.", "solution": "def op_absval_sorta_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_sorta_gt5([1, 2, 3, 4]) == []\nassert op_absval_sorta_gt5([]) == []\nassert op_absval_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_sorta_gt5([5, 5, 5]) == []\nassert op_absval_sorta_gt5([3, 1, 2]) == []\nassert op_absval_sorta_gt5([10]) == [10]\nassert op_absval_sorta_gt5([2, 4, 6]) == [6]\nassert op_absval_sorta_gt5([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_sortabs_neg_rev", "entry_point": "op_sortabs_neg_rev", "primitives": ["sortabs", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then reverse the order.", "solution": "def op_sortabs_neg_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_neg_rev([1, 2, 3, 4]) == []\nassert op_sortabs_neg_rev([]) == []\nassert op_sortabs_neg_rev([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sortabs_neg_rev([5, 5, 5]) == []\nassert op_sortabs_neg_rev([3, 1, 2]) == []\nassert op_sortabs_neg_rev([10]) == []\nassert op_sortabs_neg_rev([2, 4, 6]) == []\nassert op_sortabs_neg_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_add10_takewhilepos_odds", "entry_point": "op_add10_takewhilepos_odds", "primitives": ["add10", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then keep the odd numbers.", "solution": "def op_add10_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_add10_takewhilepos_odds([1, 2, 3, 4]) == [11, 13]\nassert op_add10_takewhilepos_odds([]) == []\nassert op_add10_takewhilepos_odds([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_add10_takewhilepos_odds([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos_odds([3, 1, 2]) == [13, 11]\nassert op_add10_takewhilepos_odds([10]) == []\nassert op_add10_takewhilepos_odds([2, 4, 6]) == []\nassert op_add10_takewhilepos_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_takewhilepos_square_add10", "entry_point": "op_takewhilepos_square_add10", "primitives": ["takewhilepos", "square", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then add ten to each.", "solution": "def op_takewhilepos_square_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_square_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_takewhilepos_square_add10([]) == []\nassert op_takewhilepos_square_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_add10([5, 5, 5]) == [35, 35, 35]\nassert op_takewhilepos_square_add10([3, 1, 2]) == [19, 11, 14]\nassert op_takewhilepos_square_add10([10]) == [110]\nassert op_takewhilepos_square_add10([2, 4, 6]) == [14, 26, 46]\nassert op_takewhilepos_square_add10([-7, 12, -7]) == []"}
{"id": "op_square_sortd_odds", "entry_point": "op_square_sortd_odds", "primitives": ["square", "sortd", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then keep the odd numbers.", "solution": "def op_square_sortd_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_sortd_odds([1, 2, 3, 4]) == [9, 1]\nassert op_square_sortd_odds([]) == []\nassert op_square_sortd_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_sortd_odds([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortd_odds([3, 1, 2]) == [9, 1]\nassert op_square_sortd_odds([10]) == []\nassert op_square_sortd_odds([2, 4, 6]) == []\nassert op_square_sortd_odds([-7, 12, -7]) == [49, 49]"}
{"id": "op_sortalpha_prefixup_dropshort", "entry_point": "op_sortalpha_prefixup_dropshort", "primitives": ["sortalpha", "prefixup", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then prefix each with a hash, then drop strings shorter than three characters.", "solution": "def op_sortalpha_prefixup_dropshort(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_sortalpha_prefixup_dropshort(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortalpha_prefixup_dropshort([]) == []\nassert op_sortalpha_prefixup_dropshort(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_sortalpha_prefixup_dropshort(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_sortalpha_prefixup_dropshort(['x']) == []\nassert op_sortalpha_prefixup_dropshort(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_dropzeros_sorta_dec", "entry_point": "op_dropzeros_sorta_dec", "primitives": ["dropzeros", "sorta", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then subtract one from each.", "solution": "def op_dropzeros_sorta_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropzeros_sorta_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropzeros_sorta_dec([]) == []\nassert op_dropzeros_sorta_dec([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_dropzeros_sorta_dec([5, 5, 5]) == [4, 4, 4]\nassert op_dropzeros_sorta_dec([3, 1, 2]) == [0, 1, 2]\nassert op_dropzeros_sorta_dec([10]) == [9]\nassert op_dropzeros_sorta_dec([2, 4, 6]) == [1, 3, 5]\nassert op_dropzeros_sorta_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_sorta_first3_evens", "entry_point": "op_sorta_first3_evens", "primitives": ["sorta", "first3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then keep the even numbers.", "solution": "def op_sorta_first3_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_first3_evens([1, 2, 3, 4]) == [2]\nassert op_sorta_first3_evens([]) == []\nassert op_sorta_first3_evens([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_sorta_first3_evens([5, 5, 5]) == []\nassert op_sorta_first3_evens([3, 1, 2]) == [2]\nassert op_sorta_first3_evens([10]) == [10]\nassert op_sorta_first3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_first3_evens([-7, 12, -7]) == [12]"}
{"id": "op_padto3_oremptyzero_sortd", "entry_point": "op_padto3_oremptyzero_sortd", "primitives": ["padto3", "oremptyzero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then sort descending.", "solution": "def op_padto3_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_oremptyzero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_oremptyzero_sortd([]) == [0, 0, 0]\nassert op_padto3_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_oremptyzero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_oremptyzero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_padto3_oremptyzero_sortd([10]) == [10, 0, 0]\nassert op_padto3_oremptyzero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_oremptyzero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_trimends_takewhilepos_absval", "entry_point": "op_trimends_takewhilepos_absval", "primitives": ["trimends", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive, then take the absolute value of each.", "solution": "def op_trimends_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_trimends_takewhilepos_absval([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_takewhilepos_absval([]) == []\nassert op_trimends_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_trimends_takewhilepos_absval([5, 5, 5]) == [5]\nassert op_trimends_takewhilepos_absval([3, 1, 2]) == [1]\nassert op_trimends_takewhilepos_absval([10]) == []\nassert op_trimends_takewhilepos_absval([2, 4, 6]) == [4]\nassert op_trimends_takewhilepos_absval([-7, 12, -7]) == [12]"}
{"id": "op_pos_oremptyzero_padto3", "entry_point": "op_pos_oremptyzero_padto3", "primitives": ["pos", "oremptyzero", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_pos_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_pos_oremptyzero_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_pos_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_oremptyzero_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_oremptyzero_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_oremptyzero_padto3([10]) == [10, 0, 0]\nassert op_pos_oremptyzero_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_oremptyzero_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sortd_sortabs_firsteven", "entry_point": "op_sortd_sortabs_firsteven", "primitives": ["sortd", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_sortd_sortabs_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortd_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_sortd_sortabs_firsteven([]) == 0\nassert op_sortd_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_sortabs_firsteven([5, 5, 5]) == 0\nassert op_sortd_sortabs_firsteven([3, 1, 2]) == 2\nassert op_sortd_sortabs_firsteven([10]) == 10\nassert op_sortd_sortabs_firsteven([2, 4, 6]) == 2\nassert op_sortd_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_beforezero_sorta_div3", "entry_point": "op_beforezero_sorta_div3", "primitives": ["beforezero", "sorta", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then keep multiples of three.", "solution": "def op_beforezero_sorta_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_sorta_div3([1, 2, 3, 4]) == [3]\nassert op_beforezero_sorta_div3([]) == []\nassert op_beforezero_sorta_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_sorta_div3([5, 5, 5]) == []\nassert op_beforezero_sorta_div3([3, 1, 2]) == [3]\nassert op_beforezero_sorta_div3([10]) == []\nassert op_beforezero_sorta_div3([2, 4, 6]) == [6]\nassert op_beforezero_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_sortd_inc_dec", "entry_point": "op_sortd_inc_dec", "primitives": ["sortd", "inc", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then subtract one from each.", "solution": "def op_sortd_inc_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_inc_dec([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_inc_dec([]) == []\nassert op_sortd_inc_dec([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_inc_dec([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_inc_dec([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_inc_dec([10]) == [10]\nassert op_sortd_inc_dec([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_inc_dec([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_square_sortabs_takewhilepos", "entry_point": "op_square_sortabs_takewhilepos", "primitives": ["square", "sortabs", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then take values while they are positive.", "solution": "def op_square_sortabs_takewhilepos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_square_sortabs_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sortabs_takewhilepos([]) == []\nassert op_square_sortabs_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_square_sortabs_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortabs_takewhilepos([3, 1, 2]) == [1, 4, 9]\nassert op_square_sortabs_takewhilepos([10]) == [100]\nassert op_square_sortabs_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_square_sortabs_takewhilepos([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_beforezero_trimends_issorted", "entry_point": "op_beforezero_trimends_issorted", "primitives": ["beforezero", "trimends", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_beforezero_trimends_issorted(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_beforezero_trimends_issorted([1, 2, 3, 4]) == True\nassert op_beforezero_trimends_issorted([]) == True\nassert op_beforezero_trimends_issorted([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_trimends_issorted([5, 5, 5]) == True\nassert op_beforezero_trimends_issorted([3, 1, 2]) == True\nassert op_beforezero_trimends_issorted([10]) == True\nassert op_beforezero_trimends_issorted([2, 4, 6]) == True\nassert op_beforezero_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_first3_odds_uniq", "entry_point": "op_first3_odds_uniq", "primitives": ["first3", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_first3_odds_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_first3_odds_uniq([]) == []\nassert op_first3_odds_uniq([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_odds_uniq([5, 5, 5]) == [5]\nassert op_first3_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_first3_odds_uniq([10]) == []\nassert op_first3_odds_uniq([2, 4, 6]) == []\nassert op_first3_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_takewhilepos_padto3_sorta", "entry_point": "op_takewhilepos_padto3_sorta", "primitives": ["takewhilepos", "padto3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then sort ascending.", "solution": "def op_takewhilepos_padto3_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_padto3_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_padto3_sorta([]) == [0, 0, 0]\nassert op_takewhilepos_padto3_sorta([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_padto3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_padto3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_padto3_sorta([10]) == [0, 0, 10]\nassert op_takewhilepos_padto3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_padto3_sorta([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_sortabs_div3_padto3", "entry_point": "op_sortabs_div3_padto3", "primitives": ["sortabs", "div3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then pad with zeros to at least three elements.", "solution": "def op_sortabs_div3_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_div3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_sortabs_div3_padto3([]) == [0, 0, 0]\nassert op_sortabs_div3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_sortabs_div3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_sortabs_div3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_sortabs_div3_padto3([10]) == [0, 0, 0]\nassert op_sortabs_div3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_sortabs_div3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_pos_double_clamp10", "entry_point": "op_pos_double_clamp10", "primitives": ["pos", "double", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then cap each value at 10.", "solution": "def op_pos_double_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_double_clamp10([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_double_clamp10([]) == []\nassert op_pos_double_clamp10([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_double_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_pos_double_clamp10([10]) == [10]\nassert op_pos_double_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_pos_double_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_rev_add10_evens", "entry_point": "op_rev_add10_evens", "primitives": ["rev", "add10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then keep the even numbers.", "solution": "def op_rev_add10_evens(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_rev_add10_evens([1, 2, 3, 4]) == [14, 12]\nassert op_rev_add10_evens([]) == []\nassert op_rev_add10_evens([-2, -1, 0, 1, 2]) == [12, 10, 8]\nassert op_rev_add10_evens([5, 5, 5]) == []\nassert op_rev_add10_evens([3, 1, 2]) == [12]\nassert op_rev_add10_evens([10]) == [20]\nassert op_rev_add10_evens([2, 4, 6]) == [16, 14, 12]\nassert op_rev_add10_evens([-7, 12, -7]) == [22]"}
{"id": "op_dropwhileneg_dropfirst_sortabs", "entry_point": "op_dropwhileneg_dropfirst_sortabs", "primitives": ["dropwhileneg", "dropfirst", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then sort by absolute value.", "solution": "def op_dropwhileneg_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropwhileneg_dropfirst_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_dropfirst_sortabs([]) == []\nassert op_dropwhileneg_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst_sortabs([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_dropfirst_sortabs([3, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst_sortabs([10]) == []\nassert op_dropwhileneg_dropfirst_sortabs([2, 4, 6]) == [4, 6]\nassert op_dropwhileneg_dropfirst_sortabs([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_first3_counteven", "entry_point": "op_padto3_first3_counteven", "primitives": ["padto3", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then return how many values are even.", "solution": "def op_padto3_first3_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_first3_counteven([1, 2, 3, 4]) == 1\nassert op_padto3_first3_counteven([]) == 3\nassert op_padto3_first3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_first3_counteven([5, 5, 5]) == 0\nassert op_padto3_first3_counteven([3, 1, 2]) == 1\nassert op_padto3_first3_counteven([10]) == 3\nassert op_padto3_first3_counteven([2, 4, 6]) == 3\nassert op_padto3_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_inc_len", "entry_point": "op_neg_inc_len", "primitives": ["neg", "inc", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then return how many remain.", "solution": "def op_neg_inc_len(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return len(r)", "tests": "assert op_neg_inc_len([1, 2, 3, 4]) == 0\nassert op_neg_inc_len([]) == 0\nassert op_neg_inc_len([-2, -1, 0, 1, 2]) == 2\nassert op_neg_inc_len([5, 5, 5]) == 0\nassert op_neg_inc_len([3, 1, 2]) == 0\nassert op_neg_inc_len([10]) == 0\nassert op_neg_inc_len([2, 4, 6]) == 0\nassert op_neg_inc_len([-7, 12, -7]) == 2"}
{"id": "op_pos_sortabs_square", "entry_point": "op_pos_sortabs_square", "primitives": ["pos", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then square each.", "solution": "def op_pos_sortabs_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_sortabs_square([]) == []\nassert op_pos_sortabs_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_pos_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_pos_sortabs_square([10]) == [100]\nassert op_pos_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_pos_sortabs_square([-7, 12, -7]) == [144]"}
{"id": "op_padto3_uniq_anyeven", "entry_point": "op_padto3_uniq_anyeven", "primitives": ["padto3", "uniq", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_padto3_uniq_anyeven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_padto3_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_padto3_uniq_anyeven([]) == True\nassert op_padto3_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_padto3_uniq_anyeven([5, 5, 5]) == False\nassert op_padto3_uniq_anyeven([3, 1, 2]) == True\nassert op_padto3_uniq_anyeven([10]) == True\nassert op_padto3_uniq_anyeven([2, 4, 6]) == True\nassert op_padto3_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_uniq_max", "entry_point": "op_sorta_uniq_max", "primitives": ["sorta", "uniq", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_sorta_uniq_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_sorta_uniq_max([1, 2, 3, 4]) == 4\nassert op_sorta_uniq_max([]) == 0\nassert op_sorta_uniq_max([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_uniq_max([5, 5, 5]) == 5\nassert op_sorta_uniq_max([3, 1, 2]) == 3\nassert op_sorta_uniq_max([10]) == 10\nassert op_sorta_uniq_max([2, 4, 6]) == 6\nassert op_sorta_uniq_max([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_gt5_counteven", "entry_point": "op_takewhilepos_gt5_counteven", "primitives": ["takewhilepos", "gt5", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then return how many values are even.", "solution": "def op_takewhilepos_gt5_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_takewhilepos_gt5_counteven([]) == 0\nassert op_takewhilepos_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_gt5_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_gt5_counteven([3, 1, 2]) == 0\nassert op_takewhilepos_gt5_counteven([10]) == 1\nassert op_takewhilepos_gt5_counteven([2, 4, 6]) == 1\nassert op_takewhilepos_gt5_counteven([-7, 12, -7]) == 0"}
{"id": "op_trimends_rev_dec", "entry_point": "op_trimends_rev_dec", "primitives": ["trimends", "rev", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then subtract one from each.", "solution": "def op_trimends_rev_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_rev_dec([1, 2, 3, 4]) == [2, 1]\nassert op_trimends_rev_dec([]) == []\nassert op_trimends_rev_dec([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_trimends_rev_dec([5, 5, 5]) == [4]\nassert op_trimends_rev_dec([3, 1, 2]) == [0]\nassert op_trimends_rev_dec([10]) == []\nassert op_trimends_rev_dec([2, 4, 6]) == [3]\nassert op_trimends_rev_dec([-7, 12, -7]) == [11]"}
{"id": "op_padto3_div3_dropfirst", "entry_point": "op_padto3_div3_dropfirst", "primitives": ["padto3", "div3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep multiples of three, then drop the first element.", "solution": "def op_padto3_div3_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_div3_dropfirst([1, 2, 3, 4]) == []\nassert op_padto3_div3_dropfirst([]) == [0, 0]\nassert op_padto3_div3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_padto3_div3_dropfirst([5, 5, 5]) == []\nassert op_padto3_div3_dropfirst([3, 1, 2]) == []\nassert op_padto3_div3_dropfirst([10]) == [0]\nassert op_padto3_div3_dropfirst([2, 4, 6]) == []\nassert op_padto3_div3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_div3_gt5_oremptyzero", "entry_point": "op_div3_gt5_oremptyzero", "primitives": ["div3", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_div3_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_div3_gt5_oremptyzero([]) == [0]\nassert op_div3_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_div3_gt5_oremptyzero([10]) == [0]\nassert op_div3_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_div3_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_absval_uniq_add10", "entry_point": "op_absval_uniq_add10", "primitives": ["absval", "uniq", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_absval_uniq_add10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_absval_uniq_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_absval_uniq_add10([]) == []\nassert op_absval_uniq_add10([-2, -1, 0, 1, 2]) == [12, 11, 10]\nassert op_absval_uniq_add10([5, 5, 5]) == [15]\nassert op_absval_uniq_add10([3, 1, 2]) == [13, 11, 12]\nassert op_absval_uniq_add10([10]) == [20]\nassert op_absval_uniq_add10([2, 4, 6]) == [12, 14, 16]\nassert op_absval_uniq_add10([-7, 12, -7]) == [17, 22]"}
{"id": "op_rev_sorta_anyeven", "entry_point": "op_rev_sorta_anyeven", "primitives": ["rev", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then return whether any value is even.", "solution": "def op_rev_sorta_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_rev_sorta_anyeven([]) == False\nassert op_rev_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_sorta_anyeven([5, 5, 5]) == False\nassert op_rev_sorta_anyeven([3, 1, 2]) == True\nassert op_rev_sorta_anyeven([10]) == True\nassert op_rev_sorta_anyeven([2, 4, 6]) == True\nassert op_rev_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_gt5_dropzeros", "entry_point": "op_oremptyzero_gt5_dropzeros", "primitives": ["oremptyzero", "gt5", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then drop the zeros.", "solution": "def op_oremptyzero_gt5_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_dropzeros([]) == []\nassert op_oremptyzero_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_dropzeros([5, 5, 5]) == []\nassert op_oremptyzero_gt5_dropzeros([3, 1, 2]) == []\nassert op_oremptyzero_gt5_dropzeros([10]) == [10]\nassert op_oremptyzero_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dropzeros_clamp10", "entry_point": "op_oremptyzero_dropzeros_clamp10", "primitives": ["oremptyzero", "dropzeros", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then cap each value at 10.", "solution": "def op_oremptyzero_dropzeros_clamp10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_oremptyzero_dropzeros_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_dropzeros_clamp10([]) == []\nassert op_oremptyzero_dropzeros_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_oremptyzero_dropzeros_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropzeros_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_dropzeros_clamp10([10]) == [10]\nassert op_oremptyzero_dropzeros_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_dropzeros_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_first3_last3_square", "entry_point": "op_first3_last3_square", "primitives": ["first3", "last3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then square each.", "solution": "def op_first3_last3_square(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_first3_last3_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_last3_square([]) == []\nassert op_first3_last3_square([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_first3_last3_square([5, 5, 5]) == [25, 25, 25]\nassert op_first3_last3_square([3, 1, 2]) == [9, 1, 4]\nassert op_first3_last3_square([10]) == [100]\nassert op_first3_last3_square([2, 4, 6]) == [4, 16, 36]\nassert op_first3_last3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_beforezero_square_prod", "entry_point": "op_beforezero_square_prod", "primitives": ["beforezero", "square", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then square each, then return their product.", "solution": "def op_beforezero_square_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_square_prod([1, 2, 3, 4]) == 576\nassert op_beforezero_square_prod([]) == 1\nassert op_beforezero_square_prod([-2, -1, 0, 1, 2]) == 4\nassert op_beforezero_square_prod([5, 5, 5]) == 15625\nassert op_beforezero_square_prod([3, 1, 2]) == 36\nassert op_beforezero_square_prod([10]) == 100\nassert op_beforezero_square_prod([2, 4, 6]) == 2304\nassert op_beforezero_square_prod([-7, 12, -7]) == 345744"}
{"id": "op_rev_beforezero_dropwhileneg", "entry_point": "op_rev_beforezero_dropwhileneg", "primitives": ["rev", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_rev_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_rev_beforezero_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_dropwhileneg([]) == []\nassert op_rev_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_dropwhileneg([10]) == [10]\nassert op_rev_beforezero_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_prefixup_lower_joinc", "entry_point": "op_prefixup_lower_joinc", "primitives": ["prefixup", "lower", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then lowercase each string, then join them with commas.", "solution": "def op_prefixup_lower_joinc(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return ','.join(r)", "tests": "assert op_prefixup_lower_joinc(['Hello', 'world']) == '#hello,#world'\nassert op_prefixup_lower_joinc([]) == ''\nassert op_prefixup_lower_joinc(['  a ', '', 'BC', 'bc']) == '#  a ,#,#bc,#bc'\nassert op_prefixup_lower_joinc(['one', 'one', 'Two']) == '#one,#one,#two'\nassert op_prefixup_lower_joinc(['x']) == '#x'\nassert op_prefixup_lower_joinc(['abc', 'de', '']) == '#abc,#de,#'"}
{"id": "op_padto3_odds_sortd", "entry_point": "op_padto3_odds_sortd", "primitives": ["padto3", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then sort descending.", "solution": "def op_padto3_odds_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_padto3_odds_sortd([]) == []\nassert op_padto3_odds_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_padto3_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_padto3_odds_sortd([10]) == []\nassert op_padto3_odds_sortd([2, 4, 6]) == []\nassert op_padto3_odds_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_uniq_odds", "entry_point": "op_clamp10_uniq_odds", "primitives": ["clamp10", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_clamp10_uniq_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_uniq_odds([]) == []\nassert op_clamp10_uniq_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_uniq_odds([5, 5, 5]) == [5]\nassert op_clamp10_uniq_odds([3, 1, 2]) == [3, 1]\nassert op_clamp10_uniq_odds([10]) == []\nassert op_clamp10_uniq_odds([2, 4, 6]) == []\nassert op_clamp10_uniq_odds([-7, 12, -7]) == [-7]"}
{"id": "op_first3_gt5_allpos", "entry_point": "op_first3_gt5_allpos", "primitives": ["first3", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then return whether all values are positive.", "solution": "def op_first3_gt5_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_first3_gt5_allpos([1, 2, 3, 4]) == True\nassert op_first3_gt5_allpos([]) == True\nassert op_first3_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_first3_gt5_allpos([5, 5, 5]) == True\nassert op_first3_gt5_allpos([3, 1, 2]) == True\nassert op_first3_gt5_allpos([10]) == True\nassert op_first3_gt5_allpos([2, 4, 6]) == True\nassert op_first3_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_add10_anyeven", "entry_point": "op_oremptyzero_add10_anyeven", "primitives": ["oremptyzero", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then return whether any value is even.", "solution": "def op_oremptyzero_add10_anyeven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_oremptyzero_add10_anyeven([1, 2, 3, 4]) == True\nassert op_oremptyzero_add10_anyeven([]) == True\nassert op_oremptyzero_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_add10_anyeven([5, 5, 5]) == False\nassert op_oremptyzero_add10_anyeven([3, 1, 2]) == True\nassert op_oremptyzero_add10_anyeven([10]) == True\nassert op_oremptyzero_add10_anyeven([2, 4, 6]) == True\nassert op_oremptyzero_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_pos_rev_negate", "entry_point": "op_pos_rev_negate", "primitives": ["pos", "rev", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then negate each.", "solution": "def op_pos_rev_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_rev_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_pos_rev_negate([]) == []\nassert op_pos_rev_negate([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_pos_rev_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_rev_negate([3, 1, 2]) == [-2, -1, -3]\nassert op_pos_rev_negate([10]) == [-10]\nassert op_pos_rev_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_pos_rev_negate([-7, 12, -7]) == [-12]"}
{"id": "op_rev_last3_prod", "entry_point": "op_rev_last3_prod", "primitives": ["rev", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then return their product.", "solution": "def op_rev_last3_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_rev_last3_prod([1, 2, 3, 4]) == 6\nassert op_rev_last3_prod([]) == 1\nassert op_rev_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_rev_last3_prod([5, 5, 5]) == 125\nassert op_rev_last3_prod([3, 1, 2]) == 6\nassert op_rev_last3_prod([10]) == 10\nassert op_rev_last3_prod([2, 4, 6]) == 48\nassert op_rev_last3_prod([-7, 12, -7]) == 588"}
{"id": "op_add10_uniq_clamp10", "entry_point": "op_add10_uniq_clamp10", "primitives": ["add10", "uniq", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_add10_uniq_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_uniq_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_uniq_clamp10([]) == []\nassert op_add10_uniq_clamp10([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_uniq_clamp10([5, 5, 5]) == [10]\nassert op_add10_uniq_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_add10_uniq_clamp10([10]) == [10]\nassert op_add10_uniq_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_add10_uniq_clamp10([-7, 12, -7]) == [3, 10]"}
{"id": "op_neg_odds_evens", "entry_point": "op_neg_odds_evens", "primitives": ["neg", "odds", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then keep the even numbers.", "solution": "def op_neg_odds_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_odds_evens([1, 2, 3, 4]) == []\nassert op_neg_odds_evens([]) == []\nassert op_neg_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_neg_odds_evens([5, 5, 5]) == []\nassert op_neg_odds_evens([3, 1, 2]) == []\nassert op_neg_odds_evens([10]) == []\nassert op_neg_odds_evens([2, 4, 6]) == []\nassert op_neg_odds_evens([-7, 12, -7]) == []"}
{"id": "op_sorta_sortabs_dropwhileneg", "entry_point": "op_sorta_sortabs_dropwhileneg", "primitives": ["sorta", "sortabs", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then drop the leading negative values.", "solution": "def op_sorta_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sorta_sortabs_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_sortabs_dropwhileneg([]) == []\nassert op_sorta_sortabs_dropwhileneg([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sorta_sortabs_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortabs_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_sortabs_dropwhileneg([10]) == [10]\nassert op_sorta_sortabs_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_sortabs_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortabs_beforezero", "entry_point": "op_rev_sortabs_beforezero", "primitives": ["rev", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_rev_sortabs_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_sortabs_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_sortabs_beforezero([]) == []\nassert op_rev_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_rev_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sortabs_beforezero([10]) == [10]\nassert op_rev_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sortabs_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropzeros_last3_dropfirst", "entry_point": "op_dropzeros_last3_dropfirst", "primitives": ["dropzeros", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then drop the first element.", "solution": "def op_dropzeros_last3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_last3_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_dropzeros_last3_dropfirst([]) == []\nassert op_dropzeros_last3_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_last3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_last3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropzeros_last3_dropfirst([10]) == []\nassert op_dropzeros_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropzeros_last3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_uniq_padto3_square", "entry_point": "op_uniq_padto3_square", "primitives": ["uniq", "padto3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements, then square each.", "solution": "def op_uniq_padto3_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_padto3_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_padto3_square([]) == [0, 0, 0]\nassert op_uniq_padto3_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_uniq_padto3_square([5, 5, 5]) == [25, 0, 0]\nassert op_uniq_padto3_square([3, 1, 2]) == [9, 1, 4]\nassert op_uniq_padto3_square([10]) == [100, 0, 0]\nassert op_uniq_padto3_square([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_padto3_square([-7, 12, -7]) == [49, 144, 0]"}
{"id": "op_first3_clamp10_uniq", "entry_point": "op_first3_clamp10_uniq", "primitives": ["first3", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_first3_clamp10_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_clamp10_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10_uniq([]) == []\nassert op_first3_clamp10_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_clamp10_uniq([5, 5, 5]) == [5]\nassert op_first3_clamp10_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_first3_clamp10_uniq([10]) == [10]\nassert op_first3_clamp10_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_last3_padto3_prod", "entry_point": "op_last3_padto3_prod", "primitives": ["last3", "padto3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then return their product.", "solution": "def op_last3_padto3_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_last3_padto3_prod([1, 2, 3, 4]) == 24\nassert op_last3_padto3_prod([]) == 0\nassert op_last3_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_last3_padto3_prod([5, 5, 5]) == 125\nassert op_last3_padto3_prod([3, 1, 2]) == 6\nassert op_last3_padto3_prod([10]) == 0\nassert op_last3_padto3_prod([2, 4, 6]) == 48\nassert op_last3_padto3_prod([-7, 12, -7]) == 588"}
{"id": "op_sorta_add10_rev", "entry_point": "op_sorta_add10_rev", "primitives": ["sorta", "add10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then reverse the order.", "solution": "def op_sorta_add10_rev(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sorta_add10_rev([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sorta_add10_rev([]) == []\nassert op_sorta_add10_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sorta_add10_rev([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_add10_rev([3, 1, 2]) == [13, 12, 11]\nassert op_sorta_add10_rev([10]) == [20]\nassert op_sorta_add10_rev([2, 4, 6]) == [16, 14, 12]\nassert op_sorta_add10_rev([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_beforezero_sorta_alldistinct", "entry_point": "op_beforezero_sorta_alldistinct", "primitives": ["beforezero", "sorta", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then return whether all values are distinct.", "solution": "def op_beforezero_sorta_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_sorta_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_sorta_alldistinct([]) == True\nassert op_beforezero_sorta_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_sorta_alldistinct([5, 5, 5]) == False\nassert op_beforezero_sorta_alldistinct([3, 1, 2]) == True\nassert op_beforezero_sorta_alldistinct([10]) == True\nassert op_beforezero_sorta_alldistinct([2, 4, 6]) == True\nassert op_beforezero_sorta_alldistinct([-7, 12, -7]) == False"}
{"id": "op_beforezero_sortabs_padto3", "entry_point": "op_beforezero_sortabs_padto3", "primitives": ["beforezero", "sortabs", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_beforezero_sortabs_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_sortabs_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sortabs_padto3([]) == [0, 0, 0]\nassert op_beforezero_sortabs_padto3([-2, -1, 0, 1, 2]) == [-1, -2, 0]\nassert op_beforezero_sortabs_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortabs_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortabs_padto3([10]) == [10, 0, 0]\nassert op_beforezero_sortabs_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortabs_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_div3_add10_double", "entry_point": "op_div3_add10_double", "primitives": ["div3", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each, then double each.", "solution": "def op_div3_add10_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_add10_double([1, 2, 3, 4]) == [26]\nassert op_div3_add10_double([]) == []\nassert op_div3_add10_double([-2, -1, 0, 1, 2]) == [20]\nassert op_div3_add10_double([5, 5, 5]) == []\nassert op_div3_add10_double([3, 1, 2]) == [26]\nassert op_div3_add10_double([10]) == []\nassert op_div3_add10_double([2, 4, 6]) == [32]\nassert op_div3_add10_double([-7, 12, -7]) == [44]"}
{"id": "op_uniq_square_sorta", "entry_point": "op_uniq_square_sorta", "primitives": ["uniq", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then sort ascending.", "solution": "def op_uniq_square_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_square_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_square_sorta([]) == []\nassert op_uniq_square_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_uniq_square_sorta([5, 5, 5]) == [25]\nassert op_uniq_square_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_uniq_square_sorta([10]) == [100]\nassert op_uniq_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_square_sorta([-7, 12, -7]) == [49, 144]"}
{"id": "op_beforezero_takewhilepos_trimends", "entry_point": "op_beforezero_takewhilepos_trimends", "primitives": ["beforezero", "takewhilepos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then drop the first and last elements.", "solution": "def op_beforezero_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_beforezero_takewhilepos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_beforezero_takewhilepos_trimends([]) == []\nassert op_beforezero_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_trimends([5, 5, 5]) == [5]\nassert op_beforezero_takewhilepos_trimends([3, 1, 2]) == [1]\nassert op_beforezero_takewhilepos_trimends([10]) == []\nassert op_beforezero_takewhilepos_trimends([2, 4, 6]) == [4]\nassert op_beforezero_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_div3_inc_firsteven", "entry_point": "op_div3_inc_firsteven", "primitives": ["div3", "inc", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then return the first even value (0 if none).", "solution": "def op_div3_inc_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_inc_firsteven([1, 2, 3, 4]) == 4\nassert op_div3_inc_firsteven([]) == 0\nassert op_div3_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_inc_firsteven([5, 5, 5]) == 0\nassert op_div3_inc_firsteven([3, 1, 2]) == 4\nassert op_div3_inc_firsteven([10]) == 0\nassert op_div3_inc_firsteven([2, 4, 6]) == 0\nassert op_div3_inc_firsteven([-7, 12, -7]) == 0"}
{"id": "op_last3_dec_trimends", "entry_point": "op_last3_dec_trimends", "primitives": ["last3", "dec", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then drop the first and last elements.", "solution": "def op_last3_dec_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_dec_trimends([1, 2, 3, 4]) == [2]\nassert op_last3_dec_trimends([]) == []\nassert op_last3_dec_trimends([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_dec_trimends([5, 5, 5]) == [4]\nassert op_last3_dec_trimends([3, 1, 2]) == [0]\nassert op_last3_dec_trimends([10]) == []\nassert op_last3_dec_trimends([2, 4, 6]) == [3]\nassert op_last3_dec_trimends([-7, 12, -7]) == [11]"}
{"id": "op_odds_neg_negate", "entry_point": "op_odds_neg_negate", "primitives": ["odds", "neg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then negate each.", "solution": "def op_odds_neg_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_neg_negate([1, 2, 3, 4]) == []\nassert op_odds_neg_negate([]) == []\nassert op_odds_neg_negate([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_neg_negate([5, 5, 5]) == []\nassert op_odds_neg_negate([3, 1, 2]) == []\nassert op_odds_neg_negate([10]) == []\nassert op_odds_neg_negate([2, 4, 6]) == []\nassert op_odds_neg_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_dec_padto3", "entry_point": "op_ages_dec_padto3", "primitives": ["ages", "dec", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_ages_dec_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_dec_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11, 0]\nassert op_ages_dec_padto3([]) == [0, 0, 0]\nassert op_ages_dec_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 64, 16]\nassert op_ages_dec_padto3([{'name': 'Fi', 'age': 41}]) == [40, 0, 0]"}
{"id": "op_sortabs_square_sortd", "entry_point": "op_sortabs_square_sortd", "primitives": ["sortabs", "square", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then sort descending.", "solution": "def op_sortabs_square_sortd(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortabs_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortabs_square_sortd([]) == []\nassert op_sortabs_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_sortabs_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_sortabs_square_sortd([10]) == [100]\nassert op_sortabs_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_sortabs_square_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_ages_negate_clamp10", "entry_point": "op_ages_negate_clamp10", "primitives": ["ages", "negate", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then cap each value at 10.", "solution": "def op_ages_negate_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_negate_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_negate_clamp10([]) == []\nassert op_ages_negate_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_negate_clamp10([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_gt5_sortd_counteven", "entry_point": "op_gt5_sortd_counteven", "primitives": ["gt5", "sortd", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then return how many values are even.", "solution": "def op_gt5_sortd_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_sortd_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_sortd_counteven([]) == 0\nassert op_gt5_sortd_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_sortd_counteven([5, 5, 5]) == 0\nassert op_gt5_sortd_counteven([3, 1, 2]) == 0\nassert op_gt5_sortd_counteven([10]) == 1\nassert op_gt5_sortd_counteven([2, 4, 6]) == 1\nassert op_gt5_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_padto3_dropwhileneg_double", "entry_point": "op_padto3_dropwhileneg_double", "primitives": ["padto3", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then double each.", "solution": "def op_padto3_dropwhileneg_double(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_padto3_dropwhileneg_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_dropwhileneg_double([]) == [0, 0, 0]\nassert op_padto3_dropwhileneg_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_padto3_dropwhileneg_double([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_dropwhileneg_double([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_dropwhileneg_double([10]) == [20, 0, 0]\nassert op_padto3_dropwhileneg_double([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_dropwhileneg_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_square_gt5_oremptyzero", "entry_point": "op_square_gt5_oremptyzero", "primitives": ["square", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_square_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_square_gt5_oremptyzero([1, 2, 3, 4]) == [9, 16]\nassert op_square_gt5_oremptyzero([]) == [0]\nassert op_square_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_square_gt5_oremptyzero([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5_oremptyzero([3, 1, 2]) == [9]\nassert op_square_gt5_oremptyzero([10]) == [100]\nassert op_square_gt5_oremptyzero([2, 4, 6]) == [16, 36]\nassert op_square_gt5_oremptyzero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_inc_last3_evens", "entry_point": "op_inc_last3_evens", "primitives": ["inc", "last3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then keep the even numbers.", "solution": "def op_inc_last3_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_last3_evens([1, 2, 3, 4]) == [4]\nassert op_inc_last3_evens([]) == []\nassert op_inc_last3_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_inc_last3_evens([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_evens([3, 1, 2]) == [4, 2]\nassert op_inc_last3_evens([10]) == []\nassert op_inc_last3_evens([2, 4, 6]) == []\nassert op_inc_last3_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_ages_first3_len", "entry_point": "op_ages_first3_len", "primitives": ["ages", "first3", "len"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then return how many remain.", "solution": "def op_ages_first3_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    return len(r)", "tests": "assert op_ages_first3_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_first3_len([]) == 0\nassert op_ages_first3_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_first3_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_rev_clamp10_odds", "entry_point": "op_rev_clamp10_odds", "primitives": ["rev", "clamp10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then keep the odd numbers.", "solution": "def op_rev_clamp10_odds(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_rev_clamp10_odds([1, 2, 3, 4]) == [3, 1]\nassert op_rev_clamp10_odds([]) == []\nassert op_rev_clamp10_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_rev_clamp10_odds([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10_odds([3, 1, 2]) == [1, 3]\nassert op_rev_clamp10_odds([10]) == []\nassert op_rev_clamp10_odds([2, 4, 6]) == []\nassert op_rev_clamp10_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_first3_min", "entry_point": "op_beforezero_first3_min", "primitives": ["beforezero", "first3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_beforezero_first3_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_beforezero_first3_min([1, 2, 3, 4]) == 1\nassert op_beforezero_first3_min([]) == 0\nassert op_beforezero_first3_min([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_first3_min([5, 5, 5]) == 5\nassert op_beforezero_first3_min([3, 1, 2]) == 1\nassert op_beforezero_first3_min([10]) == 10\nassert op_beforezero_first3_min([2, 4, 6]) == 2\nassert op_beforezero_first3_min([-7, 12, -7]) == -7"}
{"id": "op_div3_sorta_rev", "entry_point": "op_div3_sorta_rev", "primitives": ["div3", "sorta", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending, then reverse the order.", "solution": "def op_div3_sorta_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_div3_sorta_rev([1, 2, 3, 4]) == [3]\nassert op_div3_sorta_rev([]) == []\nassert op_div3_sorta_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_sorta_rev([5, 5, 5]) == []\nassert op_div3_sorta_rev([3, 1, 2]) == [3]\nassert op_div3_sorta_rev([10]) == []\nassert op_div3_sorta_rev([2, 4, 6]) == [6]\nassert op_div3_sorta_rev([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_dec_odds", "entry_point": "op_dropfirst_dec_odds", "primitives": ["dropfirst", "dec", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then keep the odd numbers.", "solution": "def op_dropfirst_dec_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_dec_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropfirst_dec_odds([]) == []\nassert op_dropfirst_dec_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_dec_odds([5, 5, 5]) == []\nassert op_dropfirst_dec_odds([3, 1, 2]) == [1]\nassert op_dropfirst_dec_odds([10]) == []\nassert op_dropfirst_dec_odds([2, 4, 6]) == [3, 5]\nassert op_dropfirst_dec_odds([-7, 12, -7]) == [11]"}
{"id": "op_last3_beforezero_trimends", "entry_point": "op_last3_beforezero_trimends", "primitives": ["last3", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_last3_beforezero_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_beforezero_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_beforezero_trimends([]) == []\nassert op_last3_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_trimends([5, 5, 5]) == [5]\nassert op_last3_beforezero_trimends([3, 1, 2]) == [1]\nassert op_last3_beforezero_trimends([10]) == []\nassert op_last3_beforezero_trimends([2, 4, 6]) == [4]\nassert op_last3_beforezero_trimends([-7, 12, -7]) == [12]"}
{"id": "op_inc_beforezero_div3", "entry_point": "op_inc_beforezero_div3", "primitives": ["inc", "beforezero", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_inc_beforezero_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_inc_beforezero_div3([]) == []\nassert op_inc_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_inc_beforezero_div3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_beforezero_div3([3, 1, 2]) == [3]\nassert op_inc_beforezero_div3([10]) == []\nassert op_inc_beforezero_div3([2, 4, 6]) == [3]\nassert op_inc_beforezero_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_rev_double_allpos", "entry_point": "op_rev_double_allpos", "primitives": ["rev", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then return whether all values are positive.", "solution": "def op_rev_double_allpos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_rev_double_allpos([1, 2, 3, 4]) == True\nassert op_rev_double_allpos([]) == True\nassert op_rev_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_rev_double_allpos([5, 5, 5]) == True\nassert op_rev_double_allpos([3, 1, 2]) == True\nassert op_rev_double_allpos([10]) == True\nassert op_rev_double_allpos([2, 4, 6]) == True\nassert op_rev_double_allpos([-7, 12, -7]) == False"}
{"id": "op_rev_dropfirst_uniq", "entry_point": "op_rev_dropfirst_uniq", "primitives": ["rev", "dropfirst", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element, then drop duplicates keeping first occurrence.", "solution": "def op_rev_dropfirst_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_dropfirst_uniq([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dropfirst_uniq([]) == []\nassert op_rev_dropfirst_uniq([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_rev_dropfirst_uniq([5, 5, 5]) == [5]\nassert op_rev_dropfirst_uniq([3, 1, 2]) == [1, 3]\nassert op_rev_dropfirst_uniq([10]) == []\nassert op_rev_dropfirst_uniq([2, 4, 6]) == [4, 2]\nassert op_rev_dropfirst_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_sortd_first3", "entry_point": "op_dropfirst_sortd_first3", "primitives": ["dropfirst", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then keep only the first three.", "solution": "def op_dropfirst_sortd_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_sortd_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_sortd_first3([]) == []\nassert op_dropfirst_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropfirst_sortd_first3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortd_first3([3, 1, 2]) == [2, 1]\nassert op_dropfirst_sortd_first3([10]) == []\nassert op_dropfirst_sortd_first3([2, 4, 6]) == [6, 4]\nassert op_dropfirst_sortd_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_inc_add10_prod", "entry_point": "op_inc_add10_prod", "primitives": ["inc", "add10", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return their product.", "solution": "def op_inc_add10_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_inc_add10_prod([1, 2, 3, 4]) == 32760\nassert op_inc_add10_prod([]) == 1\nassert op_inc_add10_prod([-2, -1, 0, 1, 2]) == 154440\nassert op_inc_add10_prod([5, 5, 5]) == 4096\nassert op_inc_add10_prod([3, 1, 2]) == 2184\nassert op_inc_add10_prod([10]) == 21\nassert op_inc_add10_prod([2, 4, 6]) == 3315\nassert op_inc_add10_prod([-7, 12, -7]) == 368"}
{"id": "op_names_strip_lower", "entry_point": "op_names_strip_lower", "primitives": ["names", "strip", "lower"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then trim whitespace from each, then lowercase each string.", "solution": "def op_names_strip_lower(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.strip() for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_names_strip_lower([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['ada', 'bo']\nassert op_names_strip_lower([]) == []\nassert op_names_strip_lower([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['cy', 'dee', 'el']\nassert op_names_strip_lower([{'name': 'Fi', 'age': 41}]) == ['fi']"}
{"id": "op_pos_takewhilepos_rev", "entry_point": "op_pos_takewhilepos_rev", "primitives": ["pos", "takewhilepos", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive, then reverse the order.", "solution": "def op_pos_takewhilepos_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_takewhilepos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_takewhilepos_rev([]) == []\nassert op_pos_takewhilepos_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_takewhilepos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_pos_takewhilepos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_pos_takewhilepos_rev([10]) == [10]\nassert op_pos_takewhilepos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_pos_takewhilepos_rev([-7, 12, -7]) == [12]"}
{"id": "op_ages_gt5_pos", "entry_point": "op_ages_gt5_pos", "primitives": ["ages", "gt5", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep values greater than five, then keep the positive numbers.", "solution": "def op_ages_gt5_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_gt5_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_gt5_pos([]) == []\nassert op_ages_gt5_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_gt5_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dec_neg_odds", "entry_point": "op_dec_neg_odds", "primitives": ["dec", "neg", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_dec_neg_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_neg_odds([1, 2, 3, 4]) == []\nassert op_dec_neg_odds([]) == []\nassert op_dec_neg_odds([-2, -1, 0, 1, 2]) == [-3, -1]\nassert op_dec_neg_odds([5, 5, 5]) == []\nassert op_dec_neg_odds([3, 1, 2]) == []\nassert op_dec_neg_odds([10]) == []\nassert op_dec_neg_odds([2, 4, 6]) == []\nassert op_dec_neg_odds([-7, 12, -7]) == []"}
{"id": "op_sorta_padto3_issorted", "entry_point": "op_sorta_padto3_issorted", "primitives": ["sorta", "padto3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_sorta_padto3_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_sorta_padto3_issorted([1, 2, 3, 4]) == True\nassert op_sorta_padto3_issorted([]) == True\nassert op_sorta_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_padto3_issorted([5, 5, 5]) == True\nassert op_sorta_padto3_issorted([3, 1, 2]) == True\nassert op_sorta_padto3_issorted([10]) == False\nassert op_sorta_padto3_issorted([2, 4, 6]) == True\nassert op_sorta_padto3_issorted([-7, 12, -7]) == True"}
{"id": "op_negate_first3_max", "entry_point": "op_negate_first3_max", "primitives": ["negate", "first3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_negate_first3_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_negate_first3_max([1, 2, 3, 4]) == -1\nassert op_negate_first3_max([]) == 0\nassert op_negate_first3_max([-2, -1, 0, 1, 2]) == 2\nassert op_negate_first3_max([5, 5, 5]) == -5\nassert op_negate_first3_max([3, 1, 2]) == -1\nassert op_negate_first3_max([10]) == -10\nassert op_negate_first3_max([2, 4, 6]) == -2\nassert op_negate_first3_max([-7, 12, -7]) == 7"}
{"id": "op_dropzeros_last3_issorted", "entry_point": "op_dropzeros_last3_issorted", "primitives": ["dropzeros", "last3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_last3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_dropzeros_last3_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_last3_issorted([]) == True\nassert op_dropzeros_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_last3_issorted([5, 5, 5]) == True\nassert op_dropzeros_last3_issorted([3, 1, 2]) == False\nassert op_dropzeros_last3_issorted([10]) == True\nassert op_dropzeros_last3_issorted([2, 4, 6]) == True\nassert op_dropzeros_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_sorta_div3_add10", "entry_point": "op_sorta_div3_add10", "primitives": ["sorta", "div3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep multiples of three, then add ten to each.", "solution": "def op_sorta_div3_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_div3_add10([1, 2, 3, 4]) == [13]\nassert op_sorta_div3_add10([]) == []\nassert op_sorta_div3_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_sorta_div3_add10([5, 5, 5]) == []\nassert op_sorta_div3_add10([3, 1, 2]) == [13]\nassert op_sorta_div3_add10([10]) == []\nassert op_sorta_div3_add10([2, 4, 6]) == [16]\nassert op_sorta_div3_add10([-7, 12, -7]) == [22]"}
{"id": "op_pos_double_sortd", "entry_point": "op_pos_double_sortd", "primitives": ["pos", "double", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then sort descending.", "solution": "def op_pos_double_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_pos_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_pos_double_sortd([]) == []\nassert op_pos_double_sortd([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_pos_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_pos_double_sortd([10]) == [20]\nassert op_pos_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_pos_double_sortd([-7, 12, -7]) == [24]"}
{"id": "op_pos_dec_clamp10", "entry_point": "op_pos_dec_clamp10", "primitives": ["pos", "dec", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then cap each value at 10.", "solution": "def op_pos_dec_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_dec_clamp10([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_pos_dec_clamp10([]) == []\nassert op_pos_dec_clamp10([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_dec_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_pos_dec_clamp10([3, 1, 2]) == [2, 0, 1]\nassert op_pos_dec_clamp10([10]) == [9]\nassert op_pos_dec_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_pos_dec_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_double_absval_pos", "entry_point": "op_double_absval_pos", "primitives": ["double", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_double_absval_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_absval_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_absval_pos([]) == []\nassert op_double_absval_pos([-2, -1, 0, 1, 2]) == [4, 2, 2, 4]\nassert op_double_absval_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_absval_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_absval_pos([10]) == [20]\nassert op_double_absval_pos([2, 4, 6]) == [4, 8, 12]\nassert op_double_absval_pos([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_evens_dropfirst_odds", "entry_point": "op_evens_dropfirst_odds", "primitives": ["evens", "dropfirst", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then keep the odd numbers.", "solution": "def op_evens_dropfirst_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_dropfirst_odds([1, 2, 3, 4]) == []\nassert op_evens_dropfirst_odds([]) == []\nassert op_evens_dropfirst_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_dropfirst_odds([5, 5, 5]) == []\nassert op_evens_dropfirst_odds([3, 1, 2]) == []\nassert op_evens_dropfirst_odds([10]) == []\nassert op_evens_dropfirst_odds([2, 4, 6]) == []\nassert op_evens_dropfirst_odds([-7, 12, -7]) == []"}
{"id": "op_ages_gt5_anyeven", "entry_point": "op_ages_gt5_anyeven", "primitives": ["ages", "gt5", "anyeven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep values greater than five, then return whether any value is even.", "solution": "def op_ages_gt5_anyeven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_ages_gt5_anyeven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_gt5_anyeven([]) == False\nassert op_ages_gt5_anyeven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_gt5_anyeven([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_beforezero_dec_firsteven", "entry_point": "op_beforezero_dec_firsteven", "primitives": ["beforezero", "dec", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then return the first even value (0 if none).", "solution": "def op_beforezero_dec_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_dec_firsteven([1, 2, 3, 4]) == 0\nassert op_beforezero_dec_firsteven([]) == 0\nassert op_beforezero_dec_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_dec_firsteven([5, 5, 5]) == 4\nassert op_beforezero_dec_firsteven([3, 1, 2]) == 2\nassert op_beforezero_dec_firsteven([10]) == 0\nassert op_beforezero_dec_firsteven([2, 4, 6]) == 0\nassert op_beforezero_dec_firsteven([-7, 12, -7]) == -8"}
{"id": "op_first3_add10_allpos", "entry_point": "op_first3_add10_allpos", "primitives": ["first3", "add10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then return whether all values are positive.", "solution": "def op_first3_add10_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_first3_add10_allpos([1, 2, 3, 4]) == True\nassert op_first3_add10_allpos([]) == True\nassert op_first3_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_first3_add10_allpos([5, 5, 5]) == True\nassert op_first3_add10_allpos([3, 1, 2]) == True\nassert op_first3_add10_allpos([10]) == True\nassert op_first3_add10_allpos([2, 4, 6]) == True\nassert op_first3_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_square_pos_max", "entry_point": "op_square_pos_max", "primitives": ["square", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_square_pos_max(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_square_pos_max([1, 2, 3, 4]) == 16\nassert op_square_pos_max([]) == 0\nassert op_square_pos_max([-2, -1, 0, 1, 2]) == 4\nassert op_square_pos_max([5, 5, 5]) == 25\nassert op_square_pos_max([3, 1, 2]) == 9\nassert op_square_pos_max([10]) == 100\nassert op_square_pos_max([2, 4, 6]) == 36\nassert op_square_pos_max([-7, 12, -7]) == 144"}
{"id": "op_oremptyzero_add10_first3", "entry_point": "op_oremptyzero_add10_first3", "primitives": ["oremptyzero", "add10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then keep only the first three.", "solution": "def op_oremptyzero_add10_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_add10_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_oremptyzero_add10_first3([]) == [10]\nassert op_oremptyzero_add10_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_oremptyzero_add10_first3([5, 5, 5]) == [15, 15, 15]\nassert op_oremptyzero_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_oremptyzero_add10_first3([10]) == [20]\nassert op_oremptyzero_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_oremptyzero_add10_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_sortabs_rev_alldistinct", "entry_point": "op_sortabs_rev_alldistinct", "primitives": ["sortabs", "rev", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then return whether all values are distinct.", "solution": "def op_sortabs_rev_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_rev_alldistinct([]) == True\nassert op_sortabs_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_rev_alldistinct([5, 5, 5]) == False\nassert op_sortabs_rev_alldistinct([3, 1, 2]) == True\nassert op_sortabs_rev_alldistinct([10]) == True\nassert op_sortabs_rev_alldistinct([2, 4, 6]) == True\nassert op_sortabs_rev_alldistinct([-7, 12, -7]) == False"}
{"id": "op_clamp10_beforezero_firsteven", "entry_point": "op_clamp10_beforezero_firsteven", "primitives": ["clamp10", "beforezero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_clamp10_beforezero_firsteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_clamp10_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_clamp10_beforezero_firsteven([]) == 0\nassert op_clamp10_beforezero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_clamp10_beforezero_firsteven([5, 5, 5]) == 0\nassert op_clamp10_beforezero_firsteven([3, 1, 2]) == 2\nassert op_clamp10_beforezero_firsteven([10]) == 10\nassert op_clamp10_beforezero_firsteven([2, 4, 6]) == 2\nassert op_clamp10_beforezero_firsteven([-7, 12, -7]) == 10"}
{"id": "op_upper_lower_maxlen", "entry_point": "op_upper_lower_maxlen", "primitives": ["upper", "lower", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then lowercase each string, then return the length of the longest string (0 if none).", "solution": "def op_upper_lower_maxlen(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_upper_lower_maxlen(['Hello', 'world']) == 5\nassert op_upper_lower_maxlen([]) == 0\nassert op_upper_lower_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_upper_lower_maxlen(['one', 'one', 'Two']) == 3\nassert op_upper_lower_maxlen(['x']) == 1\nassert op_upper_lower_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_sorta_negate_beforezero", "entry_point": "op_sorta_negate_beforezero", "primitives": ["sorta", "negate", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then keep everything before the first zero.", "solution": "def op_sorta_negate_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_negate_beforezero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_negate_beforezero([]) == []\nassert op_sorta_negate_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sorta_negate_beforezero([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_negate_beforezero([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_negate_beforezero([10]) == [-10]\nassert op_sorta_negate_beforezero([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_negate_beforezero([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_sortd_evens_prod", "entry_point": "op_sortd_evens_prod", "primitives": ["sortd", "evens", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then return their product.", "solution": "def op_sortd_evens_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_sortd_evens_prod([1, 2, 3, 4]) == 8\nassert op_sortd_evens_prod([]) == 1\nassert op_sortd_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_evens_prod([5, 5, 5]) == 1\nassert op_sortd_evens_prod([3, 1, 2]) == 2\nassert op_sortd_evens_prod([10]) == 10\nassert op_sortd_evens_prod([2, 4, 6]) == 48\nassert op_sortd_evens_prod([-7, 12, -7]) == 12"}
{"id": "op_last3_rev_add10", "entry_point": "op_last3_rev_add10", "primitives": ["last3", "rev", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then add ten to each.", "solution": "def op_last3_rev_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_rev_add10([1, 2, 3, 4]) == [14, 13, 12]\nassert op_last3_rev_add10([]) == []\nassert op_last3_rev_add10([-2, -1, 0, 1, 2]) == [12, 11, 10]\nassert op_last3_rev_add10([5, 5, 5]) == [15, 15, 15]\nassert op_last3_rev_add10([3, 1, 2]) == [12, 11, 13]\nassert op_last3_rev_add10([10]) == [20]\nassert op_last3_rev_add10([2, 4, 6]) == [16, 14, 12]\nassert op_last3_rev_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_double_evens_negate", "entry_point": "op_double_evens_negate", "primitives": ["double", "evens", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then negate each.", "solution": "def op_double_evens_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_evens_negate([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_evens_negate([]) == []\nassert op_double_evens_negate([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_evens_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_double_evens_negate([3, 1, 2]) == [-6, -2, -4]\nassert op_double_evens_negate([10]) == [-20]\nassert op_double_evens_negate([2, 4, 6]) == [-4, -8, -12]\nassert op_double_evens_negate([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_negate_absval_pos", "entry_point": "op_negate_absval_pos", "primitives": ["negate", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_negate_absval_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_absval_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval_pos([]) == []\nassert op_negate_absval_pos([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_negate_absval_pos([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval_pos([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval_pos([10]) == [10]\nassert op_negate_absval_pos([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval_pos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_dropzeros_clamp10_evens", "entry_point": "op_dropzeros_clamp10_evens", "primitives": ["dropzeros", "clamp10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then keep the even numbers.", "solution": "def op_dropzeros_clamp10_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropzeros_clamp10_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropzeros_clamp10_evens([]) == []\nassert op_dropzeros_clamp10_evens([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_dropzeros_clamp10_evens([5, 5, 5]) == []\nassert op_dropzeros_clamp10_evens([3, 1, 2]) == [2]\nassert op_dropzeros_clamp10_evens([10]) == [10]\nassert op_dropzeros_clamp10_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_clamp10_evens([-7, 12, -7]) == [10]"}
{"id": "op_sortabs_double_len", "entry_point": "op_sortabs_double_len", "primitives": ["sortabs", "double", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then return how many remain.", "solution": "def op_sortabs_double_len(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_sortabs_double_len([1, 2, 3, 4]) == 4\nassert op_sortabs_double_len([]) == 0\nassert op_sortabs_double_len([-2, -1, 0, 1, 2]) == 5\nassert op_sortabs_double_len([5, 5, 5]) == 3\nassert op_sortabs_double_len([3, 1, 2]) == 3\nassert op_sortabs_double_len([10]) == 1\nassert op_sortabs_double_len([2, 4, 6]) == 3\nassert op_sortabs_double_len([-7, 12, -7]) == 3"}
{"id": "op_evens_sorta_takewhilepos", "entry_point": "op_evens_sorta_takewhilepos", "primitives": ["evens", "sorta", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then take values while they are positive.", "solution": "def op_evens_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_evens_sorta_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_evens_sorta_takewhilepos([]) == []\nassert op_evens_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_evens_sorta_takewhilepos([5, 5, 5]) == []\nassert op_evens_sorta_takewhilepos([3, 1, 2]) == [2]\nassert op_evens_sorta_takewhilepos([10]) == [10]\nassert op_evens_sorta_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_evens_sorta_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_negate_sorta_issorted", "entry_point": "op_negate_sorta_issorted", "primitives": ["negate", "sorta", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_negate_sorta_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_negate_sorta_issorted([1, 2, 3, 4]) == True\nassert op_negate_sorta_issorted([]) == True\nassert op_negate_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_negate_sorta_issorted([5, 5, 5]) == True\nassert op_negate_sorta_issorted([3, 1, 2]) == True\nassert op_negate_sorta_issorted([10]) == True\nassert op_negate_sorta_issorted([2, 4, 6]) == True\nassert op_negate_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_negate_square", "entry_point": "op_gt5_negate_square", "primitives": ["gt5", "negate", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then square each.", "solution": "def op_gt5_negate_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_negate_square([1, 2, 3, 4]) == []\nassert op_gt5_negate_square([]) == []\nassert op_gt5_negate_square([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_square([5, 5, 5]) == []\nassert op_gt5_negate_square([3, 1, 2]) == []\nassert op_gt5_negate_square([10]) == [100]\nassert op_gt5_negate_square([2, 4, 6]) == [36]\nassert op_gt5_negate_square([-7, 12, -7]) == [144]"}
{"id": "op_ages_trimends_last3", "entry_point": "op_ages_trimends_last3", "primitives": ["ages", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then keep only the last three.", "solution": "def op_ages_trimends_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_trimends_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_last3([]) == []\nassert op_ages_trimends_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_trimends_last3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_padto3_beforezero_anyeven", "entry_point": "op_padto3_beforezero_anyeven", "primitives": ["padto3", "beforezero", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then return whether any value is even.", "solution": "def op_padto3_beforezero_anyeven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_padto3_beforezero_anyeven([1, 2, 3, 4]) == True\nassert op_padto3_beforezero_anyeven([]) == False\nassert op_padto3_beforezero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_padto3_beforezero_anyeven([5, 5, 5]) == False\nassert op_padto3_beforezero_anyeven([3, 1, 2]) == True\nassert op_padto3_beforezero_anyeven([10]) == True\nassert op_padto3_beforezero_anyeven([2, 4, 6]) == True\nassert op_padto3_beforezero_anyeven([-7, 12, -7]) == True"}
{"id": "op_rev_negate_counteven", "entry_point": "op_rev_negate_counteven", "primitives": ["rev", "negate", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then return how many values are even.", "solution": "def op_rev_negate_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_negate_counteven([1, 2, 3, 4]) == 2\nassert op_rev_negate_counteven([]) == 0\nassert op_rev_negate_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_rev_negate_counteven([5, 5, 5]) == 0\nassert op_rev_negate_counteven([3, 1, 2]) == 1\nassert op_rev_negate_counteven([10]) == 1\nassert op_rev_negate_counteven([2, 4, 6]) == 3\nassert op_rev_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_oremptyzero_gt5", "entry_point": "op_dropfirst_oremptyzero_gt5", "primitives": ["dropfirst", "oremptyzero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then keep values greater than five.", "solution": "def op_dropfirst_oremptyzero_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_oremptyzero_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_oremptyzero_gt5([]) == []\nassert op_dropfirst_oremptyzero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_oremptyzero_gt5([5, 5, 5]) == []\nassert op_dropfirst_oremptyzero_gt5([3, 1, 2]) == []\nassert op_dropfirst_oremptyzero_gt5([10]) == []\nassert op_dropfirst_oremptyzero_gt5([2, 4, 6]) == [6]\nassert op_dropfirst_oremptyzero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sorta_evens_firsteven", "entry_point": "op_sorta_evens_firsteven", "primitives": ["sorta", "evens", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then return the first even value (0 if none).", "solution": "def op_sorta_evens_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_evens_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_evens_firsteven([]) == 0\nassert op_sorta_evens_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_evens_firsteven([5, 5, 5]) == 0\nassert op_sorta_evens_firsteven([3, 1, 2]) == 2\nassert op_sorta_evens_firsteven([10]) == 10\nassert op_sorta_evens_firsteven([2, 4, 6]) == 2\nassert op_sorta_evens_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_square_issorted", "entry_point": "op_dropzeros_square_issorted", "primitives": ["dropzeros", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_square_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_dropzeros_square_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_square_issorted([]) == True\nassert op_dropzeros_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_square_issorted([5, 5, 5]) == True\nassert op_dropzeros_square_issorted([3, 1, 2]) == False\nassert op_dropzeros_square_issorted([10]) == True\nassert op_dropzeros_square_issorted([2, 4, 6]) == True\nassert op_dropzeros_square_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_beforezero_oremptyzero", "entry_point": "op_dropzeros_beforezero_oremptyzero", "primitives": ["dropzeros", "beforezero", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_dropzeros_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_beforezero_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_beforezero_oremptyzero([]) == [0]\nassert op_dropzeros_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_beforezero_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_beforezero_oremptyzero([10]) == [10]\nassert op_dropzeros_beforezero_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_beforezero_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_ages_dropfirst_beforezero", "entry_point": "op_ages_dropfirst_beforezero", "primitives": ["ages", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then keep everything before the first zero.", "solution": "def op_ages_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_dropfirst_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst_beforezero([]) == []\nassert op_ages_dropfirst_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropfirst_beforezero([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dec_rev_dropzeros", "entry_point": "op_dec_rev_dropzeros", "primitives": ["dec", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then drop the zeros.", "solution": "def op_dec_rev_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_rev_dropzeros([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dec_rev_dropzeros([]) == []\nassert op_dec_rev_dropzeros([-2, -1, 0, 1, 2]) == [1, -1, -2, -3]\nassert op_dec_rev_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_rev_dropzeros([3, 1, 2]) == [1, 2]\nassert op_dec_rev_dropzeros([10]) == [9]\nassert op_dec_rev_dropzeros([2, 4, 6]) == [5, 3, 1]\nassert op_dec_rev_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropfirst_beforezero_sorta", "entry_point": "op_dropfirst_beforezero_sorta", "primitives": ["dropfirst", "beforezero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then sort ascending.", "solution": "def op_dropfirst_beforezero_sorta(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_dropfirst_beforezero_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_beforezero_sorta([]) == []\nassert op_dropfirst_beforezero_sorta([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_beforezero_sorta([5, 5, 5]) == [5, 5]\nassert op_dropfirst_beforezero_sorta([3, 1, 2]) == [1, 2]\nassert op_dropfirst_beforezero_sorta([10]) == []\nassert op_dropfirst_beforezero_sorta([2, 4, 6]) == [4, 6]\nassert op_dropfirst_beforezero_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_gt5_add10_dropwhileneg", "entry_point": "op_gt5_add10_dropwhileneg", "primitives": ["gt5", "add10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then drop the leading negative values.", "solution": "def op_gt5_add10_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_gt5_add10_dropwhileneg([1, 2, 3, 4]) == []\nassert op_gt5_add10_dropwhileneg([]) == []\nassert op_gt5_add10_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_dropwhileneg([5, 5, 5]) == []\nassert op_gt5_add10_dropwhileneg([3, 1, 2]) == []\nassert op_gt5_add10_dropwhileneg([10]) == [20]\nassert op_gt5_add10_dropwhileneg([2, 4, 6]) == [16]\nassert op_gt5_add10_dropwhileneg([-7, 12, -7]) == [22]"}
{"id": "op_div3_double_oremptyzero", "entry_point": "op_div3_double_oremptyzero", "primitives": ["div3", "double", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then if empty, use a single zero.", "solution": "def op_div3_double_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_double_oremptyzero([1, 2, 3, 4]) == [6]\nassert op_div3_double_oremptyzero([]) == [0]\nassert op_div3_double_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_double_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_double_oremptyzero([3, 1, 2]) == [6]\nassert op_div3_double_oremptyzero([10]) == [0]\nassert op_div3_double_oremptyzero([2, 4, 6]) == [12]\nassert op_div3_double_oremptyzero([-7, 12, -7]) == [24]"}
{"id": "op_oremptyzero_dropfirst_negate", "entry_point": "op_oremptyzero_dropfirst_negate", "primitives": ["oremptyzero", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then negate each.", "solution": "def op_oremptyzero_dropfirst_negate(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_oremptyzero_dropfirst_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_oremptyzero_dropfirst_negate([]) == []\nassert op_oremptyzero_dropfirst_negate([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_oremptyzero_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_oremptyzero_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_oremptyzero_dropfirst_negate([10]) == []\nassert op_oremptyzero_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_oremptyzero_dropfirst_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_pos_beforezero_square", "entry_point": "op_pos_beforezero_square", "primitives": ["pos", "beforezero", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then square each.", "solution": "def op_pos_beforezero_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_beforezero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_beforezero_square([]) == []\nassert op_pos_beforezero_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_beforezero_square([5, 5, 5]) == [25, 25, 25]\nassert op_pos_beforezero_square([3, 1, 2]) == [9, 1, 4]\nassert op_pos_beforezero_square([10]) == [100]\nassert op_pos_beforezero_square([2, 4, 6]) == [4, 16, 36]\nassert op_pos_beforezero_square([-7, 12, -7]) == [144]"}
{"id": "op_absval_odds_takewhilepos", "entry_point": "op_absval_odds_takewhilepos", "primitives": ["absval", "odds", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers, then take values while they are positive.", "solution": "def op_absval_odds_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_odds_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_absval_odds_takewhilepos([]) == []\nassert op_absval_odds_takewhilepos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_odds_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_odds_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_absval_odds_takewhilepos([10]) == []\nassert op_absval_odds_takewhilepos([2, 4, 6]) == []\nassert op_absval_odds_takewhilepos([-7, 12, -7]) == [7, 7]"}
{"id": "op_rev_gt5_oremptyzero", "entry_point": "op_rev_gt5_oremptyzero", "primitives": ["rev", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_rev_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_rev_gt5_oremptyzero([]) == [0]\nassert op_rev_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_rev_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_rev_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_rev_gt5_oremptyzero([10]) == [10]\nassert op_rev_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_rev_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_ages_pos_dropfirst", "entry_point": "op_ages_pos_dropfirst", "primitives": ["ages", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers, then drop the first element.", "solution": "def op_ages_pos_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_ages_pos_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_pos_dropfirst([]) == []\nassert op_ages_pos_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_pos_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_add10_dropwhileneg_neg", "entry_point": "op_add10_dropwhileneg_neg", "primitives": ["add10", "dropwhileneg", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_add10_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_add10_dropwhileneg_neg([]) == []\nassert op_add10_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_dropwhileneg_neg([5, 5, 5]) == []\nassert op_add10_dropwhileneg_neg([3, 1, 2]) == []\nassert op_add10_dropwhileneg_neg([10]) == []\nassert op_add10_dropwhileneg_neg([2, 4, 6]) == []\nassert op_add10_dropwhileneg_neg([-7, 12, -7]) == []"}
{"id": "op_inc_padto3_issorted", "entry_point": "op_inc_padto3_issorted", "primitives": ["inc", "padto3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_inc_padto3_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_inc_padto3_issorted([1, 2, 3, 4]) == True\nassert op_inc_padto3_issorted([]) == True\nassert op_inc_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_padto3_issorted([5, 5, 5]) == True\nassert op_inc_padto3_issorted([3, 1, 2]) == False\nassert op_inc_padto3_issorted([10]) == False\nassert op_inc_padto3_issorted([2, 4, 6]) == True\nassert op_inc_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_trimends_negate_anyeven", "entry_point": "op_trimends_negate_anyeven", "primitives": ["trimends", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then return whether any value is even.", "solution": "def op_trimends_negate_anyeven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_trimends_negate_anyeven([1, 2, 3, 4]) == True\nassert op_trimends_negate_anyeven([]) == False\nassert op_trimends_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_trimends_negate_anyeven([5, 5, 5]) == False\nassert op_trimends_negate_anyeven([3, 1, 2]) == False\nassert op_trimends_negate_anyeven([10]) == False\nassert op_trimends_negate_anyeven([2, 4, 6]) == True\nassert op_trimends_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_double_beforezero", "entry_point": "op_uniq_double_beforezero", "primitives": ["uniq", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then keep everything before the first zero.", "solution": "def op_uniq_double_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_double_beforezero([]) == []\nassert op_uniq_double_beforezero([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_uniq_double_beforezero([5, 5, 5]) == [10]\nassert op_uniq_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_double_beforezero([10]) == [20]\nassert op_uniq_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_uniq_double_beforezero([-7, 12, -7]) == [-14, 24]"}
{"id": "op_pos_div3_trimends", "entry_point": "op_pos_div3_trimends", "primitives": ["pos", "div3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then drop the first and last elements.", "solution": "def op_pos_div3_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_pos_div3_trimends([1, 2, 3, 4]) == []\nassert op_pos_div3_trimends([]) == []\nassert op_pos_div3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_pos_div3_trimends([5, 5, 5]) == []\nassert op_pos_div3_trimends([3, 1, 2]) == []\nassert op_pos_div3_trimends([10]) == []\nassert op_pos_div3_trimends([2, 4, 6]) == []\nassert op_pos_div3_trimends([-7, 12, -7]) == []"}
{"id": "op_sortabs_dropwhileneg_negate", "entry_point": "op_sortabs_dropwhileneg_negate", "primitives": ["sortabs", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then negate each.", "solution": "def op_sortabs_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_dropwhileneg_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sortabs_dropwhileneg_negate([]) == []\nassert op_sortabs_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortabs_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_dropwhileneg_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_dropwhileneg_negate([10]) == [-10]\nassert op_sortabs_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_dropwhileneg_negate([-7, 12, -7]) == [-12]"}
{"id": "op_beforezero_clamp10_odds", "entry_point": "op_beforezero_clamp10_odds", "primitives": ["beforezero", "clamp10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10, then keep the odd numbers.", "solution": "def op_beforezero_clamp10_odds(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_beforezero_clamp10_odds([1, 2, 3, 4]) == [1, 3]\nassert op_beforezero_clamp10_odds([]) == []\nassert op_beforezero_clamp10_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_clamp10_odds([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_clamp10_odds([3, 1, 2]) == [3, 1]\nassert op_beforezero_clamp10_odds([10]) == []\nassert op_beforezero_clamp10_odds([2, 4, 6]) == []\nassert op_beforezero_clamp10_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropzeros_first3_trimends", "entry_point": "op_dropzeros_first3_trimends", "primitives": ["dropzeros", "first3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then drop the first and last elements.", "solution": "def op_dropzeros_first3_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropzeros_first3_trimends([1, 2, 3, 4]) == [2]\nassert op_dropzeros_first3_trimends([]) == []\nassert op_dropzeros_first3_trimends([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropzeros_first3_trimends([5, 5, 5]) == [5]\nassert op_dropzeros_first3_trimends([3, 1, 2]) == [1]\nassert op_dropzeros_first3_trimends([10]) == []\nassert op_dropzeros_first3_trimends([2, 4, 6]) == [4]\nassert op_dropzeros_first3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_rev_first3_trimends", "entry_point": "op_rev_first3_trimends", "primitives": ["rev", "first3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then drop the first and last elements.", "solution": "def op_rev_first3_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_first3_trimends([1, 2, 3, 4]) == [3]\nassert op_rev_first3_trimends([]) == []\nassert op_rev_first3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_rev_first3_trimends([5, 5, 5]) == [5]\nassert op_rev_first3_trimends([3, 1, 2]) == [1]\nassert op_rev_first3_trimends([10]) == []\nassert op_rev_first3_trimends([2, 4, 6]) == [4]\nassert op_rev_first3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_neg_trimends_takewhilepos", "entry_point": "op_neg_trimends_takewhilepos", "primitives": ["neg", "trimends", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then take values while they are positive.", "solution": "def op_neg_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_neg_trimends_takewhilepos([1, 2, 3, 4]) == []\nassert op_neg_trimends_takewhilepos([]) == []\nassert op_neg_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_takewhilepos([5, 5, 5]) == []\nassert op_neg_trimends_takewhilepos([3, 1, 2]) == []\nassert op_neg_trimends_takewhilepos([10]) == []\nassert op_neg_trimends_takewhilepos([2, 4, 6]) == []\nassert op_neg_trimends_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_gt5_takewhilepos", "entry_point": "op_oremptyzero_gt5_takewhilepos", "primitives": ["oremptyzero", "gt5", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then take values while they are positive.", "solution": "def op_oremptyzero_gt5_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_gt5_takewhilepos([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_takewhilepos([]) == []\nassert op_oremptyzero_gt5_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_takewhilepos([5, 5, 5]) == []\nassert op_oremptyzero_gt5_takewhilepos([3, 1, 2]) == []\nassert op_oremptyzero_gt5_takewhilepos([10]) == [10]\nassert op_oremptyzero_gt5_takewhilepos([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_pos_last3", "entry_point": "op_dropwhileneg_pos_last3", "primitives": ["dropwhileneg", "pos", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the positive numbers, then keep only the last three.", "solution": "def op_dropwhileneg_pos_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_pos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_pos_last3([]) == []\nassert op_dropwhileneg_pos_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_pos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_pos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_pos_last3([10]) == [10]\nassert op_dropwhileneg_pos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_pos_last3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_div3_sortd", "entry_point": "op_gt5_div3_sortd", "primitives": ["gt5", "div3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then sort descending.", "solution": "def op_gt5_div3_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_div3_sortd([1, 2, 3, 4]) == []\nassert op_gt5_div3_sortd([]) == []\nassert op_gt5_div3_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_div3_sortd([5, 5, 5]) == []\nassert op_gt5_div3_sortd([3, 1, 2]) == []\nassert op_gt5_div3_sortd([10]) == []\nassert op_gt5_div3_sortd([2, 4, 6]) == [6]\nassert op_gt5_div3_sortd([-7, 12, -7]) == [12]"}
{"id": "op_pos_sortabs_haszero", "entry_point": "op_pos_sortabs_haszero", "primitives": ["pos", "sortabs", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then return whether the list contains a zero.", "solution": "def op_pos_sortabs_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_pos_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_pos_sortabs_haszero([]) == False\nassert op_pos_sortabs_haszero([-2, -1, 0, 1, 2]) == False\nassert op_pos_sortabs_haszero([5, 5, 5]) == False\nassert op_pos_sortabs_haszero([3, 1, 2]) == False\nassert op_pos_sortabs_haszero([10]) == False\nassert op_pos_sortabs_haszero([2, 4, 6]) == False\nassert op_pos_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_odds_sum", "entry_point": "op_takewhilepos_odds_sum", "primitives": ["takewhilepos", "odds", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then return their sum.", "solution": "def op_takewhilepos_odds_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return sum(r)", "tests": "assert op_takewhilepos_odds_sum([1, 2, 3, 4]) == 4\nassert op_takewhilepos_odds_sum([]) == 0\nassert op_takewhilepos_odds_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_odds_sum([5, 5, 5]) == 15\nassert op_takewhilepos_odds_sum([3, 1, 2]) == 4\nassert op_takewhilepos_odds_sum([10]) == 0\nassert op_takewhilepos_odds_sum([2, 4, 6]) == 0\nassert op_takewhilepos_odds_sum([-7, 12, -7]) == 0"}
{"id": "op_ages_dropzeros_min", "entry_point": "op_ages_dropzeros_min", "primitives": ["ages", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_ages_dropzeros_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_ages_dropzeros_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_dropzeros_min([]) == 0\nassert op_ages_dropzeros_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_dropzeros_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_padto3_beforezero_len", "entry_point": "op_padto3_beforezero_len", "primitives": ["padto3", "beforezero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then return how many remain.", "solution": "def op_padto3_beforezero_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r)", "tests": "assert op_padto3_beforezero_len([1, 2, 3, 4]) == 4\nassert op_padto3_beforezero_len([]) == 0\nassert op_padto3_beforezero_len([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_beforezero_len([5, 5, 5]) == 3\nassert op_padto3_beforezero_len([3, 1, 2]) == 3\nassert op_padto3_beforezero_len([10]) == 1\nassert op_padto3_beforezero_len([2, 4, 6]) == 3\nassert op_padto3_beforezero_len([-7, 12, -7]) == 3"}
{"id": "op_oremptyzero_double_neg", "entry_point": "op_oremptyzero_double_neg", "primitives": ["oremptyzero", "double", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then keep the negative numbers.", "solution": "def op_oremptyzero_double_neg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_oremptyzero_double_neg([1, 2, 3, 4]) == []\nassert op_oremptyzero_double_neg([]) == []\nassert op_oremptyzero_double_neg([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_oremptyzero_double_neg([5, 5, 5]) == []\nassert op_oremptyzero_double_neg([3, 1, 2]) == []\nassert op_oremptyzero_double_neg([10]) == []\nassert op_oremptyzero_double_neg([2, 4, 6]) == []\nassert op_oremptyzero_double_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_sortd_add10_odds", "entry_point": "op_sortd_add10_odds", "primitives": ["sortd", "add10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then keep the odd numbers.", "solution": "def op_sortd_add10_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_add10_odds([1, 2, 3, 4]) == [13, 11]\nassert op_sortd_add10_odds([]) == []\nassert op_sortd_add10_odds([-2, -1, 0, 1, 2]) == [11, 9]\nassert op_sortd_add10_odds([5, 5, 5]) == [15, 15, 15]\nassert op_sortd_add10_odds([3, 1, 2]) == [13, 11]\nassert op_sortd_add10_odds([10]) == []\nassert op_sortd_add10_odds([2, 4, 6]) == []\nassert op_sortd_add10_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_uniqs_prefixup_anyempty", "entry_point": "op_uniqs_prefixup_anyempty", "primitives": ["uniqs", "prefixup", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then prefix each with a hash, then return whether any string is empty.", "solution": "def op_uniqs_prefixup_anyempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = ['#' + s for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_uniqs_prefixup_anyempty(['Hello', 'world']) == False\nassert op_uniqs_prefixup_anyempty([]) == False\nassert op_uniqs_prefixup_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_uniqs_prefixup_anyempty(['one', 'one', 'Two']) == False\nassert op_uniqs_prefixup_anyempty(['x']) == False\nassert op_uniqs_prefixup_anyempty(['abc', 'de', '']) == False"}
{"id": "op_pos_odds_len", "entry_point": "op_pos_odds_len", "primitives": ["pos", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then return how many remain.", "solution": "def op_pos_odds_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_pos_odds_len([1, 2, 3, 4]) == 2\nassert op_pos_odds_len([]) == 0\nassert op_pos_odds_len([-2, -1, 0, 1, 2]) == 1\nassert op_pos_odds_len([5, 5, 5]) == 3\nassert op_pos_odds_len([3, 1, 2]) == 2\nassert op_pos_odds_len([10]) == 0\nassert op_pos_odds_len([2, 4, 6]) == 0\nassert op_pos_odds_len([-7, 12, -7]) == 0"}
{"id": "op_negate_first3_neg", "entry_point": "op_negate_first3_neg", "primitives": ["negate", "first3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three, then keep the negative numbers.", "solution": "def op_negate_first3_neg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_negate_first3_neg([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_first3_neg([]) == []\nassert op_negate_first3_neg([-2, -1, 0, 1, 2]) == []\nassert op_negate_first3_neg([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_first3_neg([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_first3_neg([10]) == [-10]\nassert op_negate_first3_neg([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_first3_neg([-7, 12, -7]) == [-12]"}
{"id": "op_first3_padto3_inc", "entry_point": "op_first3_padto3_inc", "primitives": ["first3", "padto3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then add one to each.", "solution": "def op_first3_padto3_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_padto3_inc([1, 2, 3, 4]) == [2, 3, 4]\nassert op_first3_padto3_inc([]) == [1, 1, 1]\nassert op_first3_padto3_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_first3_padto3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_first3_padto3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_first3_padto3_inc([10]) == [11, 1, 1]\nassert op_first3_padto3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_first3_padto3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_neg_pos_prod", "entry_point": "op_neg_pos_prod", "primitives": ["neg", "pos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers, then return their product.", "solution": "def op_neg_pos_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_neg_pos_prod([1, 2, 3, 4]) == 1\nassert op_neg_pos_prod([]) == 1\nassert op_neg_pos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_neg_pos_prod([5, 5, 5]) == 1\nassert op_neg_pos_prod([3, 1, 2]) == 1\nassert op_neg_pos_prod([10]) == 1\nassert op_neg_pos_prod([2, 4, 6]) == 1\nassert op_neg_pos_prod([-7, 12, -7]) == 1"}
{"id": "op_evens_pos_gt5", "entry_point": "op_evens_pos_gt5", "primitives": ["evens", "pos", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers, then keep values greater than five.", "solution": "def op_evens_pos_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_pos_gt5([1, 2, 3, 4]) == []\nassert op_evens_pos_gt5([]) == []\nassert op_evens_pos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_pos_gt5([5, 5, 5]) == []\nassert op_evens_pos_gt5([3, 1, 2]) == []\nassert op_evens_pos_gt5([10]) == [10]\nassert op_evens_pos_gt5([2, 4, 6]) == [6]\nassert op_evens_pos_gt5([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_rev_max", "entry_point": "op_oremptyzero_rev_max", "primitives": ["oremptyzero", "rev", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then return the maximum (0 if empty).", "solution": "def op_oremptyzero_rev_max(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    return max(r) if r else 0", "tests": "assert op_oremptyzero_rev_max([1, 2, 3, 4]) == 4\nassert op_oremptyzero_rev_max([]) == 0\nassert op_oremptyzero_rev_max([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_rev_max([5, 5, 5]) == 5\nassert op_oremptyzero_rev_max([3, 1, 2]) == 3\nassert op_oremptyzero_rev_max([10]) == 10\nassert op_oremptyzero_rev_max([2, 4, 6]) == 6\nassert op_oremptyzero_rev_max([-7, 12, -7]) == 12"}
{"id": "op_square_dropfirst_allpos", "entry_point": "op_square_dropfirst_allpos", "primitives": ["square", "dropfirst", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then return whether all values are positive.", "solution": "def op_square_dropfirst_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_square_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_square_dropfirst_allpos([]) == True\nassert op_square_dropfirst_allpos([-2, -1, 0, 1, 2]) == False\nassert op_square_dropfirst_allpos([5, 5, 5]) == True\nassert op_square_dropfirst_allpos([3, 1, 2]) == True\nassert op_square_dropfirst_allpos([10]) == True\nassert op_square_dropfirst_allpos([2, 4, 6]) == True\nassert op_square_dropfirst_allpos([-7, 12, -7]) == True"}
{"id": "op_div3_neg_sorta", "entry_point": "op_div3_neg_sorta", "primitives": ["div3", "neg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers, then sort ascending.", "solution": "def op_div3_neg_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_neg_sorta([1, 2, 3, 4]) == []\nassert op_div3_neg_sorta([]) == []\nassert op_div3_neg_sorta([-2, -1, 0, 1, 2]) == []\nassert op_div3_neg_sorta([5, 5, 5]) == []\nassert op_div3_neg_sorta([3, 1, 2]) == []\nassert op_div3_neg_sorta([10]) == []\nassert op_div3_neg_sorta([2, 4, 6]) == []\nassert op_div3_neg_sorta([-7, 12, -7]) == []"}
{"id": "op_absval_takewhilepos_odds", "entry_point": "op_absval_takewhilepos_odds", "primitives": ["absval", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then keep the odd numbers.", "solution": "def op_absval_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_takewhilepos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_takewhilepos_odds([]) == []\nassert op_absval_takewhilepos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_absval_takewhilepos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_odds([3, 1, 2]) == [3, 1]\nassert op_absval_takewhilepos_odds([10]) == []\nassert op_absval_takewhilepos_odds([2, 4, 6]) == []\nassert op_absval_takewhilepos_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_trimends_evens_allpos", "entry_point": "op_trimends_evens_allpos", "primitives": ["trimends", "evens", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then return whether all values are positive.", "solution": "def op_trimends_evens_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_evens_allpos([1, 2, 3, 4]) == True\nassert op_trimends_evens_allpos([]) == True\nassert op_trimends_evens_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_evens_allpos([5, 5, 5]) == True\nassert op_trimends_evens_allpos([3, 1, 2]) == True\nassert op_trimends_evens_allpos([10]) == True\nassert op_trimends_evens_allpos([2, 4, 6]) == True\nassert op_trimends_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_gt5_trimends_odds", "entry_point": "op_gt5_trimends_odds", "primitives": ["gt5", "trimends", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then keep the odd numbers.", "solution": "def op_gt5_trimends_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_trimends_odds([1, 2, 3, 4]) == []\nassert op_gt5_trimends_odds([]) == []\nassert op_gt5_trimends_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_odds([5, 5, 5]) == []\nassert op_gt5_trimends_odds([3, 1, 2]) == []\nassert op_gt5_trimends_odds([10]) == []\nassert op_gt5_trimends_odds([2, 4, 6]) == []\nassert op_gt5_trimends_odds([-7, 12, -7]) == []"}
{"id": "op_dropzeros_negate_first3", "entry_point": "op_dropzeros_negate_first3", "primitives": ["dropzeros", "negate", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then keep only the first three.", "solution": "def op_dropzeros_negate_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_negate_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_dropzeros_negate_first3([]) == []\nassert op_dropzeros_negate_first3([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_dropzeros_negate_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_negate_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_dropzeros_negate_first3([10]) == [-10]\nassert op_dropzeros_negate_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_negate_first3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_double_takewhilepos_sortd", "entry_point": "op_double_takewhilepos_sortd", "primitives": ["double", "takewhilepos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then sort descending.", "solution": "def op_double_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_double_takewhilepos_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_takewhilepos_sortd([]) == []\nassert op_double_takewhilepos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_double_takewhilepos_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_double_takewhilepos_sortd([10]) == [20]\nassert op_double_takewhilepos_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_double_takewhilepos_sortd([-7, 12, -7]) == []"}
{"id": "op_first3_gt5_evens", "entry_point": "op_first3_gt5_evens", "primitives": ["first3", "gt5", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then keep the even numbers.", "solution": "def op_first3_gt5_evens(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_first3_gt5_evens([1, 2, 3, 4]) == []\nassert op_first3_gt5_evens([]) == []\nassert op_first3_gt5_evens([-2, -1, 0, 1, 2]) == []\nassert op_first3_gt5_evens([5, 5, 5]) == []\nassert op_first3_gt5_evens([3, 1, 2]) == []\nassert op_first3_gt5_evens([10]) == [10]\nassert op_first3_gt5_evens([2, 4, 6]) == [6]\nassert op_first3_gt5_evens([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_first3_takewhilepos", "entry_point": "op_dropfirst_first3_takewhilepos", "primitives": ["dropfirst", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then take values while they are positive.", "solution": "def op_dropfirst_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_first3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_first3_takewhilepos([]) == []\nassert op_dropfirst_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_first3_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_first3_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_first3_takewhilepos([10]) == []\nassert op_dropfirst_first3_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_first3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_double_uniq_add10", "entry_point": "op_double_uniq_add10", "primitives": ["double", "uniq", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_double_uniq_add10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_double_uniq_add10([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_uniq_add10([]) == []\nassert op_double_uniq_add10([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_double_uniq_add10([5, 5, 5]) == [20]\nassert op_double_uniq_add10([3, 1, 2]) == [16, 12, 14]\nassert op_double_uniq_add10([10]) == [30]\nassert op_double_uniq_add10([2, 4, 6]) == [14, 18, 22]\nassert op_double_uniq_add10([-7, 12, -7]) == [-4, 34]"}
{"id": "op_takewhilepos_sortabs_sorta", "entry_point": "op_takewhilepos_sortabs_sorta", "primitives": ["takewhilepos", "sortabs", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then sort ascending.", "solution": "def op_takewhilepos_sortabs_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_sortabs_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_sortabs_sorta([]) == []\nassert op_takewhilepos_sortabs_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_sortabs_sorta([10]) == [10]\nassert op_takewhilepos_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_sortabs_sorta([-7, 12, -7]) == []"}
{"id": "op_add10_div3_counteven", "entry_point": "op_add10_div3_counteven", "primitives": ["add10", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then return how many values are even.", "solution": "def op_add10_div3_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_div3_counteven([1, 2, 3, 4]) == 1\nassert op_add10_div3_counteven([]) == 0\nassert op_add10_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_add10_div3_counteven([5, 5, 5]) == 0\nassert op_add10_div3_counteven([3, 1, 2]) == 1\nassert op_add10_div3_counteven([10]) == 0\nassert op_add10_div3_counteven([2, 4, 6]) == 1\nassert op_add10_div3_counteven([-7, 12, -7]) == 0"}
{"id": "op_inc_sortd_square", "entry_point": "op_inc_sortd_square", "primitives": ["inc", "sortd", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then square each.", "solution": "def op_inc_sortd_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_sortd_square([1, 2, 3, 4]) == [25, 16, 9, 4]\nassert op_inc_sortd_square([]) == []\nassert op_inc_sortd_square([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_inc_sortd_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_sortd_square([3, 1, 2]) == [16, 9, 4]\nassert op_inc_sortd_square([10]) == [121]\nassert op_inc_sortd_square([2, 4, 6]) == [49, 25, 9]\nassert op_inc_sortd_square([-7, 12, -7]) == [169, 36, 36]"}
{"id": "op_clamp10_add10_square", "entry_point": "op_clamp10_add10_square", "primitives": ["clamp10", "add10", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then square each.", "solution": "def op_clamp10_add10_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_add10_square([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_clamp10_add10_square([]) == []\nassert op_clamp10_add10_square([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_clamp10_add10_square([5, 5, 5]) == [225, 225, 225]\nassert op_clamp10_add10_square([3, 1, 2]) == [169, 121, 144]\nassert op_clamp10_add10_square([10]) == [400]\nassert op_clamp10_add10_square([2, 4, 6]) == [144, 196, 256]\nassert op_clamp10_add10_square([-7, 12, -7]) == [9, 400, 9]"}
{"id": "op_gt5_takewhilepos_dec", "entry_point": "op_gt5_takewhilepos_dec", "primitives": ["gt5", "takewhilepos", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then subtract one from each.", "solution": "def op_gt5_takewhilepos_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_gt5_takewhilepos_dec([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos_dec([]) == []\nassert op_gt5_takewhilepos_dec([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos_dec([5, 5, 5]) == []\nassert op_gt5_takewhilepos_dec([3, 1, 2]) == []\nassert op_gt5_takewhilepos_dec([10]) == [9]\nassert op_gt5_takewhilepos_dec([2, 4, 6]) == [5]\nassert op_gt5_takewhilepos_dec([-7, 12, -7]) == [11]"}
{"id": "op_add10_gt5_beforezero", "entry_point": "op_add10_gt5_beforezero", "primitives": ["add10", "gt5", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_add10_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_add10_gt5_beforezero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_gt5_beforezero([]) == []\nassert op_add10_gt5_beforezero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_gt5_beforezero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5_beforezero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5_beforezero([10]) == [20]\nassert op_add10_gt5_beforezero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5_beforezero([-7, 12, -7]) == [22]"}
{"id": "op_takewhilepos_dec_counteven", "entry_point": "op_takewhilepos_dec_counteven", "primitives": ["takewhilepos", "dec", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then return how many values are even.", "solution": "def op_takewhilepos_dec_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_dec_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_dec_counteven([]) == 0\nassert op_takewhilepos_dec_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dec_counteven([5, 5, 5]) == 3\nassert op_takewhilepos_dec_counteven([3, 1, 2]) == 2\nassert op_takewhilepos_dec_counteven([10]) == 0\nassert op_takewhilepos_dec_counteven([2, 4, 6]) == 0\nassert op_takewhilepos_dec_counteven([-7, 12, -7]) == 0"}
{"id": "op_sorta_dec_allpos", "entry_point": "op_sorta_dec_allpos", "primitives": ["sorta", "dec", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then return whether all values are positive.", "solution": "def op_sorta_dec_allpos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_sorta_dec_allpos([1, 2, 3, 4]) == False\nassert op_sorta_dec_allpos([]) == True\nassert op_sorta_dec_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sorta_dec_allpos([5, 5, 5]) == True\nassert op_sorta_dec_allpos([3, 1, 2]) == False\nassert op_sorta_dec_allpos([10]) == True\nassert op_sorta_dec_allpos([2, 4, 6]) == True\nassert op_sorta_dec_allpos([-7, 12, -7]) == False"}
{"id": "op_clamp10_sorta_gt5", "entry_point": "op_clamp10_sorta_gt5", "primitives": ["clamp10", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then keep values greater than five.", "solution": "def op_clamp10_sorta_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_sorta_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_sorta_gt5([]) == []\nassert op_clamp10_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_sorta_gt5([5, 5, 5]) == []\nassert op_clamp10_sorta_gt5([3, 1, 2]) == []\nassert op_clamp10_sorta_gt5([10]) == [10]\nassert op_clamp10_sorta_gt5([2, 4, 6]) == [6]\nassert op_clamp10_sorta_gt5([-7, 12, -7]) == [10]"}
{"id": "op_sortabs_first3_dropzeros", "entry_point": "op_sortabs_first3_dropzeros", "primitives": ["sortabs", "first3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then drop the zeros.", "solution": "def op_sortabs_first3_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_first3_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_first3_dropzeros([]) == []\nassert op_sortabs_first3_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sortabs_first3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_first3_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_first3_dropzeros([10]) == [10]\nassert op_sortabs_first3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_first3_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_trimends_square_padto3", "entry_point": "op_trimends_square_padto3", "primitives": ["trimends", "square", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then pad with zeros to at least three elements.", "solution": "def op_trimends_square_padto3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_trimends_square_padto3([1, 2, 3, 4]) == [4, 9, 0]\nassert op_trimends_square_padto3([]) == [0, 0, 0]\nassert op_trimends_square_padto3([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_square_padto3([5, 5, 5]) == [25, 0, 0]\nassert op_trimends_square_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_square_padto3([10]) == [0, 0, 0]\nassert op_trimends_square_padto3([2, 4, 6]) == [16, 0, 0]\nassert op_trimends_square_padto3([-7, 12, -7]) == [144, 0, 0]"}
{"id": "op_dropwhileneg_trimends_beforezero", "entry_point": "op_dropwhileneg_trimends_beforezero", "primitives": ["dropwhileneg", "trimends", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_dropwhileneg_trimends_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_trimends_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_dropwhileneg_trimends_beforezero([]) == []\nassert op_dropwhileneg_trimends_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_beforezero([5, 5, 5]) == [5]\nassert op_dropwhileneg_trimends_beforezero([3, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_beforezero([10]) == []\nassert op_dropwhileneg_trimends_beforezero([2, 4, 6]) == [4]\nassert op_dropwhileneg_trimends_beforezero([-7, 12, -7]) == []"}
{"id": "op_rev_absval_sorta", "entry_point": "op_rev_absval_sorta", "primitives": ["rev", "absval", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then sort ascending.", "solution": "def op_rev_absval_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_rev_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_absval_sorta([]) == []\nassert op_rev_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_rev_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_rev_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_rev_absval_sorta([10]) == [10]\nassert op_rev_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_rev_absval_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_oremptyzero_square_sortabs", "entry_point": "op_oremptyzero_square_sortabs", "primitives": ["oremptyzero", "square", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then sort by absolute value.", "solution": "def op_oremptyzero_square_sortabs(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_oremptyzero_square_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_oremptyzero_square_sortabs([]) == [0]\nassert op_oremptyzero_square_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_oremptyzero_square_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_square_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_oremptyzero_square_sortabs([10]) == [100]\nassert op_oremptyzero_square_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_square_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_padto3_square_sortabs", "entry_point": "op_padto3_square_sortabs", "primitives": ["padto3", "square", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then sort by absolute value.", "solution": "def op_padto3_square_sortabs(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_padto3_square_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_padto3_square_sortabs([]) == [0, 0, 0]\nassert op_padto3_square_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_padto3_square_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_square_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_padto3_square_sortabs([10]) == [0, 0, 100]\nassert op_padto3_square_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_square_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_padto3_gt5_neg", "entry_point": "op_padto3_gt5_neg", "primitives": ["padto3", "gt5", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then keep the negative numbers.", "solution": "def op_padto3_gt5_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_gt5_neg([1, 2, 3, 4]) == []\nassert op_padto3_gt5_neg([]) == []\nassert op_padto3_gt5_neg([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5_neg([5, 5, 5]) == []\nassert op_padto3_gt5_neg([3, 1, 2]) == []\nassert op_padto3_gt5_neg([10]) == []\nassert op_padto3_gt5_neg([2, 4, 6]) == []\nassert op_padto3_gt5_neg([-7, 12, -7]) == []"}
{"id": "op_rev_trimends_firsteven", "entry_point": "op_rev_trimends_firsteven", "primitives": ["rev", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_rev_trimends_firsteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_rev_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_rev_trimends_firsteven([]) == 0\nassert op_rev_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_rev_trimends_firsteven([5, 5, 5]) == 0\nassert op_rev_trimends_firsteven([3, 1, 2]) == 0\nassert op_rev_trimends_firsteven([10]) == 0\nassert op_rev_trimends_firsteven([2, 4, 6]) == 4\nassert op_rev_trimends_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_sortd_dropzeros", "entry_point": "op_evens_sortd_dropzeros", "primitives": ["evens", "sortd", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then drop the zeros.", "solution": "def op_evens_sortd_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_evens_sortd_dropzeros([1, 2, 3, 4]) == [4, 2]\nassert op_evens_sortd_dropzeros([]) == []\nassert op_evens_sortd_dropzeros([-2, -1, 0, 1, 2]) == [2, -2]\nassert op_evens_sortd_dropzeros([5, 5, 5]) == []\nassert op_evens_sortd_dropzeros([3, 1, 2]) == [2]\nassert op_evens_sortd_dropzeros([10]) == [10]\nassert op_evens_sortd_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_evens_sortd_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_sortd_padto3_allpos", "entry_point": "op_sortd_padto3_allpos", "primitives": ["sortd", "padto3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then return whether all values are positive.", "solution": "def op_sortd_padto3_allpos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return all(x > 0 for x in r)", "tests": "assert op_sortd_padto3_allpos([1, 2, 3, 4]) == True\nassert op_sortd_padto3_allpos([]) == False\nassert op_sortd_padto3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortd_padto3_allpos([5, 5, 5]) == True\nassert op_sortd_padto3_allpos([3, 1, 2]) == True\nassert op_sortd_padto3_allpos([10]) == False\nassert op_sortd_padto3_allpos([2, 4, 6]) == True\nassert op_sortd_padto3_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_sortabs_pos", "entry_point": "op_last3_sortabs_pos", "primitives": ["last3", "sortabs", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then keep the positive numbers.", "solution": "def op_last3_sortabs_pos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_last3_sortabs_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortabs_pos([]) == []\nassert op_last3_sortabs_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortabs_pos([10]) == [10]\nassert op_last3_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortabs_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropshort_upper_firstchar", "entry_point": "op_dropshort_upper_firstchar", "primitives": ["dropshort", "upper", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string, then keep the first character of each (dropping empties).", "solution": "def op_dropshort_upper_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_dropshort_upper_firstchar(['Hello', 'world']) == ['H', 'W']\nassert op_dropshort_upper_firstchar([]) == []\nassert op_dropshort_upper_firstchar(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_dropshort_upper_firstchar(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_dropshort_upper_firstchar(['x']) == []\nassert op_dropshort_upper_firstchar(['abc', 'de', '']) == ['A']"}
{"id": "op_ages_padto3_min", "entry_point": "op_ages_padto3_min", "primitives": ["ages", "padto3", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_ages_padto3_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_ages_padto3_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_padto3_min([]) == 0\nassert op_ages_padto3_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_padto3_min([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_dropfirst_neg_uniq", "entry_point": "op_dropfirst_neg_uniq", "primitives": ["dropfirst", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_neg_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_neg_uniq([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_uniq([]) == []\nassert op_dropfirst_neg_uniq([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg_uniq([5, 5, 5]) == []\nassert op_dropfirst_neg_uniq([3, 1, 2]) == []\nassert op_dropfirst_neg_uniq([10]) == []\nassert op_dropfirst_neg_uniq([2, 4, 6]) == []\nassert op_dropfirst_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_dec_pos_haszero", "entry_point": "op_dec_pos_haszero", "primitives": ["dec", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_dec_pos_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_dec_pos_haszero([1, 2, 3, 4]) == False\nassert op_dec_pos_haszero([]) == False\nassert op_dec_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dec_pos_haszero([5, 5, 5]) == False\nassert op_dec_pos_haszero([3, 1, 2]) == False\nassert op_dec_pos_haszero([10]) == False\nassert op_dec_pos_haszero([2, 4, 6]) == False\nassert op_dec_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_negate_dropfirst_first3", "entry_point": "op_negate_dropfirst_first3", "primitives": ["negate", "dropfirst", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then keep only the first three.", "solution": "def op_negate_dropfirst_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = r[:3]\n    return r", "tests": "assert op_negate_dropfirst_first3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_dropfirst_first3([]) == []\nassert op_negate_dropfirst_first3([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_negate_dropfirst_first3([5, 5, 5]) == [-5, -5]\nassert op_negate_dropfirst_first3([3, 1, 2]) == [-1, -2]\nassert op_negate_dropfirst_first3([10]) == []\nassert op_negate_dropfirst_first3([2, 4, 6]) == [-4, -6]\nassert op_negate_dropfirst_first3([-7, 12, -7]) == [-12, 7]"}
{"id": "op_inc_last3_dec", "entry_point": "op_inc_last3_dec", "primitives": ["inc", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then subtract one from each.", "solution": "def op_inc_last3_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_last3_dec([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_last3_dec([]) == []\nassert op_inc_last3_dec([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_last3_dec([5, 5, 5]) == [5, 5, 5]\nassert op_inc_last3_dec([3, 1, 2]) == [3, 1, 2]\nassert op_inc_last3_dec([10]) == [10]\nassert op_inc_last3_dec([2, 4, 6]) == [2, 4, 6]\nassert op_inc_last3_dec([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_div3_double_pos", "entry_point": "op_div3_double_pos", "primitives": ["div3", "double", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then keep the positive numbers.", "solution": "def op_div3_double_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_div3_double_pos([1, 2, 3, 4]) == [6]\nassert op_div3_double_pos([]) == []\nassert op_div3_double_pos([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_pos([5, 5, 5]) == []\nassert op_div3_double_pos([3, 1, 2]) == [6]\nassert op_div3_double_pos([10]) == []\nassert op_div3_double_pos([2, 4, 6]) == [12]\nassert op_div3_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_div3_evens_beforezero", "entry_point": "op_div3_evens_beforezero", "primitives": ["div3", "evens", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_div3_evens_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_evens_beforezero([1, 2, 3, 4]) == []\nassert op_div3_evens_beforezero([]) == []\nassert op_div3_evens_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_evens_beforezero([5, 5, 5]) == []\nassert op_div3_evens_beforezero([3, 1, 2]) == []\nassert op_div3_evens_beforezero([10]) == []\nassert op_div3_evens_beforezero([2, 4, 6]) == [6]\nassert op_div3_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_div3_last3_takewhilepos", "entry_point": "op_div3_last3_takewhilepos", "primitives": ["div3", "last3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then take values while they are positive.", "solution": "def op_div3_last3_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_last3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_div3_last3_takewhilepos([]) == []\nassert op_div3_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_last3_takewhilepos([5, 5, 5]) == []\nassert op_div3_last3_takewhilepos([3, 1, 2]) == [3]\nassert op_div3_last3_takewhilepos([10]) == []\nassert op_div3_last3_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_last3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_dropfirst_dec", "entry_point": "op_dropzeros_dropfirst_dec", "primitives": ["dropzeros", "dropfirst", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then subtract one from each.", "solution": "def op_dropzeros_dropfirst_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropzeros_dropfirst_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_dropfirst_dec([]) == []\nassert op_dropzeros_dropfirst_dec([-2, -1, 0, 1, 2]) == [-2, 0, 1]\nassert op_dropzeros_dropfirst_dec([5, 5, 5]) == [4, 4]\nassert op_dropzeros_dropfirst_dec([3, 1, 2]) == [0, 1]\nassert op_dropzeros_dropfirst_dec([10]) == []\nassert op_dropzeros_dropfirst_dec([2, 4, 6]) == [3, 5]\nassert op_dropzeros_dropfirst_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_last3_sorta_padto3", "entry_point": "op_last3_sorta_padto3", "primitives": ["last3", "sorta", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then pad with zeros to at least three elements.", "solution": "def op_last3_sorta_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_sorta_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sorta_padto3([]) == [0, 0, 0]\nassert op_last3_sorta_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sorta_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sorta_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sorta_padto3([10]) == [10, 0, 0]\nassert op_last3_sorta_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sorta_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_odds_takewhilepos_issorted", "entry_point": "op_odds_takewhilepos_issorted", "primitives": ["odds", "takewhilepos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_odds_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_odds_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_odds_takewhilepos_issorted([]) == True\nassert op_odds_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_takewhilepos_issorted([5, 5, 5]) == True\nassert op_odds_takewhilepos_issorted([3, 1, 2]) == False\nassert op_odds_takewhilepos_issorted([10]) == True\nassert op_odds_takewhilepos_issorted([2, 4, 6]) == True\nassert op_odds_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_trimends_sortd_beforezero", "entry_point": "op_trimends_sortd_beforezero", "primitives": ["trimends", "sortd", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending, then keep everything before the first zero.", "solution": "def op_trimends_sortd_beforezero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_trimends_sortd_beforezero([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_sortd_beforezero([]) == []\nassert op_trimends_sortd_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_sortd_beforezero([5, 5, 5]) == [5]\nassert op_trimends_sortd_beforezero([3, 1, 2]) == [1]\nassert op_trimends_sortd_beforezero([10]) == []\nassert op_trimends_sortd_beforezero([2, 4, 6]) == [4]\nassert op_trimends_sortd_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_inc_sortabs_max", "entry_point": "op_inc_sortabs_max", "primitives": ["inc", "sortabs", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_inc_sortabs_max(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_inc_sortabs_max([1, 2, 3, 4]) == 5\nassert op_inc_sortabs_max([]) == 0\nassert op_inc_sortabs_max([-2, -1, 0, 1, 2]) == 3\nassert op_inc_sortabs_max([5, 5, 5]) == 6\nassert op_inc_sortabs_max([3, 1, 2]) == 4\nassert op_inc_sortabs_max([10]) == 11\nassert op_inc_sortabs_max([2, 4, 6]) == 7\nassert op_inc_sortabs_max([-7, 12, -7]) == 13"}
{"id": "op_dropwhileneg_sortabs_sortd", "entry_point": "op_dropwhileneg_sortabs_sortd", "primitives": ["dropwhileneg", "sortabs", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then sort descending.", "solution": "def op_dropwhileneg_sortabs_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_sortabs_sortd([]) == []\nassert op_dropwhileneg_sortabs_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_sortabs_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sortabs_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropwhileneg_sortabs_sortd([10]) == [10]\nassert op_dropwhileneg_sortabs_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_sortabs_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_dec_inc_allpos", "entry_point": "op_dec_inc_allpos", "primitives": ["dec", "inc", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then return whether all values are positive.", "solution": "def op_dec_inc_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_inc_allpos([1, 2, 3, 4]) == True\nassert op_dec_inc_allpos([]) == True\nassert op_dec_inc_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_inc_allpos([5, 5, 5]) == True\nassert op_dec_inc_allpos([3, 1, 2]) == True\nassert op_dec_inc_allpos([10]) == True\nassert op_dec_inc_allpos([2, 4, 6]) == True\nassert op_dec_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_neg_div3_uniq", "entry_point": "op_neg_div3_uniq", "primitives": ["neg", "div3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three, then drop duplicates keeping first occurrence.", "solution": "def op_neg_div3_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_neg_div3_uniq([1, 2, 3, 4]) == []\nassert op_neg_div3_uniq([]) == []\nassert op_neg_div3_uniq([-2, -1, 0, 1, 2]) == []\nassert op_neg_div3_uniq([5, 5, 5]) == []\nassert op_neg_div3_uniq([3, 1, 2]) == []\nassert op_neg_div3_uniq([10]) == []\nassert op_neg_div3_uniq([2, 4, 6]) == []\nassert op_neg_div3_uniq([-7, 12, -7]) == []"}
{"id": "op_lower_sortalpha_dropshort", "entry_point": "op_lower_sortalpha_dropshort", "primitives": ["lower", "sortalpha", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort alphabetically, then drop strings shorter than three characters.", "solution": "def op_lower_sortalpha_dropshort(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_lower_sortalpha_dropshort(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortalpha_dropshort([]) == []\nassert op_lower_sortalpha_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_lower_sortalpha_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_sortalpha_dropshort(['x']) == []\nassert op_lower_sortalpha_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_double_pos_evens", "entry_point": "op_double_pos_evens", "primitives": ["double", "pos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then keep the even numbers.", "solution": "def op_double_pos_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_pos_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_pos_evens([]) == []\nassert op_double_pos_evens([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_pos_evens([5, 5, 5]) == [10, 10, 10]\nassert op_double_pos_evens([3, 1, 2]) == [6, 2, 4]\nassert op_double_pos_evens([10]) == [20]\nassert op_double_pos_evens([2, 4, 6]) == [4, 8, 12]\nassert op_double_pos_evens([-7, 12, -7]) == [24]"}
{"id": "op_odds_dec_negate", "entry_point": "op_odds_dec_negate", "primitives": ["odds", "dec", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each, then negate each.", "solution": "def op_odds_dec_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_dec_negate([1, 2, 3, 4]) == [0, -2]\nassert op_odds_dec_negate([]) == []\nassert op_odds_dec_negate([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_odds_dec_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_odds_dec_negate([3, 1, 2]) == [-2, 0]\nassert op_odds_dec_negate([10]) == []\nassert op_odds_dec_negate([2, 4, 6]) == []\nassert op_odds_dec_negate([-7, 12, -7]) == [8, 8]"}
{"id": "op_double_clamp10_pos", "entry_point": "op_double_clamp10_pos", "primitives": ["double", "clamp10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10, then keep the positive numbers.", "solution": "def op_double_clamp10_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_clamp10_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_clamp10_pos([]) == []\nassert op_double_clamp10_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_clamp10_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_clamp10_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_clamp10_pos([10]) == [10]\nassert op_double_clamp10_pos([2, 4, 6]) == [4, 8, 10]\nassert op_double_clamp10_pos([-7, 12, -7]) == [10]"}
{"id": "op_uniq_square_add10", "entry_point": "op_uniq_square_add10", "primitives": ["uniq", "square", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then add ten to each.", "solution": "def op_uniq_square_add10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_uniq_square_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_uniq_square_add10([]) == []\nassert op_uniq_square_add10([-2, -1, 0, 1, 2]) == [14, 11, 10, 11, 14]\nassert op_uniq_square_add10([5, 5, 5]) == [35]\nassert op_uniq_square_add10([3, 1, 2]) == [19, 11, 14]\nassert op_uniq_square_add10([10]) == [110]\nassert op_uniq_square_add10([2, 4, 6]) == [14, 26, 46]\nassert op_uniq_square_add10([-7, 12, -7]) == [59, 154]"}
{"id": "op_dropfirst_square_issorted", "entry_point": "op_dropfirst_square_issorted", "primitives": ["dropfirst", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_square_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_dropfirst_square_issorted([1, 2, 3, 4]) == True\nassert op_dropfirst_square_issorted([]) == True\nassert op_dropfirst_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_square_issorted([5, 5, 5]) == True\nassert op_dropfirst_square_issorted([3, 1, 2]) == True\nassert op_dropfirst_square_issorted([10]) == True\nassert op_dropfirst_square_issorted([2, 4, 6]) == True\nassert op_dropfirst_square_issorted([-7, 12, -7]) == False"}
{"id": "op_inc_uniq_gt5", "entry_point": "op_inc_uniq_gt5", "primitives": ["inc", "uniq", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_inc_uniq_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_uniq_gt5([1, 2, 3, 4]) == []\nassert op_inc_uniq_gt5([]) == []\nassert op_inc_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_uniq_gt5([5, 5, 5]) == [6]\nassert op_inc_uniq_gt5([3, 1, 2]) == []\nassert op_inc_uniq_gt5([10]) == [11]\nassert op_inc_uniq_gt5([2, 4, 6]) == [7]\nassert op_inc_uniq_gt5([-7, 12, -7]) == [13]"}
{"id": "op_sorta_inc_max", "entry_point": "op_sorta_inc_max", "primitives": ["sorta", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then return the maximum (0 if empty).", "solution": "def op_sorta_inc_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_sorta_inc_max([1, 2, 3, 4]) == 5\nassert op_sorta_inc_max([]) == 0\nassert op_sorta_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_inc_max([5, 5, 5]) == 6\nassert op_sorta_inc_max([3, 1, 2]) == 4\nassert op_sorta_inc_max([10]) == 11\nassert op_sorta_inc_max([2, 4, 6]) == 7\nassert op_sorta_inc_max([-7, 12, -7]) == 13"}
{"id": "op_oremptyzero_pos_inc", "entry_point": "op_oremptyzero_pos_inc", "primitives": ["oremptyzero", "pos", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then add one to each.", "solution": "def op_oremptyzero_pos_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_pos_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_oremptyzero_pos_inc([]) == []\nassert op_oremptyzero_pos_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_oremptyzero_pos_inc([5, 5, 5]) == [6, 6, 6]\nassert op_oremptyzero_pos_inc([3, 1, 2]) == [4, 2, 3]\nassert op_oremptyzero_pos_inc([10]) == [11]\nassert op_oremptyzero_pos_inc([2, 4, 6]) == [3, 5, 7]\nassert op_oremptyzero_pos_inc([-7, 12, -7]) == [13]"}
{"id": "op_absval_evens_takewhilepos", "entry_point": "op_absval_evens_takewhilepos", "primitives": ["absval", "evens", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then take values while they are positive.", "solution": "def op_absval_evens_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_absval_evens_takewhilepos([]) == []\nassert op_absval_evens_takewhilepos([-2, -1, 0, 1, 2]) == [2]\nassert op_absval_evens_takewhilepos([5, 5, 5]) == []\nassert op_absval_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_absval_evens_takewhilepos([10]) == [10]\nassert op_absval_evens_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_square_uniq", "entry_point": "op_dropwhileneg_square_uniq", "primitives": ["dropwhileneg", "square", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then drop duplicates keeping first occurrence.", "solution": "def op_dropwhileneg_square_uniq(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropwhileneg_square_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropwhileneg_square_uniq([]) == []\nassert op_dropwhileneg_square_uniq([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropwhileneg_square_uniq([5, 5, 5]) == [25]\nassert op_dropwhileneg_square_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_square_uniq([10]) == [100]\nassert op_dropwhileneg_square_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_square_uniq([-7, 12, -7]) == [144, 49]"}
{"id": "op_dropzeros_dropwhileneg_pos", "entry_point": "op_dropzeros_dropwhileneg_pos", "primitives": ["dropzeros", "dropwhileneg", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_dropzeros_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_dropwhileneg_pos([]) == []\nassert op_dropzeros_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_dropwhileneg_pos([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_dropwhileneg_pos([10]) == [10]\nassert op_dropzeros_dropwhileneg_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_dropwhileneg_pos([-7, 12, -7]) == [12]"}
{"id": "op_padto3_sortabs_clamp10", "entry_point": "op_padto3_sortabs_clamp10", "primitives": ["padto3", "sortabs", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then cap each value at 10.", "solution": "def op_padto3_sortabs_clamp10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_padto3_sortabs_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sortabs_clamp10([]) == [0, 0, 0]\nassert op_padto3_sortabs_clamp10([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_padto3_sortabs_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortabs_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sortabs_clamp10([10]) == [0, 0, 10]\nassert op_padto3_sortabs_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sortabs_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_sortabs_pos_sorta", "entry_point": "op_sortabs_pos_sorta", "primitives": ["sortabs", "pos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then sort ascending.", "solution": "def op_sortabs_pos_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_pos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_pos_sorta([]) == []\nassert op_sortabs_pos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_pos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_pos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_pos_sorta([10]) == [10]\nassert op_sortabs_pos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_pos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_ages_takewhilepos_pos", "entry_point": "op_ages_takewhilepos_pos", "primitives": ["ages", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then keep the positive numbers.", "solution": "def op_ages_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_takewhilepos_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos_pos([]) == []\nassert op_ages_takewhilepos_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_pos_dropfirst_len", "entry_point": "op_pos_dropfirst_len", "primitives": ["pos", "dropfirst", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first element, then return how many remain.", "solution": "def op_pos_dropfirst_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return len(r)", "tests": "assert op_pos_dropfirst_len([1, 2, 3, 4]) == 3\nassert op_pos_dropfirst_len([]) == 0\nassert op_pos_dropfirst_len([-2, -1, 0, 1, 2]) == 1\nassert op_pos_dropfirst_len([5, 5, 5]) == 2\nassert op_pos_dropfirst_len([3, 1, 2]) == 2\nassert op_pos_dropfirst_len([10]) == 0\nassert op_pos_dropfirst_len([2, 4, 6]) == 2\nassert op_pos_dropfirst_len([-7, 12, -7]) == 0"}
{"id": "op_neg_dropfirst_sorta", "entry_point": "op_neg_dropfirst_sorta", "primitives": ["neg", "dropfirst", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then sort ascending.", "solution": "def op_neg_dropfirst_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    r = sorted(r)\n    return r", "tests": "assert op_neg_dropfirst_sorta([1, 2, 3, 4]) == []\nassert op_neg_dropfirst_sorta([]) == []\nassert op_neg_dropfirst_sorta([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_dropfirst_sorta([5, 5, 5]) == []\nassert op_neg_dropfirst_sorta([3, 1, 2]) == []\nassert op_neg_dropfirst_sorta([10]) == []\nassert op_neg_dropfirst_sorta([2, 4, 6]) == []\nassert op_neg_dropfirst_sorta([-7, 12, -7]) == [-7]"}
{"id": "op_dec_trimends_firsteven", "entry_point": "op_dec_trimends_firsteven", "primitives": ["dec", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_dec_trimends_firsteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dec_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_dec_trimends_firsteven([]) == 0\nassert op_dec_trimends_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dec_trimends_firsteven([5, 5, 5]) == 4\nassert op_dec_trimends_firsteven([3, 1, 2]) == 0\nassert op_dec_trimends_firsteven([10]) == 0\nassert op_dec_trimends_firsteven([2, 4, 6]) == 0\nassert op_dec_trimends_firsteven([-7, 12, -7]) == 0"}
{"id": "op_sorta_odds_issorted", "entry_point": "op_sorta_odds_issorted", "primitives": ["sorta", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_sorta_odds_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_sorta_odds_issorted([1, 2, 3, 4]) == True\nassert op_sorta_odds_issorted([]) == True\nassert op_sorta_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_odds_issorted([5, 5, 5]) == True\nassert op_sorta_odds_issorted([3, 1, 2]) == True\nassert op_sorta_odds_issorted([10]) == True\nassert op_sorta_odds_issorted([2, 4, 6]) == True\nassert op_sorta_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_div3_dropwhileneg_haszero", "entry_point": "op_div3_dropwhileneg_haszero", "primitives": ["div3", "dropwhileneg", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_div3_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_div3_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_div3_dropwhileneg_haszero([]) == False\nassert op_div3_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_div3_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_div3_dropwhileneg_haszero([10]) == False\nassert op_div3_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_div3_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_beforezero_add10", "entry_point": "op_dropfirst_beforezero_add10", "primitives": ["dropfirst", "beforezero", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then add ten to each.", "solution": "def op_dropfirst_beforezero_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_beforezero_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_beforezero_add10([]) == []\nassert op_dropfirst_beforezero_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_dropfirst_beforezero_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_beforezero_add10([3, 1, 2]) == [11, 12]\nassert op_dropfirst_beforezero_add10([10]) == []\nassert op_dropfirst_beforezero_add10([2, 4, 6]) == [14, 16]\nassert op_dropfirst_beforezero_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_dec_dropzeros_absval", "entry_point": "op_dec_dropzeros_absval", "primitives": ["dec", "dropzeros", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then take the absolute value of each.", "solution": "def op_dec_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_dropzeros_absval([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropzeros_absval([]) == []\nassert op_dec_dropzeros_absval([-2, -1, 0, 1, 2]) == [3, 2, 1, 1]\nassert op_dec_dropzeros_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropzeros_absval([3, 1, 2]) == [2, 1]\nassert op_dec_dropzeros_absval([10]) == [9]\nassert op_dec_dropzeros_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropzeros_absval([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_dropwhileneg_gt5_rev", "entry_point": "op_dropwhileneg_gt5_rev", "primitives": ["dropwhileneg", "gt5", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then reverse the order.", "solution": "def op_dropwhileneg_gt5_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_gt5_rev([1, 2, 3, 4]) == []\nassert op_dropwhileneg_gt5_rev([]) == []\nassert op_dropwhileneg_gt5_rev([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_gt5_rev([5, 5, 5]) == []\nassert op_dropwhileneg_gt5_rev([3, 1, 2]) == []\nassert op_dropwhileneg_gt5_rev([10]) == [10]\nassert op_dropwhileneg_gt5_rev([2, 4, 6]) == [6]\nassert op_dropwhileneg_gt5_rev([-7, 12, -7]) == [12]"}
{"id": "op_pos_square_takewhilepos", "entry_point": "op_pos_square_takewhilepos", "primitives": ["pos", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then take values while they are positive.", "solution": "def op_pos_square_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_pos_square_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_square_takewhilepos([]) == []\nassert op_pos_square_takewhilepos([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_square_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_pos_square_takewhilepos([3, 1, 2]) == [9, 1, 4]\nassert op_pos_square_takewhilepos([10]) == [100]\nassert op_pos_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_pos_square_takewhilepos([-7, 12, -7]) == [144]"}
{"id": "op_sortabs_negate_haszero", "entry_point": "op_sortabs_negate_haszero", "primitives": ["sortabs", "negate", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then negate each, then return whether the list contains a zero.", "solution": "def op_sortabs_negate_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return 0 in r", "tests": "assert op_sortabs_negate_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_negate_haszero([]) == False\nassert op_sortabs_negate_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_negate_haszero([5, 5, 5]) == False\nassert op_sortabs_negate_haszero([3, 1, 2]) == False\nassert op_sortabs_negate_haszero([10]) == False\nassert op_sortabs_negate_haszero([2, 4, 6]) == False\nassert op_sortabs_negate_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_sorta_odds", "entry_point": "op_sortd_sorta_odds", "primitives": ["sortd", "sorta", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then keep the odd numbers.", "solution": "def op_sortd_sorta_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_sorta_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sortd_sorta_odds([]) == []\nassert op_sortd_sorta_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sortd_sorta_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sorta_odds([3, 1, 2]) == [1, 3]\nassert op_sortd_sorta_odds([10]) == []\nassert op_sortd_sorta_odds([2, 4, 6]) == []\nassert op_sortd_sorta_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_beforezero_dropzeros", "entry_point": "op_pos_beforezero_dropzeros", "primitives": ["pos", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then drop the zeros.", "solution": "def op_pos_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_beforezero_dropzeros([]) == []\nassert op_pos_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_beforezero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_beforezero_dropzeros([10]) == [10]\nassert op_pos_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_beforezero_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_padto3_trimends_dropfirst", "entry_point": "op_padto3_trimends_dropfirst", "primitives": ["padto3", "trimends", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then drop the first element.", "solution": "def op_padto3_trimends_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_trimends_dropfirst([1, 2, 3, 4]) == [3]\nassert op_padto3_trimends_dropfirst([]) == []\nassert op_padto3_trimends_dropfirst([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_padto3_trimends_dropfirst([5, 5, 5]) == []\nassert op_padto3_trimends_dropfirst([3, 1, 2]) == []\nassert op_padto3_trimends_dropfirst([10]) == []\nassert op_padto3_trimends_dropfirst([2, 4, 6]) == []\nassert op_padto3_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_pos_uniq_allpos", "entry_point": "op_pos_uniq_allpos", "primitives": ["pos", "uniq", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_pos_uniq_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_pos_uniq_allpos([1, 2, 3, 4]) == True\nassert op_pos_uniq_allpos([]) == True\nassert op_pos_uniq_allpos([-2, -1, 0, 1, 2]) == True\nassert op_pos_uniq_allpos([5, 5, 5]) == True\nassert op_pos_uniq_allpos([3, 1, 2]) == True\nassert op_pos_uniq_allpos([10]) == True\nassert op_pos_uniq_allpos([2, 4, 6]) == True\nassert op_pos_uniq_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_double_counteven", "entry_point": "op_oremptyzero_double_counteven", "primitives": ["oremptyzero", "double", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then return how many values are even.", "solution": "def op_oremptyzero_double_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_double_counteven([1, 2, 3, 4]) == 4\nassert op_oremptyzero_double_counteven([]) == 1\nassert op_oremptyzero_double_counteven([-2, -1, 0, 1, 2]) == 5\nassert op_oremptyzero_double_counteven([5, 5, 5]) == 3\nassert op_oremptyzero_double_counteven([3, 1, 2]) == 3\nassert op_oremptyzero_double_counteven([10]) == 1\nassert op_oremptyzero_double_counteven([2, 4, 6]) == 3\nassert op_oremptyzero_double_counteven([-7, 12, -7]) == 3"}
{"id": "op_firstchar_sortalpha_nonempty", "entry_point": "op_firstchar_sortalpha_nonempty", "primitives": ["firstchar", "sortalpha", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then drop empty strings.", "solution": "def op_firstchar_sortalpha_nonempty(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_firstchar_sortalpha_nonempty(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_sortalpha_nonempty([]) == []\nassert op_firstchar_sortalpha_nonempty(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_sortalpha_nonempty(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_firstchar_sortalpha_nonempty(['x']) == ['x']\nassert op_firstchar_sortalpha_nonempty(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortd_padto3_first3", "entry_point": "op_sortd_padto3_first3", "primitives": ["sortd", "padto3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then keep only the first three.", "solution": "def op_sortd_padto3_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return r", "tests": "assert op_sortd_padto3_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortd_padto3_first3([]) == [0, 0, 0]\nassert op_sortd_padto3_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_sortd_padto3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_padto3_first3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_padto3_first3([10]) == [10, 0, 0]\nassert op_sortd_padto3_first3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_padto3_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_add10_oremptyzero_max", "entry_point": "op_add10_oremptyzero_max", "primitives": ["add10", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_add10_oremptyzero_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_add10_oremptyzero_max([1, 2, 3, 4]) == 14\nassert op_add10_oremptyzero_max([]) == 0\nassert op_add10_oremptyzero_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_oremptyzero_max([5, 5, 5]) == 15\nassert op_add10_oremptyzero_max([3, 1, 2]) == 13\nassert op_add10_oremptyzero_max([10]) == 20\nassert op_add10_oremptyzero_max([2, 4, 6]) == 16\nassert op_add10_oremptyzero_max([-7, 12, -7]) == 22"}
{"id": "op_oremptyzero_dec_haszero", "entry_point": "op_oremptyzero_dec_haszero", "primitives": ["oremptyzero", "dec", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_oremptyzero_dec_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_oremptyzero_dec_haszero([1, 2, 3, 4]) == True\nassert op_oremptyzero_dec_haszero([]) == False\nassert op_oremptyzero_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_dec_haszero([5, 5, 5]) == False\nassert op_oremptyzero_dec_haszero([3, 1, 2]) == True\nassert op_oremptyzero_dec_haszero([10]) == False\nassert op_oremptyzero_dec_haszero([2, 4, 6]) == False\nassert op_oremptyzero_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_absval_beforezero", "entry_point": "op_dec_absval_beforezero", "primitives": ["dec", "absval", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then keep everything before the first zero.", "solution": "def op_dec_absval_beforezero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dec_absval_beforezero([1, 2, 3, 4]) == []\nassert op_dec_absval_beforezero([]) == []\nassert op_dec_absval_beforezero([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_dec_absval_beforezero([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_beforezero([3, 1, 2]) == [2]\nassert op_dec_absval_beforezero([10]) == [9]\nassert op_dec_absval_beforezero([2, 4, 6]) == [1, 3, 5]\nassert op_dec_absval_beforezero([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_pos_sorta_oremptyzero", "entry_point": "op_pos_sorta_oremptyzero", "primitives": ["pos", "sorta", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort ascending, then if empty, use a single zero.", "solution": "def op_pos_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_pos_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_sorta_oremptyzero([]) == [0]\nassert op_pos_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_pos_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_pos_sorta_oremptyzero([10]) == [10]\nassert op_pos_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_sorta_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_div3_beforezero_len", "entry_point": "op_div3_beforezero_len", "primitives": ["div3", "beforezero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then return how many remain.", "solution": "def op_div3_beforezero_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r)", "tests": "assert op_div3_beforezero_len([1, 2, 3, 4]) == 1\nassert op_div3_beforezero_len([]) == 0\nassert op_div3_beforezero_len([-2, -1, 0, 1, 2]) == 0\nassert op_div3_beforezero_len([5, 5, 5]) == 0\nassert op_div3_beforezero_len([3, 1, 2]) == 1\nassert op_div3_beforezero_len([10]) == 0\nassert op_div3_beforezero_len([2, 4, 6]) == 1\nassert op_div3_beforezero_len([-7, 12, -7]) == 1"}
{"id": "op_absval_gt5_sortabs", "entry_point": "op_absval_gt5_sortabs", "primitives": ["absval", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then sort by absolute value.", "solution": "def op_absval_gt5_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_absval_gt5_sortabs([]) == []\nassert op_absval_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_sortabs([5, 5, 5]) == []\nassert op_absval_gt5_sortabs([3, 1, 2]) == []\nassert op_absval_gt5_sortabs([10]) == [10]\nassert op_absval_gt5_sortabs([2, 4, 6]) == [6]\nassert op_absval_gt5_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_dropwhileneg_first3_sorta", "entry_point": "op_dropwhileneg_first3_sorta", "primitives": ["dropwhileneg", "first3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then sort ascending.", "solution": "def op_dropwhileneg_first3_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_first3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropwhileneg_first3_sorta([]) == []\nassert op_dropwhileneg_first3_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_first3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_first3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_first3_sorta([10]) == [10]\nassert op_dropwhileneg_first3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_first3_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_oremptyzero_negate_dropwhileneg", "entry_point": "op_oremptyzero_negate_dropwhileneg", "primitives": ["oremptyzero", "negate", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then drop the leading negative values.", "solution": "def op_oremptyzero_negate_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_negate_dropwhileneg([1, 2, 3, 4]) == []\nassert op_oremptyzero_negate_dropwhileneg([]) == [0]\nassert op_oremptyzero_negate_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_oremptyzero_negate_dropwhileneg([5, 5, 5]) == []\nassert op_oremptyzero_negate_dropwhileneg([3, 1, 2]) == []\nassert op_oremptyzero_negate_dropwhileneg([10]) == []\nassert op_oremptyzero_negate_dropwhileneg([2, 4, 6]) == []\nassert op_oremptyzero_negate_dropwhileneg([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_inc_square_rev", "entry_point": "op_inc_square_rev", "primitives": ["inc", "square", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each, then reverse the order.", "solution": "def op_inc_square_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_square_rev([1, 2, 3, 4]) == [25, 16, 9, 4]\nassert op_inc_square_rev([]) == []\nassert op_inc_square_rev([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_inc_square_rev([5, 5, 5]) == [36, 36, 36]\nassert op_inc_square_rev([3, 1, 2]) == [9, 4, 16]\nassert op_inc_square_rev([10]) == [121]\nassert op_inc_square_rev([2, 4, 6]) == [49, 25, 9]\nassert op_inc_square_rev([-7, 12, -7]) == [36, 169, 36]"}
{"id": "op_absval_double_dropzeros", "entry_point": "op_absval_double_dropzeros", "primitives": ["absval", "double", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then double each, then drop the zeros.", "solution": "def op_absval_double_dropzeros(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_absval_double_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_absval_double_dropzeros([]) == []\nassert op_absval_double_dropzeros([-2, -1, 0, 1, 2]) == [4, 2, 2, 4]\nassert op_absval_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_absval_double_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_absval_double_dropzeros([10]) == [20]\nassert op_absval_double_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_absval_double_dropzeros([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_ages_square_clamp10", "entry_point": "op_ages_square_clamp10", "primitives": ["ages", "square", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then cap each value at 10.", "solution": "def op_ages_square_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_square_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_square_clamp10([]) == []\nassert op_ages_square_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_square_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_inc_add10_oremptyzero", "entry_point": "op_inc_add10_oremptyzero", "primitives": ["inc", "add10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then if empty, use a single zero.", "solution": "def op_inc_add10_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_add10_oremptyzero([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_add10_oremptyzero([]) == [0]\nassert op_inc_add10_oremptyzero([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_add10_oremptyzero([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10_oremptyzero([3, 1, 2]) == [14, 12, 13]\nassert op_inc_add10_oremptyzero([10]) == [21]\nassert op_inc_add10_oremptyzero([2, 4, 6]) == [13, 15, 17]\nassert op_inc_add10_oremptyzero([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_negate_neg_add10", "entry_point": "op_negate_neg_add10", "primitives": ["negate", "neg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then add ten to each.", "solution": "def op_negate_neg_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_neg_add10([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_neg_add10([]) == []\nassert op_negate_neg_add10([-2, -1, 0, 1, 2]) == [9, 8]\nassert op_negate_neg_add10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_neg_add10([3, 1, 2]) == [7, 9, 8]\nassert op_negate_neg_add10([10]) == [0]\nassert op_negate_neg_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_neg_add10([-7, 12, -7]) == [-2]"}
{"id": "op_last3_add10_issorted", "entry_point": "op_last3_add10_issorted", "primitives": ["last3", "add10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_last3_add10_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_last3_add10_issorted([1, 2, 3, 4]) == True\nassert op_last3_add10_issorted([]) == True\nassert op_last3_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_add10_issorted([5, 5, 5]) == True\nassert op_last3_add10_issorted([3, 1, 2]) == False\nassert op_last3_add10_issorted([10]) == True\nassert op_last3_add10_issorted([2, 4, 6]) == True\nassert op_last3_add10_issorted([-7, 12, -7]) == False"}
{"id": "op_last3_div3_add10", "entry_point": "op_last3_div3_add10", "primitives": ["last3", "div3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then add ten to each.", "solution": "def op_last3_div3_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_div3_add10([1, 2, 3, 4]) == [13]\nassert op_last3_div3_add10([]) == []\nassert op_last3_div3_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_last3_div3_add10([5, 5, 5]) == []\nassert op_last3_div3_add10([3, 1, 2]) == [13]\nassert op_last3_div3_add10([10]) == []\nassert op_last3_div3_add10([2, 4, 6]) == [16]\nassert op_last3_div3_add10([-7, 12, -7]) == [22]"}
{"id": "op_last3_clamp10_alldistinct", "entry_point": "op_last3_clamp10_alldistinct", "primitives": ["last3", "clamp10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_last3_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_last3_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_clamp10_alldistinct([]) == True\nassert op_last3_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_clamp10_alldistinct([5, 5, 5]) == False\nassert op_last3_clamp10_alldistinct([3, 1, 2]) == True\nassert op_last3_clamp10_alldistinct([10]) == True\nassert op_last3_clamp10_alldistinct([2, 4, 6]) == True\nassert op_last3_clamp10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sorta_dropwhileneg_double", "entry_point": "op_sorta_dropwhileneg_double", "primitives": ["sorta", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then double each.", "solution": "def op_sorta_dropwhileneg_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_dropwhileneg_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sorta_dropwhileneg_double([]) == []\nassert op_sorta_dropwhileneg_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_sorta_dropwhileneg_double([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_dropwhileneg_double([3, 1, 2]) == [2, 4, 6]\nassert op_sorta_dropwhileneg_double([10]) == [20]\nassert op_sorta_dropwhileneg_double([2, 4, 6]) == [4, 8, 12]\nassert op_sorta_dropwhileneg_double([-7, 12, -7]) == [24]"}
{"id": "op_ages_neg_firsteven", "entry_point": "op_ages_neg_firsteven", "primitives": ["ages", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_ages_neg_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_neg_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_neg_firsteven([]) == 0\nassert op_ages_neg_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 0\nassert op_ages_neg_firsteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_double_dec_div3", "entry_point": "op_double_dec_div3", "primitives": ["double", "dec", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then keep multiples of three.", "solution": "def op_double_dec_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_dec_div3([1, 2, 3, 4]) == [3]\nassert op_double_dec_div3([]) == []\nassert op_double_dec_div3([-2, -1, 0, 1, 2]) == [-3, 3]\nassert op_double_dec_div3([5, 5, 5]) == [9, 9, 9]\nassert op_double_dec_div3([3, 1, 2]) == [3]\nassert op_double_dec_div3([10]) == []\nassert op_double_dec_div3([2, 4, 6]) == [3]\nassert op_double_dec_div3([-7, 12, -7]) == [-15, -15]"}
{"id": "op_dropzeros_neg_uniq", "entry_point": "op_dropzeros_neg_uniq", "primitives": ["dropzeros", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_dropzeros_neg_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropzeros_neg_uniq([1, 2, 3, 4]) == []\nassert op_dropzeros_neg_uniq([]) == []\nassert op_dropzeros_neg_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_dropzeros_neg_uniq([5, 5, 5]) == []\nassert op_dropzeros_neg_uniq([3, 1, 2]) == []\nassert op_dropzeros_neg_uniq([10]) == []\nassert op_dropzeros_neg_uniq([2, 4, 6]) == []\nassert op_dropzeros_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_absval_beforezero_dec", "entry_point": "op_absval_beforezero_dec", "primitives": ["absval", "beforezero", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then subtract one from each.", "solution": "def op_absval_beforezero_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_beforezero_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_absval_beforezero_dec([]) == []\nassert op_absval_beforezero_dec([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_absval_beforezero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_beforezero_dec([3, 1, 2]) == [2, 0, 1]\nassert op_absval_beforezero_dec([10]) == [9]\nassert op_absval_beforezero_dec([2, 4, 6]) == [1, 3, 5]\nassert op_absval_beforezero_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_odds_rev_min", "entry_point": "op_odds_rev_min", "primitives": ["odds", "rev", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_odds_rev_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_odds_rev_min([1, 2, 3, 4]) == 1\nassert op_odds_rev_min([]) == 0\nassert op_odds_rev_min([-2, -1, 0, 1, 2]) == -1\nassert op_odds_rev_min([5, 5, 5]) == 5\nassert op_odds_rev_min([3, 1, 2]) == 1\nassert op_odds_rev_min([10]) == 0\nassert op_odds_rev_min([2, 4, 6]) == 0\nassert op_odds_rev_min([-7, 12, -7]) == -7"}
{"id": "op_dropwhileneg_dropzeros_takewhilepos", "entry_point": "op_dropwhileneg_dropzeros_takewhilepos", "primitives": ["dropwhileneg", "dropzeros", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then take values while they are positive.", "solution": "def op_dropwhileneg_dropzeros_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_dropzeros_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_dropzeros_takewhilepos([]) == []\nassert op_dropwhileneg_dropzeros_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropzeros_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_dropzeros_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_dropzeros_takewhilepos([10]) == [10]\nassert op_dropwhileneg_dropzeros_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_dropzeros_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_add10_sorta", "entry_point": "op_uniq_add10_sorta", "primitives": ["uniq", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then sort ascending.", "solution": "def op_uniq_add10_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_add10_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10_sorta([]) == []\nassert op_uniq_add10_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10_sorta([5, 5, 5]) == [15]\nassert op_uniq_add10_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_uniq_add10_sorta([10]) == [20]\nassert op_uniq_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_sorta([-7, 12, -7]) == [3, 22]"}
{"id": "op_dec_last3_clamp10", "entry_point": "op_dec_last3_clamp10", "primitives": ["dec", "last3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then cap each value at 10.", "solution": "def op_dec_last3_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_last3_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_last3_clamp10([]) == []\nassert op_dec_last3_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dec_last3_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dec_last3_clamp10([3, 1, 2]) == [2, 0, 1]\nassert op_dec_last3_clamp10([10]) == [9]\nassert op_dec_last3_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dec_last3_clamp10([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_oremptyzero_evens_padto3", "entry_point": "op_oremptyzero_evens_padto3", "primitives": ["oremptyzero", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_oremptyzero_evens_padto3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_oremptyzero_evens_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_oremptyzero_evens_padto3([]) == [0, 0, 0]\nassert op_oremptyzero_evens_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_oremptyzero_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_oremptyzero_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_oremptyzero_evens_padto3([10]) == [10, 0, 0]\nassert op_oremptyzero_evens_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_beforezero_rev_alldistinct", "entry_point": "op_beforezero_rev_alldistinct", "primitives": ["beforezero", "rev", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then return whether all values are distinct.", "solution": "def op_beforezero_rev_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_rev_alldistinct([]) == True\nassert op_beforezero_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_rev_alldistinct([5, 5, 5]) == False\nassert op_beforezero_rev_alldistinct([3, 1, 2]) == True\nassert op_beforezero_rev_alldistinct([10]) == True\nassert op_beforezero_rev_alldistinct([2, 4, 6]) == True\nassert op_beforezero_rev_alldistinct([-7, 12, -7]) == False"}
{"id": "op_clamp10_gt5_beforezero", "entry_point": "op_clamp10_gt5_beforezero", "primitives": ["clamp10", "gt5", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_clamp10_gt5_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_clamp10_gt5_beforezero([]) == []\nassert op_clamp10_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_gt5_beforezero([5, 5, 5]) == []\nassert op_clamp10_gt5_beforezero([3, 1, 2]) == []\nassert op_clamp10_gt5_beforezero([10]) == [10]\nassert op_clamp10_gt5_beforezero([2, 4, 6]) == [6]\nassert op_clamp10_gt5_beforezero([-7, 12, -7]) == [10]"}
{"id": "op_sortd_dropzeros_issorted", "entry_point": "op_sortd_dropzeros_issorted", "primitives": ["sortd", "dropzeros", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_sortd_dropzeros_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_sortd_dropzeros_issorted([1, 2, 3, 4]) == False\nassert op_sortd_dropzeros_issorted([]) == True\nassert op_sortd_dropzeros_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortd_dropzeros_issorted([5, 5, 5]) == True\nassert op_sortd_dropzeros_issorted([3, 1, 2]) == False\nassert op_sortd_dropzeros_issorted([10]) == True\nassert op_sortd_dropzeros_issorted([2, 4, 6]) == False\nassert op_sortd_dropzeros_issorted([-7, 12, -7]) == False"}
{"id": "op_uniq_evens_negate", "entry_point": "op_uniq_evens_negate", "primitives": ["uniq", "evens", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then negate each.", "solution": "def op_uniq_evens_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_evens_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_uniq_evens_negate([]) == []\nassert op_uniq_evens_negate([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_uniq_evens_negate([5, 5, 5]) == []\nassert op_uniq_evens_negate([3, 1, 2]) == [-2]\nassert op_uniq_evens_negate([10]) == [-10]\nassert op_uniq_evens_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_evens_negate([-7, 12, -7]) == [-12]"}
{"id": "op_absval_last3_max", "entry_point": "op_absval_last3_max", "primitives": ["absval", "last3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_absval_last3_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_absval_last3_max([1, 2, 3, 4]) == 4\nassert op_absval_last3_max([]) == 0\nassert op_absval_last3_max([-2, -1, 0, 1, 2]) == 2\nassert op_absval_last3_max([5, 5, 5]) == 5\nassert op_absval_last3_max([3, 1, 2]) == 3\nassert op_absval_last3_max([10]) == 10\nassert op_absval_last3_max([2, 4, 6]) == 6\nassert op_absval_last3_max([-7, 12, -7]) == 12"}
{"id": "op_uniq_dropzeros_sortd", "entry_point": "op_uniq_dropzeros_sortd", "primitives": ["uniq", "dropzeros", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then sort descending.", "solution": "def op_uniq_dropzeros_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_dropzeros_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_dropzeros_sortd([]) == []\nassert op_uniq_dropzeros_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_uniq_dropzeros_sortd([5, 5, 5]) == [5]\nassert op_uniq_dropzeros_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_dropzeros_sortd([10]) == [10]\nassert op_uniq_dropzeros_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_dropzeros_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_first3_dropzeros_prod", "entry_point": "op_first3_dropzeros_prod", "primitives": ["first3", "dropzeros", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then return their product.", "solution": "def op_first3_dropzeros_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_first3_dropzeros_prod([1, 2, 3, 4]) == 6\nassert op_first3_dropzeros_prod([]) == 1\nassert op_first3_dropzeros_prod([-2, -1, 0, 1, 2]) == 2\nassert op_first3_dropzeros_prod([5, 5, 5]) == 125\nassert op_first3_dropzeros_prod([3, 1, 2]) == 6\nassert op_first3_dropzeros_prod([10]) == 10\nassert op_first3_dropzeros_prod([2, 4, 6]) == 48\nassert op_first3_dropzeros_prod([-7, 12, -7]) == 588"}
{"id": "op_trimends_evens_max", "entry_point": "op_trimends_evens_max", "primitives": ["trimends", "evens", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_trimends_evens_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_trimends_evens_max([1, 2, 3, 4]) == 2\nassert op_trimends_evens_max([]) == 0\nassert op_trimends_evens_max([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_evens_max([5, 5, 5]) == 0\nassert op_trimends_evens_max([3, 1, 2]) == 0\nassert op_trimends_evens_max([10]) == 0\nassert op_trimends_evens_max([2, 4, 6]) == 4\nassert op_trimends_evens_max([-7, 12, -7]) == 12"}
{"id": "op_pos_dropwhileneg_issorted", "entry_point": "op_pos_dropwhileneg_issorted", "primitives": ["pos", "dropwhileneg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_pos_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_pos_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_pos_dropwhileneg_issorted([]) == True\nassert op_pos_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_pos_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_pos_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_pos_dropwhileneg_issorted([10]) == True\nassert op_pos_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_pos_dropwhileneg_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_dropfirst_trimends", "entry_point": "op_gt5_dropfirst_trimends", "primitives": ["gt5", "dropfirst", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then drop the first and last elements.", "solution": "def op_gt5_dropfirst_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_dropfirst_trimends([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_trimends([]) == []\nassert op_gt5_dropfirst_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_trimends([5, 5, 5]) == []\nassert op_gt5_dropfirst_trimends([3, 1, 2]) == []\nassert op_gt5_dropfirst_trimends([10]) == []\nassert op_gt5_dropfirst_trimends([2, 4, 6]) == []\nassert op_gt5_dropfirst_trimends([-7, 12, -7]) == []"}
{"id": "op_beforezero_last3_dropfirst", "entry_point": "op_beforezero_last3_dropfirst", "primitives": ["beforezero", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then drop the first element.", "solution": "def op_beforezero_last3_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_last3_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_beforezero_last3_dropfirst([]) == []\nassert op_beforezero_last3_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_last3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_beforezero_last3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_beforezero_last3_dropfirst([10]) == []\nassert op_beforezero_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_beforezero_last3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_dec_takewhilepos_odds", "entry_point": "op_dec_takewhilepos_odds", "primitives": ["dec", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then keep the odd numbers.", "solution": "def op_dec_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_takewhilepos_odds([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos_odds([]) == []\nassert op_dec_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos_odds([5, 5, 5]) == []\nassert op_dec_takewhilepos_odds([3, 1, 2]) == []\nassert op_dec_takewhilepos_odds([10]) == [9]\nassert op_dec_takewhilepos_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_double_absval_trimends", "entry_point": "op_double_absval_trimends", "primitives": ["double", "absval", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_double_absval_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_absval_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_double_absval_trimends([]) == []\nassert op_double_absval_trimends([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_double_absval_trimends([5, 5, 5]) == [10]\nassert op_double_absval_trimends([3, 1, 2]) == [2]\nassert op_double_absval_trimends([10]) == []\nassert op_double_absval_trimends([2, 4, 6]) == [8]\nassert op_double_absval_trimends([-7, 12, -7]) == [24]"}
{"id": "op_first3_dropzeros_padto3", "entry_point": "op_first3_dropzeros_padto3", "primitives": ["first3", "dropzeros", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then pad with zeros to at least three elements.", "solution": "def op_first3_dropzeros_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_dropzeros_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropzeros_padto3([]) == [0, 0, 0]\nassert op_first3_dropzeros_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_dropzeros_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropzeros_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropzeros_padto3([10]) == [10, 0, 0]\nassert op_first3_dropzeros_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropzeros_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_negate_dropzeros_counteven", "entry_point": "op_negate_dropzeros_counteven", "primitives": ["negate", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then return how many values are even.", "solution": "def op_negate_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_negate_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_negate_dropzeros_counteven([]) == 0\nassert op_negate_dropzeros_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_negate_dropzeros_counteven([5, 5, 5]) == 0\nassert op_negate_dropzeros_counteven([3, 1, 2]) == 1\nassert op_negate_dropzeros_counteven([10]) == 1\nassert op_negate_dropzeros_counteven([2, 4, 6]) == 3\nassert op_negate_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropwhileneg_first3_last3", "entry_point": "op_dropwhileneg_first3_last3", "primitives": ["dropwhileneg", "first3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then keep only the last three.", "solution": "def op_dropwhileneg_first3_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_first3_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropwhileneg_first3_last3([]) == []\nassert op_dropwhileneg_first3_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_first3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_first3_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_first3_last3([10]) == [10]\nassert op_dropwhileneg_first3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_first3_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_nonempty_uniqs_maxlen", "entry_point": "op_nonempty_uniqs_maxlen", "primitives": ["nonempty", "uniqs", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop duplicate strings keeping the first, then return the length of the longest string (0 if none).", "solution": "def op_nonempty_uniqs_maxlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = list(dict.fromkeys(r))\n    return max((len(s) for s in r), default=0)", "tests": "assert op_nonempty_uniqs_maxlen(['Hello', 'world']) == 5\nassert op_nonempty_uniqs_maxlen([]) == 0\nassert op_nonempty_uniqs_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_nonempty_uniqs_maxlen(['one', 'one', 'Two']) == 3\nassert op_nonempty_uniqs_maxlen(['x']) == 1\nassert op_nonempty_uniqs_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_neg_clamp10_uniq", "entry_point": "op_neg_clamp10_uniq", "primitives": ["neg", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_neg_clamp10_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_neg_clamp10_uniq([1, 2, 3, 4]) == []\nassert op_neg_clamp10_uniq([]) == []\nassert op_neg_clamp10_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_clamp10_uniq([5, 5, 5]) == []\nassert op_neg_clamp10_uniq([3, 1, 2]) == []\nassert op_neg_clamp10_uniq([10]) == []\nassert op_neg_clamp10_uniq([2, 4, 6]) == []\nassert op_neg_clamp10_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_rev_dropzeros_sortabs", "entry_point": "op_rev_dropzeros_sortabs", "primitives": ["rev", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then sort by absolute value.", "solution": "def op_rev_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_dropzeros_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_dropzeros_sortabs([]) == []\nassert op_rev_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [1, -1, 2, -2]\nassert op_rev_dropzeros_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_dropzeros_sortabs([10]) == [10]\nassert op_rev_dropzeros_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_dropzeros_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortd_uniq_sortabs", "entry_point": "op_sortd_uniq_sortabs", "primitives": ["sortd", "uniq", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then sort by absolute value.", "solution": "def op_sortd_uniq_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortd_uniq_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_uniq_sortabs([]) == []\nassert op_sortd_uniq_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortd_uniq_sortabs([5, 5, 5]) == [5]\nassert op_sortd_uniq_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_uniq_sortabs([10]) == [10]\nassert op_sortd_uniq_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_uniq_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_absval_last3_double", "entry_point": "op_absval_last3_double", "primitives": ["absval", "last3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then double each.", "solution": "def op_absval_last3_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_last3_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_absval_last3_double([]) == []\nassert op_absval_last3_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_absval_last3_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_last3_double([3, 1, 2]) == [6, 2, 4]\nassert op_absval_last3_double([10]) == [20]\nassert op_absval_last3_double([2, 4, 6]) == [4, 8, 12]\nassert op_absval_last3_double([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_evens_trimends_takewhilepos", "entry_point": "op_evens_trimends_takewhilepos", "primitives": ["evens", "trimends", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then take values while they are positive.", "solution": "def op_evens_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_evens_trimends_takewhilepos([1, 2, 3, 4]) == []\nassert op_evens_trimends_takewhilepos([]) == []\nassert op_evens_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_evens_trimends_takewhilepos([5, 5, 5]) == []\nassert op_evens_trimends_takewhilepos([3, 1, 2]) == []\nassert op_evens_trimends_takewhilepos([10]) == []\nassert op_evens_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_evens_trimends_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_trimends_negate_odds", "entry_point": "op_trimends_negate_odds", "primitives": ["trimends", "negate", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then keep the odd numbers.", "solution": "def op_trimends_negate_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_negate_odds([1, 2, 3, 4]) == [-3]\nassert op_trimends_negate_odds([]) == []\nassert op_trimends_negate_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_trimends_negate_odds([5, 5, 5]) == [-5]\nassert op_trimends_negate_odds([3, 1, 2]) == [-1]\nassert op_trimends_negate_odds([10]) == []\nassert op_trimends_negate_odds([2, 4, 6]) == []\nassert op_trimends_negate_odds([-7, 12, -7]) == []"}
{"id": "op_dropfirst_gt5_first3", "entry_point": "op_dropfirst_gt5_first3", "primitives": ["dropfirst", "gt5", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep values greater than five, then keep only the first three.", "solution": "def op_dropfirst_gt5_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_gt5_first3([1, 2, 3, 4]) == []\nassert op_dropfirst_gt5_first3([]) == []\nassert op_dropfirst_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_gt5_first3([5, 5, 5]) == []\nassert op_dropfirst_gt5_first3([3, 1, 2]) == []\nassert op_dropfirst_gt5_first3([10]) == []\nassert op_dropfirst_gt5_first3([2, 4, 6]) == [6]\nassert op_dropfirst_gt5_first3([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_sorta_counteven", "entry_point": "op_beforezero_sorta_counteven", "primitives": ["beforezero", "sorta", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then return how many values are even.", "solution": "def op_beforezero_sorta_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_sorta_counteven([]) == 0\nassert op_beforezero_sorta_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_sorta_counteven([5, 5, 5]) == 0\nassert op_beforezero_sorta_counteven([3, 1, 2]) == 1\nassert op_beforezero_sorta_counteven([10]) == 1\nassert op_beforezero_sorta_counteven([2, 4, 6]) == 3\nassert op_beforezero_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_inc_double_len", "entry_point": "op_inc_double_len", "primitives": ["inc", "double", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then return how many remain.", "solution": "def op_inc_double_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_inc_double_len([1, 2, 3, 4]) == 4\nassert op_inc_double_len([]) == 0\nassert op_inc_double_len([-2, -1, 0, 1, 2]) == 5\nassert op_inc_double_len([5, 5, 5]) == 3\nassert op_inc_double_len([3, 1, 2]) == 3\nassert op_inc_double_len([10]) == 1\nassert op_inc_double_len([2, 4, 6]) == 3\nassert op_inc_double_len([-7, 12, -7]) == 3"}
{"id": "op_uniq_add10_pos", "entry_point": "op_uniq_add10_pos", "primitives": ["uniq", "add10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then keep the positive numbers.", "solution": "def op_uniq_add10_pos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_uniq_add10_pos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10_pos([]) == []\nassert op_uniq_add10_pos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10_pos([5, 5, 5]) == [15]\nassert op_uniq_add10_pos([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10_pos([10]) == [20]\nassert op_uniq_add10_pos([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_pos([-7, 12, -7]) == [3, 22]"}
{"id": "op_dec_pos_allpos", "entry_point": "op_dec_pos_allpos", "primitives": ["dec", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_dec_pos_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_pos_allpos([1, 2, 3, 4]) == True\nassert op_dec_pos_allpos([]) == True\nassert op_dec_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_dec_pos_allpos([5, 5, 5]) == True\nassert op_dec_pos_allpos([3, 1, 2]) == True\nassert op_dec_pos_allpos([10]) == True\nassert op_dec_pos_allpos([2, 4, 6]) == True\nassert op_dec_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_div3_dec_first3", "entry_point": "op_div3_dec_first3", "primitives": ["div3", "dec", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each, then keep only the first three.", "solution": "def op_div3_dec_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_div3_dec_first3([1, 2, 3, 4]) == [2]\nassert op_div3_dec_first3([]) == []\nassert op_div3_dec_first3([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_dec_first3([5, 5, 5]) == []\nassert op_div3_dec_first3([3, 1, 2]) == [2]\nassert op_div3_dec_first3([10]) == []\nassert op_div3_dec_first3([2, 4, 6]) == [5]\nassert op_div3_dec_first3([-7, 12, -7]) == [11]"}
{"id": "op_padto3_add10_min", "entry_point": "op_padto3_add10_min", "primitives": ["padto3", "add10", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_padto3_add10_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_padto3_add10_min([1, 2, 3, 4]) == 11\nassert op_padto3_add10_min([]) == 10\nassert op_padto3_add10_min([-2, -1, 0, 1, 2]) == 8\nassert op_padto3_add10_min([5, 5, 5]) == 15\nassert op_padto3_add10_min([3, 1, 2]) == 11\nassert op_padto3_add10_min([10]) == 10\nassert op_padto3_add10_min([2, 4, 6]) == 12\nassert op_padto3_add10_min([-7, 12, -7]) == 3"}
{"id": "op_dropzeros_oremptyzero_sortd", "entry_point": "op_dropzeros_oremptyzero_sortd", "primitives": ["dropzeros", "oremptyzero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then sort descending.", "solution": "def op_dropzeros_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_oremptyzero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_oremptyzero_sortd([]) == [0]\nassert op_dropzeros_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_oremptyzero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_oremptyzero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_oremptyzero_sortd([10]) == [10]\nassert op_dropzeros_oremptyzero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_oremptyzero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_rev_last3_beforezero", "entry_point": "op_rev_last3_beforezero", "primitives": ["rev", "last3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then keep everything before the first zero.", "solution": "def op_rev_last3_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_last3_beforezero([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_last3_beforezero([]) == []\nassert op_rev_last3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_rev_last3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3_beforezero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_last3_beforezero([10]) == [10]\nassert op_rev_last3_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_last3_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_oremptyzero_odds_sorta", "entry_point": "op_oremptyzero_odds_sorta", "primitives": ["oremptyzero", "odds", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then sort ascending.", "solution": "def op_oremptyzero_odds_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_odds_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_odds_sorta([]) == []\nassert op_oremptyzero_odds_sorta([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_odds_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_odds_sorta([3, 1, 2]) == [1, 3]\nassert op_oremptyzero_odds_sorta([10]) == []\nassert op_oremptyzero_odds_sorta([2, 4, 6]) == []\nassert op_oremptyzero_odds_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_ages_oremptyzero_sortabs", "entry_point": "op_ages_oremptyzero_sortabs", "primitives": ["ages", "oremptyzero", "sortabs"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then sort by absolute value.", "solution": "def op_ages_oremptyzero_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_oremptyzero_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_oremptyzero_sortabs([]) == [0]\nassert op_ages_oremptyzero_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_oremptyzero_sortabs([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropwhileneg_dec_rev", "entry_point": "op_dropwhileneg_dec_rev", "primitives": ["dropwhileneg", "dec", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then subtract one from each, then reverse the order.", "solution": "def op_dropwhileneg_dec_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_dec_rev([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dropwhileneg_dec_rev([]) == []\nassert op_dropwhileneg_dec_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_dropwhileneg_dec_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dropwhileneg_dec_rev([3, 1, 2]) == [1, 0, 2]\nassert op_dropwhileneg_dec_rev([10]) == [9]\nassert op_dropwhileneg_dec_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dropwhileneg_dec_rev([-7, 12, -7]) == [-8, 11]"}
{"id": "op_rev_sortabs_gt5", "entry_point": "op_rev_sortabs_gt5", "primitives": ["rev", "sortabs", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then keep values greater than five.", "solution": "def op_rev_sortabs_gt5(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_rev_sortabs_gt5([1, 2, 3, 4]) == []\nassert op_rev_sortabs_gt5([]) == []\nassert op_rev_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_rev_sortabs_gt5([5, 5, 5]) == []\nassert op_rev_sortabs_gt5([3, 1, 2]) == []\nassert op_rev_sortabs_gt5([10]) == [10]\nassert op_rev_sortabs_gt5([2, 4, 6]) == [6]\nassert op_rev_sortabs_gt5([-7, 12, -7]) == [12]"}
{"id": "op_rev_double_sortabs", "entry_point": "op_rev_double_sortabs", "primitives": ["rev", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then sort by absolute value.", "solution": "def op_rev_double_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_double_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_rev_double_sortabs([]) == []\nassert op_rev_double_sortabs([-2, -1, 0, 1, 2]) == [0, 2, -2, 4, -4]\nassert op_rev_double_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_rev_double_sortabs([10]) == [20]\nassert op_rev_double_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_rev_double_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_first3_takewhilepos_dropwhileneg", "entry_point": "op_first3_takewhilepos_dropwhileneg", "primitives": ["first3", "takewhilepos", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then drop the leading negative values.", "solution": "def op_first3_takewhilepos_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_takewhilepos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_takewhilepos_dropwhileneg([]) == []\nassert op_first3_takewhilepos_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_first3_takewhilepos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_first3_takewhilepos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_first3_takewhilepos_dropwhileneg([10]) == [10]\nassert op_first3_takewhilepos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_first3_takewhilepos_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_padto3_clamp10_firsteven", "entry_point": "op_padto3_clamp10_firsteven", "primitives": ["padto3", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_padto3_clamp10_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_padto3_clamp10_firsteven([]) == 0\nassert op_padto3_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_clamp10_firsteven([5, 5, 5]) == 0\nassert op_padto3_clamp10_firsteven([3, 1, 2]) == 2\nassert op_padto3_clamp10_firsteven([10]) == 10\nassert op_padto3_clamp10_firsteven([2, 4, 6]) == 2\nassert op_padto3_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_names_uniqs_sortlen", "entry_point": "op_names_uniqs_sortlen", "primitives": ["names", "uniqs", "sortlen"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop duplicate strings keeping the first, then sort by length, shortest first.", "solution": "def op_names_uniqs_sortlen(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_names_uniqs_sortlen([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Bo', 'Ada']\nassert op_names_uniqs_sortlen([]) == []\nassert op_names_uniqs_sortlen([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'El', 'Dee']\nassert op_names_uniqs_sortlen([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_inc_gt5_trimends", "entry_point": "op_inc_gt5_trimends", "primitives": ["inc", "gt5", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then drop the first and last elements.", "solution": "def op_inc_gt5_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_gt5_trimends([1, 2, 3, 4]) == []\nassert op_inc_gt5_trimends([]) == []\nassert op_inc_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5_trimends([5, 5, 5]) == [6]\nassert op_inc_gt5_trimends([3, 1, 2]) == []\nassert op_inc_gt5_trimends([10]) == []\nassert op_inc_gt5_trimends([2, 4, 6]) == []\nassert op_inc_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_uniqs_dropshort_upper", "entry_point": "op_uniqs_dropshort_upper", "primitives": ["uniqs", "dropshort", "upper"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop strings shorter than three characters, then uppercase each string.", "solution": "def op_uniqs_dropshort_upper(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_uniqs_dropshort_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_uniqs_dropshort_upper([]) == []\nassert op_uniqs_dropshort_upper(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_uniqs_dropshort_upper(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_uniqs_dropshort_upper(['x']) == []\nassert op_uniqs_dropshort_upper(['abc', 'de', '']) == ['ABC']"}
{"id": "op_takewhilepos_trimends_inc", "entry_point": "op_takewhilepos_trimends_inc", "primitives": ["takewhilepos", "trimends", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then add one to each.", "solution": "def op_takewhilepos_trimends_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_trimends_inc([1, 2, 3, 4]) == [3, 4]\nassert op_takewhilepos_trimends_inc([]) == []\nassert op_takewhilepos_trimends_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_trimends_inc([5, 5, 5]) == [6]\nassert op_takewhilepos_trimends_inc([3, 1, 2]) == [2]\nassert op_takewhilepos_trimends_inc([10]) == []\nassert op_takewhilepos_trimends_inc([2, 4, 6]) == [5]\nassert op_takewhilepos_trimends_inc([-7, 12, -7]) == []"}
{"id": "op_uniq_add10_neg", "entry_point": "op_uniq_add10_neg", "primitives": ["uniq", "add10", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then keep the negative numbers.", "solution": "def op_uniq_add10_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_add10_neg([1, 2, 3, 4]) == []\nassert op_uniq_add10_neg([]) == []\nassert op_uniq_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_uniq_add10_neg([5, 5, 5]) == []\nassert op_uniq_add10_neg([3, 1, 2]) == []\nassert op_uniq_add10_neg([10]) == []\nassert op_uniq_add10_neg([2, 4, 6]) == []\nassert op_uniq_add10_neg([-7, 12, -7]) == []"}
{"id": "op_dec_dropwhileneg_trimends", "entry_point": "op_dec_dropwhileneg_trimends", "primitives": ["dec", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_dec_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_dropwhileneg_trimends([1, 2, 3, 4]) == [1, 2]\nassert op_dec_dropwhileneg_trimends([]) == []\nassert op_dec_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dec_dropwhileneg_trimends([5, 5, 5]) == [4]\nassert op_dec_dropwhileneg_trimends([3, 1, 2]) == [0]\nassert op_dec_dropwhileneg_trimends([10]) == []\nassert op_dec_dropwhileneg_trimends([2, 4, 6]) == [3]\nassert op_dec_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_sortabs_absval_pos", "entry_point": "op_sortabs_absval_pos", "primitives": ["sortabs", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_sortabs_absval_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_absval_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_absval_pos([]) == []\nassert op_sortabs_absval_pos([-2, -1, 0, 1, 2]) == [1, 1, 2, 2]\nassert op_sortabs_absval_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_absval_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_absval_pos([10]) == [10]\nassert op_sortabs_absval_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_absval_pos([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_uniq_sortd_dropzeros", "entry_point": "op_uniq_sortd_dropzeros", "primitives": ["uniq", "sortd", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then drop the zeros.", "solution": "def op_uniq_sortd_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_sortd_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_sortd_dropzeros([]) == []\nassert op_uniq_sortd_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_uniq_sortd_dropzeros([5, 5, 5]) == [5]\nassert op_uniq_sortd_dropzeros([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_sortd_dropzeros([10]) == [10]\nassert op_uniq_sortd_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_sortd_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_evens_dropwhileneg_inc", "entry_point": "op_evens_dropwhileneg_inc", "primitives": ["evens", "dropwhileneg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then add one to each.", "solution": "def op_evens_dropwhileneg_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_evens_dropwhileneg_inc([1, 2, 3, 4]) == [3, 5]\nassert op_evens_dropwhileneg_inc([]) == []\nassert op_evens_dropwhileneg_inc([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_evens_dropwhileneg_inc([5, 5, 5]) == []\nassert op_evens_dropwhileneg_inc([3, 1, 2]) == [3]\nassert op_evens_dropwhileneg_inc([10]) == [11]\nassert op_evens_dropwhileneg_inc([2, 4, 6]) == [3, 5, 7]\nassert op_evens_dropwhileneg_inc([-7, 12, -7]) == [13]"}
{"id": "op_padto3_first3_oremptyzero", "entry_point": "op_padto3_first3_oremptyzero", "primitives": ["padto3", "first3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then if empty, use a single zero.", "solution": "def op_padto3_first3_oremptyzero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_padto3_first3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_first3_oremptyzero([]) == [0, 0, 0]\nassert op_padto3_first3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_padto3_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_first3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_first3_oremptyzero([10]) == [10, 0, 0]\nassert op_padto3_first3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_first3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_ages_sortabs_issorted", "entry_point": "op_ages_sortabs_issorted", "primitives": ["ages", "sortabs", "issorted"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_ages_sortabs_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_ages_sortabs_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_sortabs_issorted([]) == True\nassert op_ages_sortabs_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_sortabs_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_odds_beforezero_trimends", "entry_point": "op_odds_beforezero_trimends", "primitives": ["odds", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_odds_beforezero_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_beforezero_trimends([1, 2, 3, 4]) == []\nassert op_odds_beforezero_trimends([]) == []\nassert op_odds_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_beforezero_trimends([5, 5, 5]) == [5]\nassert op_odds_beforezero_trimends([3, 1, 2]) == []\nassert op_odds_beforezero_trimends([10]) == []\nassert op_odds_beforezero_trimends([2, 4, 6]) == []\nassert op_odds_beforezero_trimends([-7, 12, -7]) == []"}
{"id": "op_sortd_padto3_negate", "entry_point": "op_sortd_padto3_negate", "primitives": ["sortd", "padto3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then negate each.", "solution": "def op_sortd_padto3_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_padto3_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sortd_padto3_negate([]) == [0, 0, 0]\nassert op_sortd_padto3_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_padto3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortd_padto3_negate([3, 1, 2]) == [-3, -2, -1]\nassert op_sortd_padto3_negate([10]) == [-10, 0, 0]\nassert op_sortd_padto3_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_sortd_padto3_negate([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_takewhilepos_neg_anyeven", "entry_point": "op_takewhilepos_neg_anyeven", "primitives": ["takewhilepos", "neg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then return whether any value is even.", "solution": "def op_takewhilepos_neg_anyeven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_takewhilepos_neg_anyeven([1, 2, 3, 4]) == False\nassert op_takewhilepos_neg_anyeven([]) == False\nassert op_takewhilepos_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_neg_anyeven([5, 5, 5]) == False\nassert op_takewhilepos_neg_anyeven([3, 1, 2]) == False\nassert op_takewhilepos_neg_anyeven([10]) == False\nassert op_takewhilepos_neg_anyeven([2, 4, 6]) == False\nassert op_takewhilepos_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_sortd_evens_padto3", "entry_point": "op_sortd_evens_padto3", "primitives": ["sortd", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_sortd_evens_padto3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortd_evens_padto3([1, 2, 3, 4]) == [4, 2, 0]\nassert op_sortd_evens_padto3([]) == [0, 0, 0]\nassert op_sortd_evens_padto3([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_sortd_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_sortd_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_sortd_evens_padto3([10]) == [10, 0, 0]\nassert op_sortd_evens_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_dropfirst_last3_haszero", "entry_point": "op_dropfirst_last3_haszero", "primitives": ["dropfirst", "last3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then return whether the list contains a zero.", "solution": "def op_dropfirst_last3_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    return 0 in r", "tests": "assert op_dropfirst_last3_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_last3_haszero([]) == False\nassert op_dropfirst_last3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_last3_haszero([5, 5, 5]) == False\nassert op_dropfirst_last3_haszero([3, 1, 2]) == False\nassert op_dropfirst_last3_haszero([10]) == False\nassert op_dropfirst_last3_haszero([2, 4, 6]) == False\nassert op_dropfirst_last3_haszero([-7, 12, -7]) == False"}
{"id": "op_sortabs_square_padto3", "entry_point": "op_sortabs_square_padto3", "primitives": ["sortabs", "square", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then pad with zeros to at least three elements.", "solution": "def op_sortabs_square_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_square_padto3([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_square_padto3([]) == [0, 0, 0]\nassert op_sortabs_square_padto3([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sortabs_square_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_square_padto3([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_square_padto3([10]) == [100, 0, 0]\nassert op_sortabs_square_padto3([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_square_padto3([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_gt5_takewhilepos_add10", "entry_point": "op_gt5_takewhilepos_add10", "primitives": ["gt5", "takewhilepos", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then add ten to each.", "solution": "def op_gt5_takewhilepos_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_gt5_takewhilepos_add10([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos_add10([]) == []\nassert op_gt5_takewhilepos_add10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos_add10([5, 5, 5]) == []\nassert op_gt5_takewhilepos_add10([3, 1, 2]) == []\nassert op_gt5_takewhilepos_add10([10]) == [20]\nassert op_gt5_takewhilepos_add10([2, 4, 6]) == [16]\nassert op_gt5_takewhilepos_add10([-7, 12, -7]) == [22]"}
{"id": "op_evens_double_firsteven", "entry_point": "op_evens_double_firsteven", "primitives": ["evens", "double", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then return the first even value (0 if none).", "solution": "def op_evens_double_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_evens_double_firsteven([1, 2, 3, 4]) == 4\nassert op_evens_double_firsteven([]) == 0\nassert op_evens_double_firsteven([-2, -1, 0, 1, 2]) == -4\nassert op_evens_double_firsteven([5, 5, 5]) == 0\nassert op_evens_double_firsteven([3, 1, 2]) == 4\nassert op_evens_double_firsteven([10]) == 20\nassert op_evens_double_firsteven([2, 4, 6]) == 4\nassert op_evens_double_firsteven([-7, 12, -7]) == 24"}
{"id": "op_sortalpha_strip_joinc", "entry_point": "op_sortalpha_strip_joinc", "primitives": ["sortalpha", "strip", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then trim whitespace from each, then join them with commas.", "solution": "def op_sortalpha_strip_joinc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    return ','.join(r)", "tests": "assert op_sortalpha_strip_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortalpha_strip_joinc([]) == ''\nassert op_sortalpha_strip_joinc(['  a ', '', 'BC', 'bc']) == ',a,BC,bc'\nassert op_sortalpha_strip_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_sortalpha_strip_joinc(['x']) == 'x'\nassert op_sortalpha_strip_joinc(['abc', 'de', '']) == ',abc,de'"}
{"id": "op_ages_negate_counteven", "entry_point": "op_ages_negate_counteven", "primitives": ["ages", "negate", "counteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then return how many values are even.", "solution": "def op_ages_negate_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_negate_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_negate_counteven([]) == 0\nassert op_ages_negate_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_ages_negate_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_trimends_beforezero_last3", "entry_point": "op_trimends_beforezero_last3", "primitives": ["trimends", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then keep only the last three.", "solution": "def op_trimends_beforezero_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_beforezero_last3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_beforezero_last3([]) == []\nassert op_trimends_beforezero_last3([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero_last3([5, 5, 5]) == [5]\nassert op_trimends_beforezero_last3([3, 1, 2]) == [1]\nassert op_trimends_beforezero_last3([10]) == []\nassert op_trimends_beforezero_last3([2, 4, 6]) == [4]\nassert op_trimends_beforezero_last3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_double_len", "entry_point": "op_gt5_double_len", "primitives": ["gt5", "double", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then return how many remain.", "solution": "def op_gt5_double_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_gt5_double_len([1, 2, 3, 4]) == 0\nassert op_gt5_double_len([]) == 0\nassert op_gt5_double_len([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_double_len([5, 5, 5]) == 0\nassert op_gt5_double_len([3, 1, 2]) == 0\nassert op_gt5_double_len([10]) == 1\nassert op_gt5_double_len([2, 4, 6]) == 1\nassert op_gt5_double_len([-7, 12, -7]) == 1"}
{"id": "op_div3_trimends_absval", "entry_point": "op_div3_trimends_absval", "primitives": ["div3", "trimends", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_div3_trimends_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_trimends_absval([1, 2, 3, 4]) == []\nassert op_div3_trimends_absval([]) == []\nassert op_div3_trimends_absval([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends_absval([5, 5, 5]) == []\nassert op_div3_trimends_absval([3, 1, 2]) == []\nassert op_div3_trimends_absval([10]) == []\nassert op_div3_trimends_absval([2, 4, 6]) == []\nassert op_div3_trimends_absval([-7, 12, -7]) == []"}
{"id": "op_absval_div3_pos", "entry_point": "op_absval_div3_pos", "primitives": ["absval", "div3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then keep the positive numbers.", "solution": "def op_absval_div3_pos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_absval_div3_pos([1, 2, 3, 4]) == [3]\nassert op_absval_div3_pos([]) == []\nassert op_absval_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_absval_div3_pos([5, 5, 5]) == []\nassert op_absval_div3_pos([3, 1, 2]) == [3]\nassert op_absval_div3_pos([10]) == []\nassert op_absval_div3_pos([2, 4, 6]) == [6]\nassert op_absval_div3_pos([-7, 12, -7]) == [12]"}
{"id": "op_dec_sortabs_min", "entry_point": "op_dec_sortabs_min", "primitives": ["dec", "sortabs", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_dec_sortabs_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_dec_sortabs_min([1, 2, 3, 4]) == 0\nassert op_dec_sortabs_min([]) == 0\nassert op_dec_sortabs_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_sortabs_min([5, 5, 5]) == 4\nassert op_dec_sortabs_min([3, 1, 2]) == 0\nassert op_dec_sortabs_min([10]) == 9\nassert op_dec_sortabs_min([2, 4, 6]) == 1\nassert op_dec_sortabs_min([-7, 12, -7]) == -8"}
{"id": "op_names_sortalpha_anyempty", "entry_point": "op_names_sortalpha_anyempty", "primitives": ["names", "sortalpha", "anyempty"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort alphabetically, then return whether any string is empty.", "solution": "def op_names_sortalpha_anyempty(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r)\n    return any(s == '' for s in r)", "tests": "assert op_names_sortalpha_anyempty([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_names_sortalpha_anyempty([]) == False\nassert op_names_sortalpha_anyempty([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_names_sortalpha_anyempty([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_add10_absval_evens", "entry_point": "op_add10_absval_evens", "primitives": ["add10", "absval", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then keep the even numbers.", "solution": "def op_add10_absval_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_absval_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_absval_evens([]) == []\nassert op_add10_absval_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_absval_evens([5, 5, 5]) == []\nassert op_add10_absval_evens([3, 1, 2]) == [12]\nassert op_add10_absval_evens([10]) == [20]\nassert op_add10_absval_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_absval_evens([-7, 12, -7]) == [22]"}
{"id": "op_evens_takewhilepos_haszero", "entry_point": "op_evens_takewhilepos_haszero", "primitives": ["evens", "takewhilepos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then return whether the list contains a zero.", "solution": "def op_evens_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_evens_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_evens_takewhilepos_haszero([]) == False\nassert op_evens_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_evens_takewhilepos_haszero([5, 5, 5]) == False\nassert op_evens_takewhilepos_haszero([3, 1, 2]) == False\nassert op_evens_takewhilepos_haszero([10]) == False\nassert op_evens_takewhilepos_haszero([2, 4, 6]) == False\nassert op_evens_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_uniq_gt5", "entry_point": "op_padto3_uniq_gt5", "primitives": ["padto3", "uniq", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_padto3_uniq_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_uniq_gt5([1, 2, 3, 4]) == []\nassert op_padto3_uniq_gt5([]) == []\nassert op_padto3_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_uniq_gt5([5, 5, 5]) == []\nassert op_padto3_uniq_gt5([3, 1, 2]) == []\nassert op_padto3_uniq_gt5([10]) == [10]\nassert op_padto3_uniq_gt5([2, 4, 6]) == [6]\nassert op_padto3_uniq_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_absval_pos", "entry_point": "op_dropfirst_absval_pos", "primitives": ["dropfirst", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_dropfirst_absval_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_absval_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_absval_pos([]) == []\nassert op_dropfirst_absval_pos([-2, -1, 0, 1, 2]) == [1, 1, 2]\nassert op_dropfirst_absval_pos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_absval_pos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_absval_pos([10]) == []\nassert op_dropfirst_absval_pos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_absval_pos([-7, 12, -7]) == [12, 7]"}
{"id": "op_dropzeros_beforezero_sortd", "entry_point": "op_dropzeros_beforezero_sortd", "primitives": ["dropzeros", "beforezero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then sort descending.", "solution": "def op_dropzeros_beforezero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_beforezero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_beforezero_sortd([]) == []\nassert op_dropzeros_beforezero_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_beforezero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_beforezero_sortd([10]) == [10]\nassert op_dropzeros_beforezero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_beforezero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_sortabs_double_alldistinct", "entry_point": "op_sortabs_double_alldistinct", "primitives": ["sortabs", "double", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then return whether all values are distinct.", "solution": "def op_sortabs_double_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_double_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_double_alldistinct([]) == True\nassert op_sortabs_double_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_double_alldistinct([5, 5, 5]) == False\nassert op_sortabs_double_alldistinct([3, 1, 2]) == True\nassert op_sortabs_double_alldistinct([10]) == True\nassert op_sortabs_double_alldistinct([2, 4, 6]) == True\nassert op_sortabs_double_alldistinct([-7, 12, -7]) == False"}
{"id": "op_gt5_double_issorted", "entry_point": "op_gt5_double_issorted", "primitives": ["gt5", "double", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then return whether the list is sorted ascending.", "solution": "def op_gt5_double_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_gt5_double_issorted([1, 2, 3, 4]) == True\nassert op_gt5_double_issorted([]) == True\nassert op_gt5_double_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_double_issorted([5, 5, 5]) == True\nassert op_gt5_double_issorted([3, 1, 2]) == True\nassert op_gt5_double_issorted([10]) == True\nassert op_gt5_double_issorted([2, 4, 6]) == True\nassert op_gt5_double_issorted([-7, 12, -7]) == True"}
{"id": "op_pos_last3_odds", "entry_point": "op_pos_last3_odds", "primitives": ["pos", "last3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then keep the odd numbers.", "solution": "def op_pos_last3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_pos_last3_odds([1, 2, 3, 4]) == [3]\nassert op_pos_last3_odds([]) == []\nassert op_pos_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_pos_last3_odds([3, 1, 2]) == [3, 1]\nassert op_pos_last3_odds([10]) == []\nassert op_pos_last3_odds([2, 4, 6]) == []\nassert op_pos_last3_odds([-7, 12, -7]) == []"}
{"id": "op_last3_trimends_alldistinct", "entry_point": "op_last3_trimends_alldistinct", "primitives": ["last3", "trimends", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_last3_trimends_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_last3_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_trimends_alldistinct([]) == True\nassert op_last3_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_trimends_alldistinct([5, 5, 5]) == True\nassert op_last3_trimends_alldistinct([3, 1, 2]) == True\nassert op_last3_trimends_alldistinct([10]) == True\nassert op_last3_trimends_alldistinct([2, 4, 6]) == True\nassert op_last3_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_add10_rev_first3", "entry_point": "op_add10_rev_first3", "primitives": ["add10", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then keep only the first three.", "solution": "def op_add10_rev_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_add10_rev_first3([1, 2, 3, 4]) == [14, 13, 12]\nassert op_add10_rev_first3([]) == []\nassert op_add10_rev_first3([-2, -1, 0, 1, 2]) == [12, 11, 10]\nassert op_add10_rev_first3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_rev_first3([3, 1, 2]) == [12, 11, 13]\nassert op_add10_rev_first3([10]) == [20]\nassert op_add10_rev_first3([2, 4, 6]) == [16, 14, 12]\nassert op_add10_rev_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_takewhilepos_div3_dec", "entry_point": "op_takewhilepos_div3_dec", "primitives": ["takewhilepos", "div3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three, then subtract one from each.", "solution": "def op_takewhilepos_div3_dec(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_div3_dec([1, 2, 3, 4]) == [2]\nassert op_takewhilepos_div3_dec([]) == []\nassert op_takewhilepos_div3_dec([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_div3_dec([5, 5, 5]) == []\nassert op_takewhilepos_div3_dec([3, 1, 2]) == [2]\nassert op_takewhilepos_div3_dec([10]) == []\nassert op_takewhilepos_div3_dec([2, 4, 6]) == [5]\nassert op_takewhilepos_div3_dec([-7, 12, -7]) == []"}
{"id": "op_dropzeros_takewhilepos_sum", "entry_point": "op_dropzeros_takewhilepos_sum", "primitives": ["dropzeros", "takewhilepos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then return their sum.", "solution": "def op_dropzeros_takewhilepos_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_dropzeros_takewhilepos_sum([1, 2, 3, 4]) == 10\nassert op_dropzeros_takewhilepos_sum([]) == 0\nassert op_dropzeros_takewhilepos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_takewhilepos_sum([5, 5, 5]) == 15\nassert op_dropzeros_takewhilepos_sum([3, 1, 2]) == 6\nassert op_dropzeros_takewhilepos_sum([10]) == 10\nassert op_dropzeros_takewhilepos_sum([2, 4, 6]) == 12\nassert op_dropzeros_takewhilepos_sum([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_square_add10", "entry_point": "op_dropfirst_square_add10", "primitives": ["dropfirst", "square", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then add ten to each.", "solution": "def op_dropfirst_square_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_square_add10([1, 2, 3, 4]) == [14, 19, 26]\nassert op_dropfirst_square_add10([]) == []\nassert op_dropfirst_square_add10([-2, -1, 0, 1, 2]) == [11, 10, 11, 14]\nassert op_dropfirst_square_add10([5, 5, 5]) == [35, 35]\nassert op_dropfirst_square_add10([3, 1, 2]) == [11, 14]\nassert op_dropfirst_square_add10([10]) == []\nassert op_dropfirst_square_add10([2, 4, 6]) == [26, 46]\nassert op_dropfirst_square_add10([-7, 12, -7]) == [154, 59]"}
{"id": "op_uniq_square_div3", "entry_point": "op_uniq_square_div3", "primitives": ["uniq", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then keep multiples of three.", "solution": "def op_uniq_square_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_square_div3([1, 2, 3, 4]) == [9]\nassert op_uniq_square_div3([]) == []\nassert op_uniq_square_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_square_div3([5, 5, 5]) == []\nassert op_uniq_square_div3([3, 1, 2]) == [9]\nassert op_uniq_square_div3([10]) == []\nassert op_uniq_square_div3([2, 4, 6]) == [36]\nassert op_uniq_square_div3([-7, 12, -7]) == [144]"}
{"id": "op_double_inc_last3", "entry_point": "op_double_inc_last3", "primitives": ["double", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each, then keep only the last three.", "solution": "def op_double_inc_last3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_double_inc_last3([1, 2, 3, 4]) == [5, 7, 9]\nassert op_double_inc_last3([]) == []\nassert op_double_inc_last3([-2, -1, 0, 1, 2]) == [1, 3, 5]\nassert op_double_inc_last3([5, 5, 5]) == [11, 11, 11]\nassert op_double_inc_last3([3, 1, 2]) == [7, 3, 5]\nassert op_double_inc_last3([10]) == [21]\nassert op_double_inc_last3([2, 4, 6]) == [5, 9, 13]\nassert op_double_inc_last3([-7, 12, -7]) == [-13, 25, -13]"}
{"id": "op_uniq_negate_neg", "entry_point": "op_uniq_negate_neg", "primitives": ["uniq", "negate", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then keep the negative numbers.", "solution": "def op_uniq_negate_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_negate_neg([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_negate_neg([]) == []\nassert op_uniq_negate_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_uniq_negate_neg([5, 5, 5]) == [-5]\nassert op_uniq_negate_neg([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_negate_neg([10]) == [-10]\nassert op_uniq_negate_neg([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_negate_neg([-7, 12, -7]) == [-12]"}
{"id": "op_sortabs_inc_square", "entry_point": "op_sortabs_inc_square", "primitives": ["sortabs", "inc", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then square each.", "solution": "def op_sortabs_inc_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_inc_square([1, 2, 3, 4]) == [4, 9, 16, 25]\nassert op_sortabs_inc_square([]) == []\nassert op_sortabs_inc_square([-2, -1, 0, 1, 2]) == [1, 0, 4, 1, 9]\nassert op_sortabs_inc_square([5, 5, 5]) == [36, 36, 36]\nassert op_sortabs_inc_square([3, 1, 2]) == [4, 9, 16]\nassert op_sortabs_inc_square([10]) == [121]\nassert op_sortabs_inc_square([2, 4, 6]) == [9, 25, 49]\nassert op_sortabs_inc_square([-7, 12, -7]) == [36, 36, 169]"}
{"id": "op_div3_gt5_takewhilepos", "entry_point": "op_div3_gt5_takewhilepos", "primitives": ["div3", "gt5", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then take values while they are positive.", "solution": "def op_div3_gt5_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_gt5_takewhilepos([1, 2, 3, 4]) == []\nassert op_div3_gt5_takewhilepos([]) == []\nassert op_div3_gt5_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_takewhilepos([5, 5, 5]) == []\nassert op_div3_gt5_takewhilepos([3, 1, 2]) == []\nassert op_div3_gt5_takewhilepos([10]) == []\nassert op_div3_gt5_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_gt5_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_rev_double_negate", "entry_point": "op_rev_double_negate", "primitives": ["rev", "double", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then negate each.", "solution": "def op_rev_double_negate(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_rev_double_negate([1, 2, 3, 4]) == [-8, -6, -4, -2]\nassert op_rev_double_negate([]) == []\nassert op_rev_double_negate([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_rev_double_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_rev_double_negate([3, 1, 2]) == [-4, -2, -6]\nassert op_rev_double_negate([10]) == [-20]\nassert op_rev_double_negate([2, 4, 6]) == [-12, -8, -4]\nassert op_rev_double_negate([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_pos_oremptyzero_haszero", "entry_point": "op_pos_oremptyzero_haszero", "primitives": ["pos", "oremptyzero", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_pos_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_pos_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_pos_oremptyzero_haszero([]) == True\nassert op_pos_oremptyzero_haszero([-2, -1, 0, 1, 2]) == False\nassert op_pos_oremptyzero_haszero([5, 5, 5]) == False\nassert op_pos_oremptyzero_haszero([3, 1, 2]) == False\nassert op_pos_oremptyzero_haszero([10]) == False\nassert op_pos_oremptyzero_haszero([2, 4, 6]) == False\nassert op_pos_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_gt5_dropzeros", "entry_point": "op_padto3_gt5_dropzeros", "primitives": ["padto3", "gt5", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then drop the zeros.", "solution": "def op_padto3_gt5_dropzeros(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_padto3_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_padto3_gt5_dropzeros([]) == []\nassert op_padto3_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5_dropzeros([5, 5, 5]) == []\nassert op_padto3_gt5_dropzeros([3, 1, 2]) == []\nassert op_padto3_gt5_dropzeros([10]) == [10]\nassert op_padto3_gt5_dropzeros([2, 4, 6]) == [6]\nassert op_padto3_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_gt5_sorta_dec", "entry_point": "op_gt5_sorta_dec", "primitives": ["gt5", "sorta", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then subtract one from each.", "solution": "def op_gt5_sorta_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_gt5_sorta_dec([1, 2, 3, 4]) == []\nassert op_gt5_sorta_dec([]) == []\nassert op_gt5_sorta_dec([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_dec([5, 5, 5]) == []\nassert op_gt5_sorta_dec([3, 1, 2]) == []\nassert op_gt5_sorta_dec([10]) == [9]\nassert op_gt5_sorta_dec([2, 4, 6]) == [5]\nassert op_gt5_sorta_dec([-7, 12, -7]) == [11]"}
{"id": "op_evens_neg_clamp10", "entry_point": "op_evens_neg_clamp10", "primitives": ["evens", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers, then cap each value at 10.", "solution": "def op_evens_neg_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_neg_clamp10([1, 2, 3, 4]) == []\nassert op_evens_neg_clamp10([]) == []\nassert op_evens_neg_clamp10([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_neg_clamp10([5, 5, 5]) == []\nassert op_evens_neg_clamp10([3, 1, 2]) == []\nassert op_evens_neg_clamp10([10]) == []\nassert op_evens_neg_clamp10([2, 4, 6]) == []\nassert op_evens_neg_clamp10([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_beforezero_alldistinct", "entry_point": "op_dropwhileneg_beforezero_alldistinct", "primitives": ["dropwhileneg", "beforezero", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep everything before the first zero, then return whether all values are distinct.", "solution": "def op_dropwhileneg_beforezero_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_beforezero_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_beforezero_alldistinct([]) == True\nassert op_dropwhileneg_beforezero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_beforezero_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_beforezero_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_beforezero_alldistinct([10]) == True\nassert op_dropwhileneg_beforezero_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_beforezero_alldistinct([-7, 12, -7]) == True"}
{"id": "op_clamp10_gt5_absval", "entry_point": "op_clamp10_gt5_absval", "primitives": ["clamp10", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five, then take the absolute value of each.", "solution": "def op_clamp10_gt5_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_gt5_absval([1, 2, 3, 4]) == []\nassert op_clamp10_gt5_absval([]) == []\nassert op_clamp10_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_gt5_absval([5, 5, 5]) == []\nassert op_clamp10_gt5_absval([3, 1, 2]) == []\nassert op_clamp10_gt5_absval([10]) == [10]\nassert op_clamp10_gt5_absval([2, 4, 6]) == [6]\nassert op_clamp10_gt5_absval([-7, 12, -7]) == [10]"}
{"id": "op_clamp10_negate_evens", "entry_point": "op_clamp10_negate_evens", "primitives": ["clamp10", "negate", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then keep the even numbers.", "solution": "def op_clamp10_negate_evens(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_clamp10_negate_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_clamp10_negate_evens([]) == []\nassert op_clamp10_negate_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_clamp10_negate_evens([5, 5, 5]) == []\nassert op_clamp10_negate_evens([3, 1, 2]) == [-2]\nassert op_clamp10_negate_evens([10]) == [-10]\nassert op_clamp10_negate_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_clamp10_negate_evens([-7, 12, -7]) == [-10]"}
{"id": "op_neg_double_gt5", "entry_point": "op_neg_double_gt5", "primitives": ["neg", "double", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then double each, then keep values greater than five.", "solution": "def op_neg_double_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_double_gt5([1, 2, 3, 4]) == []\nassert op_neg_double_gt5([]) == []\nassert op_neg_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_double_gt5([5, 5, 5]) == []\nassert op_neg_double_gt5([3, 1, 2]) == []\nassert op_neg_double_gt5([10]) == []\nassert op_neg_double_gt5([2, 4, 6]) == []\nassert op_neg_double_gt5([-7, 12, -7]) == []"}
{"id": "op_odds_absval_counteven", "entry_point": "op_odds_absval_counteven", "primitives": ["odds", "absval", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then return how many values are even.", "solution": "def op_odds_absval_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_odds_absval_counteven([1, 2, 3, 4]) == 0\nassert op_odds_absval_counteven([]) == 0\nassert op_odds_absval_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_absval_counteven([5, 5, 5]) == 0\nassert op_odds_absval_counteven([3, 1, 2]) == 0\nassert op_odds_absval_counteven([10]) == 0\nassert op_odds_absval_counteven([2, 4, 6]) == 0\nassert op_odds_absval_counteven([-7, 12, -7]) == 0"}
{"id": "op_last3_clamp10_absval", "entry_point": "op_last3_clamp10_absval", "primitives": ["last3", "clamp10", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then take the absolute value of each.", "solution": "def op_last3_clamp10_absval(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_last3_clamp10_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_clamp10_absval([]) == []\nassert op_last3_clamp10_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_clamp10_absval([5, 5, 5]) == [5, 5, 5]\nassert op_last3_clamp10_absval([3, 1, 2]) == [3, 1, 2]\nassert op_last3_clamp10_absval([10]) == [10]\nassert op_last3_clamp10_absval([2, 4, 6]) == [2, 4, 6]\nassert op_last3_clamp10_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_dropzeros_pos_max", "entry_point": "op_dropzeros_pos_max", "primitives": ["dropzeros", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_dropzeros_pos_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_pos_max([1, 2, 3, 4]) == 4\nassert op_dropzeros_pos_max([]) == 0\nassert op_dropzeros_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_pos_max([5, 5, 5]) == 5\nassert op_dropzeros_pos_max([3, 1, 2]) == 3\nassert op_dropzeros_pos_max([10]) == 10\nassert op_dropzeros_pos_max([2, 4, 6]) == 6\nassert op_dropzeros_pos_max([-7, 12, -7]) == 12"}
{"id": "op_absval_uniq_sorta", "entry_point": "op_absval_uniq_sorta", "primitives": ["absval", "uniq", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence, then sort ascending.", "solution": "def op_absval_uniq_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return r", "tests": "assert op_absval_uniq_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_uniq_sorta([]) == []\nassert op_absval_uniq_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_uniq_sorta([5, 5, 5]) == [5]\nassert op_absval_uniq_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_absval_uniq_sorta([10]) == [10]\nassert op_absval_uniq_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_absval_uniq_sorta([-7, 12, -7]) == [7, 12]"}
{"id": "op_beforezero_clamp10_rev", "entry_point": "op_beforezero_clamp10_rev", "primitives": ["beforezero", "clamp10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10, then reverse the order.", "solution": "def op_beforezero_clamp10_rev(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_beforezero_clamp10_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_clamp10_rev([]) == []\nassert op_beforezero_clamp10_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_clamp10_rev([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_clamp10_rev([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_clamp10_rev([10]) == [10]\nassert op_beforezero_clamp10_rev([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_clamp10_rev([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_gt5_neg_firsteven", "entry_point": "op_gt5_neg_firsteven", "primitives": ["gt5", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_gt5_neg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_neg_firsteven([]) == 0\nassert op_gt5_neg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_neg_firsteven([5, 5, 5]) == 0\nassert op_gt5_neg_firsteven([3, 1, 2]) == 0\nassert op_gt5_neg_firsteven([10]) == 0\nassert op_gt5_neg_firsteven([2, 4, 6]) == 0\nassert op_gt5_neg_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_uniq_absval", "entry_point": "op_dropfirst_uniq_absval", "primitives": ["dropfirst", "uniq", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_dropfirst_uniq_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_uniq_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_uniq_absval([]) == []\nassert op_dropfirst_uniq_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_dropfirst_uniq_absval([5, 5, 5]) == [5]\nassert op_dropfirst_uniq_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_uniq_absval([10]) == []\nassert op_dropfirst_uniq_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_uniq_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_ages_last3_first3", "entry_point": "op_ages_last3_first3", "primitives": ["ages", "last3", "first3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then keep only the first three.", "solution": "def op_ages_last3_first3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_ages_last3_first3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_last3_first3([]) == []\nassert op_ages_last3_first3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_last3_first3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_takewhilepos_last3_pos", "entry_point": "op_takewhilepos_last3_pos", "primitives": ["takewhilepos", "last3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then keep the positive numbers.", "solution": "def op_takewhilepos_last3_pos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_takewhilepos_last3_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_last3_pos([]) == []\nassert op_takewhilepos_last3_pos([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_last3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_last3_pos([10]) == [10]\nassert op_takewhilepos_last3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_last3_pos([-7, 12, -7]) == []"}
{"id": "op_inc_dropwhileneg_firsteven", "entry_point": "op_inc_dropwhileneg_firsteven", "primitives": ["inc", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_inc_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_inc_dropwhileneg_firsteven([1, 2, 3, 4]) == 2\nassert op_inc_dropwhileneg_firsteven([]) == 0\nassert op_inc_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_inc_dropwhileneg_firsteven([5, 5, 5]) == 6\nassert op_inc_dropwhileneg_firsteven([3, 1, 2]) == 4\nassert op_inc_dropwhileneg_firsteven([10]) == 0\nassert op_inc_dropwhileneg_firsteven([2, 4, 6]) == 0\nassert op_inc_dropwhileneg_firsteven([-7, 12, -7]) == -6"}
{"id": "op_sortabs_last3_haszero", "entry_point": "op_sortabs_last3_haszero", "primitives": ["sortabs", "last3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the last three, then return whether the list contains a zero.", "solution": "def op_sortabs_last3_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return 0 in r", "tests": "assert op_sortabs_last3_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_last3_haszero([]) == False\nassert op_sortabs_last3_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_last3_haszero([5, 5, 5]) == False\nassert op_sortabs_last3_haszero([3, 1, 2]) == False\nassert op_sortabs_last3_haszero([10]) == False\nassert op_sortabs_last3_haszero([2, 4, 6]) == False\nassert op_sortabs_last3_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_double_beforezero", "entry_point": "op_div3_double_beforezero", "primitives": ["div3", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then keep everything before the first zero.", "solution": "def op_div3_double_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_double_beforezero([1, 2, 3, 4]) == [6]\nassert op_div3_double_beforezero([]) == []\nassert op_div3_double_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_beforezero([5, 5, 5]) == []\nassert op_div3_double_beforezero([3, 1, 2]) == [6]\nassert op_div3_double_beforezero([10]) == []\nassert op_div3_double_beforezero([2, 4, 6]) == [12]\nassert op_div3_double_beforezero([-7, 12, -7]) == [24]"}
{"id": "op_clamp10_dropzeros_double", "entry_point": "op_clamp10_dropzeros_double", "primitives": ["clamp10", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then double each.", "solution": "def op_clamp10_dropzeros_double(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_clamp10_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_clamp10_dropzeros_double([]) == []\nassert op_clamp10_dropzeros_double([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_clamp10_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_clamp10_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_clamp10_dropzeros_double([10]) == [20]\nassert op_clamp10_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_clamp10_dropzeros_double([-7, 12, -7]) == [-14, 20, -14]"}
{"id": "op_gt5_trimends_inc", "entry_point": "op_gt5_trimends_inc", "primitives": ["gt5", "trimends", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then add one to each.", "solution": "def op_gt5_trimends_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_gt5_trimends_inc([1, 2, 3, 4]) == []\nassert op_gt5_trimends_inc([]) == []\nassert op_gt5_trimends_inc([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_inc([5, 5, 5]) == []\nassert op_gt5_trimends_inc([3, 1, 2]) == []\nassert op_gt5_trimends_inc([10]) == []\nassert op_gt5_trimends_inc([2, 4, 6]) == []\nassert op_gt5_trimends_inc([-7, 12, -7]) == []"}
{"id": "op_names_sortlen_joinc", "entry_point": "op_names_sortlen_joinc", "primitives": ["names", "sortlen", "joinc"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort by length, shortest first, then join them with commas.", "solution": "def op_names_sortlen_joinc(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    return ','.join(r)", "tests": "assert op_names_sortlen_joinc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Bo,Ada'\nassert op_names_sortlen_joinc([]) == ''\nassert op_names_sortlen_joinc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Cy,El,Dee'\nassert op_names_sortlen_joinc([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_neg_dropfirst_max", "entry_point": "op_neg_dropfirst_max", "primitives": ["neg", "dropfirst", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_neg_dropfirst_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_neg_dropfirst_max([1, 2, 3, 4]) == 0\nassert op_neg_dropfirst_max([]) == 0\nassert op_neg_dropfirst_max([-2, -1, 0, 1, 2]) == -1\nassert op_neg_dropfirst_max([5, 5, 5]) == 0\nassert op_neg_dropfirst_max([3, 1, 2]) == 0\nassert op_neg_dropfirst_max([10]) == 0\nassert op_neg_dropfirst_max([2, 4, 6]) == 0\nassert op_neg_dropfirst_max([-7, 12, -7]) == -7"}
{"id": "op_sortabs_trimends_dropwhileneg", "entry_point": "op_sortabs_trimends_dropwhileneg", "primitives": ["sortabs", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_sortabs_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortabs_trimends_dropwhileneg([1, 2, 3, 4]) == [2, 3]\nassert op_sortabs_trimends_dropwhileneg([]) == []\nassert op_sortabs_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == [1, -2]\nassert op_sortabs_trimends_dropwhileneg([5, 5, 5]) == [5]\nassert op_sortabs_trimends_dropwhileneg([3, 1, 2]) == [2]\nassert op_sortabs_trimends_dropwhileneg([10]) == []\nassert op_sortabs_trimends_dropwhileneg([2, 4, 6]) == [4]\nassert op_sortabs_trimends_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dropshort_uniqs_joinc", "entry_point": "op_dropshort_uniqs_joinc", "primitives": ["dropshort", "uniqs", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then drop duplicate strings keeping the first, then join them with commas.", "solution": "def op_dropshort_uniqs_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = list(dict.fromkeys(r))\n    return ','.join(r)", "tests": "assert op_dropshort_uniqs_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_dropshort_uniqs_joinc([]) == ''\nassert op_dropshort_uniqs_joinc(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_dropshort_uniqs_joinc(['one', 'one', 'Two']) == 'one,Two'\nassert op_dropshort_uniqs_joinc(['x']) == ''\nassert op_dropshort_uniqs_joinc(['abc', 'de', '']) == 'abc'"}
{"id": "op_sorta_dropzeros_oremptyzero", "entry_point": "op_sorta_dropzeros_oremptyzero", "primitives": ["sorta", "dropzeros", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then if empty, use a single zero.", "solution": "def op_sorta_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_dropzeros_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropzeros_oremptyzero([]) == [0]\nassert op_sorta_dropzeros_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_sorta_dropzeros_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropzeros_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropzeros_oremptyzero([10]) == [10]\nassert op_sorta_dropzeros_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropzeros_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_evens_rev_prod", "entry_point": "op_evens_rev_prod", "primitives": ["evens", "rev", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then return their product.", "solution": "def op_evens_rev_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return __import__('math').prod(r)", "tests": "assert op_evens_rev_prod([1, 2, 3, 4]) == 8\nassert op_evens_rev_prod([]) == 1\nassert op_evens_rev_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_rev_prod([5, 5, 5]) == 1\nassert op_evens_rev_prod([3, 1, 2]) == 2\nassert op_evens_rev_prod([10]) == 10\nassert op_evens_rev_prod([2, 4, 6]) == 48\nassert op_evens_rev_prod([-7, 12, -7]) == 12"}
{"id": "op_absval_pos_issorted", "entry_point": "op_absval_pos_issorted", "primitives": ["absval", "pos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_absval_pos_issorted(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_absval_pos_issorted([1, 2, 3, 4]) == True\nassert op_absval_pos_issorted([]) == True\nassert op_absval_pos_issorted([-2, -1, 0, 1, 2]) == False\nassert op_absval_pos_issorted([5, 5, 5]) == True\nassert op_absval_pos_issorted([3, 1, 2]) == False\nassert op_absval_pos_issorted([10]) == True\nassert op_absval_pos_issorted([2, 4, 6]) == True\nassert op_absval_pos_issorted([-7, 12, -7]) == False"}
{"id": "op_ages_clamp10_gt5", "entry_point": "op_ages_clamp10_gt5", "primitives": ["ages", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then keep values greater than five.", "solution": "def op_ages_clamp10_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_clamp10_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_clamp10_gt5([]) == []\nassert op_ages_clamp10_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10_gt5([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_lower_uniqs_lens", "entry_point": "op_lower_uniqs_lens", "primitives": ["lower", "uniqs", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop duplicate strings keeping the first, then return the total number of characters.", "solution": "def op_lower_uniqs_lens(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return sum(len(s) for s in r)", "tests": "assert op_lower_uniqs_lens(['Hello', 'world']) == 10\nassert op_lower_uniqs_lens([]) == 0\nassert op_lower_uniqs_lens(['  a ', '', 'BC', 'bc']) == 6\nassert op_lower_uniqs_lens(['one', 'one', 'Two']) == 6\nassert op_lower_uniqs_lens(['x']) == 1\nassert op_lower_uniqs_lens(['abc', 'de', '']) == 5"}
{"id": "op_gt5_div3_allpos", "entry_point": "op_gt5_div3_allpos", "primitives": ["gt5", "div3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then return whether all values are positive.", "solution": "def op_gt5_div3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_div3_allpos([1, 2, 3, 4]) == True\nassert op_gt5_div3_allpos([]) == True\nassert op_gt5_div3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_div3_allpos([5, 5, 5]) == True\nassert op_gt5_div3_allpos([3, 1, 2]) == True\nassert op_gt5_div3_allpos([10]) == True\nassert op_gt5_div3_allpos([2, 4, 6]) == True\nassert op_gt5_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_gt5_dec_sortabs", "entry_point": "op_gt5_dec_sortabs", "primitives": ["gt5", "dec", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then sort by absolute value.", "solution": "def op_gt5_dec_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_dec_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_dec_sortabs([]) == []\nassert op_gt5_dec_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dec_sortabs([5, 5, 5]) == []\nassert op_gt5_dec_sortabs([3, 1, 2]) == []\nassert op_gt5_dec_sortabs([10]) == [9]\nassert op_gt5_dec_sortabs([2, 4, 6]) == [5]\nassert op_gt5_dec_sortabs([-7, 12, -7]) == [11]"}
{"id": "op_oremptyzero_dec_issorted", "entry_point": "op_oremptyzero_dec_issorted", "primitives": ["oremptyzero", "dec", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_dec_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_oremptyzero_dec_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_dec_issorted([]) == True\nassert op_oremptyzero_dec_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_dec_issorted([5, 5, 5]) == True\nassert op_oremptyzero_dec_issorted([3, 1, 2]) == False\nassert op_oremptyzero_dec_issorted([10]) == True\nassert op_oremptyzero_dec_issorted([2, 4, 6]) == True\nassert op_oremptyzero_dec_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_pos_sortabs", "entry_point": "op_dropzeros_pos_sortabs", "primitives": ["dropzeros", "pos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the positive numbers, then sort by absolute value.", "solution": "def op_dropzeros_pos_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_pos_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_pos_sortabs([]) == []\nassert op_dropzeros_pos_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_pos_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_pos_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_pos_sortabs([10]) == [10]\nassert op_dropzeros_pos_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_negate_clamp10_alldistinct", "entry_point": "op_negate_clamp10_alldistinct", "primitives": ["negate", "clamp10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_negate_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_negate_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_clamp10_alldistinct([]) == True\nassert op_negate_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_clamp10_alldistinct([5, 5, 5]) == False\nassert op_negate_clamp10_alldistinct([3, 1, 2]) == True\nassert op_negate_clamp10_alldistinct([10]) == True\nassert op_negate_clamp10_alldistinct([2, 4, 6]) == True\nassert op_negate_clamp10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sortd_square_dropwhileneg", "entry_point": "op_sortd_square_dropwhileneg", "primitives": ["sortd", "square", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then drop the leading negative values.", "solution": "def op_sortd_square_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_square_dropwhileneg([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_square_dropwhileneg([]) == []\nassert op_sortd_square_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sortd_square_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_dropwhileneg([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_square_dropwhileneg([10]) == [100]\nassert op_sortd_square_dropwhileneg([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square_dropwhileneg([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_pos_odds_counteven", "entry_point": "op_pos_odds_counteven", "primitives": ["pos", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then return how many values are even.", "solution": "def op_pos_odds_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_odds_counteven([1, 2, 3, 4]) == 0\nassert op_pos_odds_counteven([]) == 0\nassert op_pos_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_pos_odds_counteven([5, 5, 5]) == 0\nassert op_pos_odds_counteven([3, 1, 2]) == 0\nassert op_pos_odds_counteven([10]) == 0\nassert op_pos_odds_counteven([2, 4, 6]) == 0\nassert op_pos_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_sorta_gt5_anyeven", "entry_point": "op_sorta_gt5_anyeven", "primitives": ["sorta", "gt5", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five, then return whether any value is even.", "solution": "def op_sorta_gt5_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_gt5_anyeven([1, 2, 3, 4]) == False\nassert op_sorta_gt5_anyeven([]) == False\nassert op_sorta_gt5_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_sorta_gt5_anyeven([5, 5, 5]) == False\nassert op_sorta_gt5_anyeven([3, 1, 2]) == False\nassert op_sorta_gt5_anyeven([10]) == True\nassert op_sorta_gt5_anyeven([2, 4, 6]) == True\nassert op_sorta_gt5_anyeven([-7, 12, -7]) == True"}
{"id": "op_double_div3_odds", "entry_point": "op_double_div3_odds", "primitives": ["double", "div3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then keep the odd numbers.", "solution": "def op_double_div3_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_div3_odds([1, 2, 3, 4]) == []\nassert op_double_div3_odds([]) == []\nassert op_double_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_div3_odds([5, 5, 5]) == []\nassert op_double_div3_odds([3, 1, 2]) == []\nassert op_double_div3_odds([10]) == []\nassert op_double_div3_odds([2, 4, 6]) == []\nassert op_double_div3_odds([-7, 12, -7]) == []"}
{"id": "op_dec_absval_trimends", "entry_point": "op_dec_absval_trimends", "primitives": ["dec", "absval", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_dec_absval_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_absval_trimends([1, 2, 3, 4]) == [1, 2]\nassert op_dec_absval_trimends([]) == []\nassert op_dec_absval_trimends([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dec_absval_trimends([5, 5, 5]) == [4]\nassert op_dec_absval_trimends([3, 1, 2]) == [0]\nassert op_dec_absval_trimends([10]) == []\nassert op_dec_absval_trimends([2, 4, 6]) == [3]\nassert op_dec_absval_trimends([-7, 12, -7]) == [11]"}
{"id": "op_padto3_double_neg", "entry_point": "op_padto3_double_neg", "primitives": ["padto3", "double", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then keep the negative numbers.", "solution": "def op_padto3_double_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_double_neg([1, 2, 3, 4]) == []\nassert op_padto3_double_neg([]) == []\nassert op_padto3_double_neg([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_padto3_double_neg([5, 5, 5]) == []\nassert op_padto3_double_neg([3, 1, 2]) == []\nassert op_padto3_double_neg([10]) == []\nassert op_padto3_double_neg([2, 4, 6]) == []\nassert op_padto3_double_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_neg_div3_sum", "entry_point": "op_neg_div3_sum", "primitives": ["neg", "div3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three, then return their sum.", "solution": "def op_neg_div3_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return sum(r)", "tests": "assert op_neg_div3_sum([1, 2, 3, 4]) == 0\nassert op_neg_div3_sum([]) == 0\nassert op_neg_div3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_neg_div3_sum([5, 5, 5]) == 0\nassert op_neg_div3_sum([3, 1, 2]) == 0\nassert op_neg_div3_sum([10]) == 0\nassert op_neg_div3_sum([2, 4, 6]) == 0\nassert op_neg_div3_sum([-7, 12, -7]) == 0"}
{"id": "op_uniq_square_allpos", "entry_point": "op_uniq_square_allpos", "primitives": ["uniq", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then return whether all values are positive.", "solution": "def op_uniq_square_allpos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_uniq_square_allpos([1, 2, 3, 4]) == True\nassert op_uniq_square_allpos([]) == True\nassert op_uniq_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_uniq_square_allpos([5, 5, 5]) == True\nassert op_uniq_square_allpos([3, 1, 2]) == True\nassert op_uniq_square_allpos([10]) == True\nassert op_uniq_square_allpos([2, 4, 6]) == True\nassert op_uniq_square_allpos([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_first3_counteven", "entry_point": "op_dropwhileneg_first3_counteven", "primitives": ["dropwhileneg", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then return how many values are even.", "solution": "def op_dropwhileneg_first3_counteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropwhileneg_first3_counteven([1, 2, 3, 4]) == 1\nassert op_dropwhileneg_first3_counteven([]) == 0\nassert op_dropwhileneg_first3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_first3_counteven([5, 5, 5]) == 0\nassert op_dropwhileneg_first3_counteven([3, 1, 2]) == 1\nassert op_dropwhileneg_first3_counteven([10]) == 1\nassert op_dropwhileneg_first3_counteven([2, 4, 6]) == 3\nassert op_dropwhileneg_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_dec_neg_first3", "entry_point": "op_dec_neg_first3", "primitives": ["dec", "neg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then keep only the first three.", "solution": "def op_dec_neg_first3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_dec_neg_first3([1, 2, 3, 4]) == []\nassert op_dec_neg_first3([]) == []\nassert op_dec_neg_first3([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_neg_first3([5, 5, 5]) == []\nassert op_dec_neg_first3([3, 1, 2]) == []\nassert op_dec_neg_first3([10]) == []\nassert op_dec_neg_first3([2, 4, 6]) == []\nassert op_dec_neg_first3([-7, 12, -7]) == [-8, -8]"}
{"id": "op_negate_add10_sortabs", "entry_point": "op_negate_add10_sortabs", "primitives": ["negate", "add10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then sort by absolute value.", "solution": "def op_negate_add10_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_add10_sortabs([1, 2, 3, 4]) == [6, 7, 8, 9]\nassert op_negate_add10_sortabs([]) == []\nassert op_negate_add10_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_negate_add10_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_negate_add10_sortabs([3, 1, 2]) == [7, 8, 9]\nassert op_negate_add10_sortabs([10]) == [0]\nassert op_negate_add10_sortabs([2, 4, 6]) == [4, 6, 8]\nassert op_negate_add10_sortabs([-7, 12, -7]) == [-2, 17, 17]"}
{"id": "op_first3_dropfirst_min", "entry_point": "op_first3_dropfirst_min", "primitives": ["first3", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_first3_dropfirst_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_first3_dropfirst_min([1, 2, 3, 4]) == 2\nassert op_first3_dropfirst_min([]) == 0\nassert op_first3_dropfirst_min([-2, -1, 0, 1, 2]) == -1\nassert op_first3_dropfirst_min([5, 5, 5]) == 5\nassert op_first3_dropfirst_min([3, 1, 2]) == 1\nassert op_first3_dropfirst_min([10]) == 0\nassert op_first3_dropfirst_min([2, 4, 6]) == 4\nassert op_first3_dropfirst_min([-7, 12, -7]) == -7"}
{"id": "op_odds_beforezero_square", "entry_point": "op_odds_beforezero_square", "primitives": ["odds", "beforezero", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then square each.", "solution": "def op_odds_beforezero_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_odds_beforezero_square([1, 2, 3, 4]) == [1, 9]\nassert op_odds_beforezero_square([]) == []\nassert op_odds_beforezero_square([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_beforezero_square([5, 5, 5]) == [25, 25, 25]\nassert op_odds_beforezero_square([3, 1, 2]) == [9, 1]\nassert op_odds_beforezero_square([10]) == []\nassert op_odds_beforezero_square([2, 4, 6]) == []\nassert op_odds_beforezero_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_sortd_add10_issorted", "entry_point": "op_sortd_add10_issorted", "primitives": ["sortd", "add10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_sortd_add10_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_sortd_add10_issorted([1, 2, 3, 4]) == False\nassert op_sortd_add10_issorted([]) == True\nassert op_sortd_add10_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortd_add10_issorted([5, 5, 5]) == True\nassert op_sortd_add10_issorted([3, 1, 2]) == False\nassert op_sortd_add10_issorted([10]) == True\nassert op_sortd_add10_issorted([2, 4, 6]) == False\nassert op_sortd_add10_issorted([-7, 12, -7]) == False"}
{"id": "op_nonempty_strip_sortalpha", "entry_point": "op_nonempty_strip_sortalpha", "primitives": ["nonempty", "strip", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then trim whitespace from each, then sort alphabetically.", "solution": "def op_nonempty_strip_sortalpha(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.strip() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_nonempty_strip_sortalpha(['Hello', 'world']) == ['Hello', 'world']\nassert op_nonempty_strip_sortalpha([]) == []\nassert op_nonempty_strip_sortalpha(['  a ', '', 'BC', 'bc']) == ['BC', 'a', 'bc']\nassert op_nonempty_strip_sortalpha(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_nonempty_strip_sortalpha(['x']) == ['x']\nassert op_nonempty_strip_sortalpha(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_dropfirst_neg_len", "entry_point": "op_dropfirst_neg_len", "primitives": ["dropfirst", "neg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then return how many remain.", "solution": "def op_dropfirst_neg_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_dropfirst_neg_len([1, 2, 3, 4]) == 0\nassert op_dropfirst_neg_len([]) == 0\nassert op_dropfirst_neg_len([-2, -1, 0, 1, 2]) == 1\nassert op_dropfirst_neg_len([5, 5, 5]) == 0\nassert op_dropfirst_neg_len([3, 1, 2]) == 0\nassert op_dropfirst_neg_len([10]) == 0\nassert op_dropfirst_neg_len([2, 4, 6]) == 0\nassert op_dropfirst_neg_len([-7, 12, -7]) == 1"}
{"id": "op_negate_oremptyzero_evens", "entry_point": "op_negate_oremptyzero_evens", "primitives": ["negate", "oremptyzero", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_negate_oremptyzero_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_oremptyzero_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_oremptyzero_evens([]) == [0]\nassert op_negate_oremptyzero_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_oremptyzero_evens([5, 5, 5]) == []\nassert op_negate_oremptyzero_evens([3, 1, 2]) == [-2]\nassert op_negate_oremptyzero_evens([10]) == [-10]\nassert op_negate_oremptyzero_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_oremptyzero_evens([-7, 12, -7]) == [-12]"}
{"id": "op_rev_padto3_len", "entry_point": "op_rev_padto3_len", "primitives": ["rev", "padto3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_rev_padto3_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_rev_padto3_len([1, 2, 3, 4]) == 4\nassert op_rev_padto3_len([]) == 3\nassert op_rev_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_padto3_len([5, 5, 5]) == 3\nassert op_rev_padto3_len([3, 1, 2]) == 3\nassert op_rev_padto3_len([10]) == 3\nassert op_rev_padto3_len([2, 4, 6]) == 3\nassert op_rev_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_dropwhileneg_trimends_rev", "entry_point": "op_dropwhileneg_trimends_rev", "primitives": ["dropwhileneg", "trimends", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then reverse the order.", "solution": "def op_dropwhileneg_trimends_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_dropwhileneg_trimends_rev([]) == []\nassert op_dropwhileneg_trimends_rev([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_rev([5, 5, 5]) == [5]\nassert op_dropwhileneg_trimends_rev([3, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_rev([10]) == []\nassert op_dropwhileneg_trimends_rev([2, 4, 6]) == [4]\nassert op_dropwhileneg_trimends_rev([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_add10_counteven", "entry_point": "op_takewhilepos_add10_counteven", "primitives": ["takewhilepos", "add10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then return how many values are even.", "solution": "def op_takewhilepos_add10_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_add10_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_add10_counteven([]) == 0\nassert op_takewhilepos_add10_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_add10_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_add10_counteven([3, 1, 2]) == 1\nassert op_takewhilepos_add10_counteven([10]) == 1\nassert op_takewhilepos_add10_counteven([2, 4, 6]) == 3\nassert op_takewhilepos_add10_counteven([-7, 12, -7]) == 0"}
{"id": "op_square_negate_evens", "entry_point": "op_square_negate_evens", "primitives": ["square", "negate", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then negate each, then keep the even numbers.", "solution": "def op_square_negate_evens(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_square_negate_evens([1, 2, 3, 4]) == [-4, -16]\nassert op_square_negate_evens([]) == []\nassert op_square_negate_evens([-2, -1, 0, 1, 2]) == [-4, 0, -4]\nassert op_square_negate_evens([5, 5, 5]) == []\nassert op_square_negate_evens([3, 1, 2]) == [-4]\nassert op_square_negate_evens([10]) == [-100]\nassert op_square_negate_evens([2, 4, 6]) == [-4, -16, -36]\nassert op_square_negate_evens([-7, 12, -7]) == [-144]"}
{"id": "op_sortabs_dropwhileneg_issorted", "entry_point": "op_sortabs_dropwhileneg_issorted", "primitives": ["sortabs", "dropwhileneg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_sortabs_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_sortabs_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_dropwhileneg_issorted([]) == True\nassert op_sortabs_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_sortabs_dropwhileneg_issorted([3, 1, 2]) == True\nassert op_sortabs_dropwhileneg_issorted([10]) == True\nassert op_sortabs_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_sortabs_dropwhileneg_issorted([-7, 12, -7]) == True"}
{"id": "op_rev_square_sortd", "entry_point": "op_rev_square_sortd", "primitives": ["rev", "square", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then sort descending.", "solution": "def op_rev_square_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_square_sortd([]) == []\nassert op_rev_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_rev_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_rev_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_rev_square_sortd([10]) == [100]\nassert op_rev_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_rev_square_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_square_double_max", "entry_point": "op_square_double_max", "primitives": ["square", "double", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then return the maximum (0 if empty).", "solution": "def op_square_double_max(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_square_double_max([1, 2, 3, 4]) == 32\nassert op_square_double_max([]) == 0\nassert op_square_double_max([-2, -1, 0, 1, 2]) == 8\nassert op_square_double_max([5, 5, 5]) == 50\nassert op_square_double_max([3, 1, 2]) == 18\nassert op_square_double_max([10]) == 200\nassert op_square_double_max([2, 4, 6]) == 72\nassert op_square_double_max([-7, 12, -7]) == 288"}
{"id": "op_clamp10_add10_sortabs", "entry_point": "op_clamp10_add10_sortabs", "primitives": ["clamp10", "add10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then sort by absolute value.", "solution": "def op_clamp10_add10_sortabs(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_clamp10_add10_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_add10_sortabs([]) == []\nassert op_clamp10_add10_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_clamp10_add10_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_add10_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_clamp10_add10_sortabs([10]) == [20]\nassert op_clamp10_add10_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_add10_sortabs([-7, 12, -7]) == [3, 3, 20]"}
{"id": "op_negate_sortabs_len", "entry_point": "op_negate_sortabs_len", "primitives": ["negate", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort by absolute value, then return how many remain.", "solution": "def op_negate_sortabs_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_negate_sortabs_len([1, 2, 3, 4]) == 4\nassert op_negate_sortabs_len([]) == 0\nassert op_negate_sortabs_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_sortabs_len([5, 5, 5]) == 3\nassert op_negate_sortabs_len([3, 1, 2]) == 3\nassert op_negate_sortabs_len([10]) == 1\nassert op_negate_sortabs_len([2, 4, 6]) == 3\nassert op_negate_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_uniq_add10_dec", "entry_point": "op_uniq_add10_dec", "primitives": ["uniq", "add10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then subtract one from each.", "solution": "def op_uniq_add10_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_add10_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_uniq_add10_dec([]) == []\nassert op_uniq_add10_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_uniq_add10_dec([5, 5, 5]) == [14]\nassert op_uniq_add10_dec([3, 1, 2]) == [12, 10, 11]\nassert op_uniq_add10_dec([10]) == [19]\nassert op_uniq_add10_dec([2, 4, 6]) == [11, 13, 15]\nassert op_uniq_add10_dec([-7, 12, -7]) == [2, 21]"}
{"id": "op_oremptyzero_sorta_takewhilepos", "entry_point": "op_oremptyzero_sorta_takewhilepos", "primitives": ["oremptyzero", "sorta", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then take values while they are positive.", "solution": "def op_oremptyzero_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_sorta_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sorta_takewhilepos([]) == []\nassert op_oremptyzero_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_sorta_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sorta_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sorta_takewhilepos([10]) == [10]\nassert op_oremptyzero_sorta_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sorta_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_add10_sortd_absval", "entry_point": "op_add10_sortd_absval", "primitives": ["add10", "sortd", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort descending, then take the absolute value of each.", "solution": "def op_add10_sortd_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_sortd_absval([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_sortd_absval([]) == []\nassert op_add10_sortd_absval([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_sortd_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortd_absval([3, 1, 2]) == [13, 12, 11]\nassert op_add10_sortd_absval([10]) == [20]\nassert op_add10_sortd_absval([2, 4, 6]) == [16, 14, 12]\nassert op_add10_sortd_absval([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_add10_sorta_sortd", "entry_point": "op_add10_sorta_sortd", "primitives": ["add10", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then sort descending.", "solution": "def op_add10_sorta_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_sorta_sortd([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_sorta_sortd([]) == []\nassert op_add10_sorta_sortd([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_sorta_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sorta_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_add10_sorta_sortd([10]) == [20]\nassert op_add10_sorta_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_add10_sorta_sortd([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_strip_sortalpha_lens", "entry_point": "op_strip_sortalpha_lens", "primitives": ["strip", "sortalpha", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort alphabetically, then return the total number of characters.", "solution": "def op_strip_sortalpha_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r)\n    return sum(len(s) for s in r)", "tests": "assert op_strip_sortalpha_lens(['Hello', 'world']) == 10\nassert op_strip_sortalpha_lens([]) == 0\nassert op_strip_sortalpha_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_strip_sortalpha_lens(['one', 'one', 'Two']) == 9\nassert op_strip_sortalpha_lens(['x']) == 1\nassert op_strip_sortalpha_lens(['abc', 'de', '']) == 5"}
{"id": "op_ages_negate_double", "entry_point": "op_ages_negate_double", "primitives": ["ages", "negate", "double"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then double each.", "solution": "def op_ages_negate_double(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_ages_negate_double([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-72, -24]\nassert op_ages_negate_double([]) == []\nassert op_ages_negate_double([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-36, -130, -34]\nassert op_ages_negate_double([{'name': 'Fi', 'age': 41}]) == [-82]"}
{"id": "op_dropzeros_first3_anyeven", "entry_point": "op_dropzeros_first3_anyeven", "primitives": ["dropzeros", "first3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then return whether any value is even.", "solution": "def op_dropzeros_first3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_first3_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_first3_anyeven([]) == False\nassert op_dropzeros_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_first3_anyeven([5, 5, 5]) == False\nassert op_dropzeros_first3_anyeven([3, 1, 2]) == True\nassert op_dropzeros_first3_anyeven([10]) == True\nassert op_dropzeros_first3_anyeven([2, 4, 6]) == True\nassert op_dropzeros_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_neg_odds_sortabs", "entry_point": "op_neg_odds_sortabs", "primitives": ["neg", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then sort by absolute value.", "solution": "def op_neg_odds_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_odds_sortabs([1, 2, 3, 4]) == []\nassert op_neg_odds_sortabs([]) == []\nassert op_neg_odds_sortabs([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_odds_sortabs([5, 5, 5]) == []\nassert op_neg_odds_sortabs([3, 1, 2]) == []\nassert op_neg_odds_sortabs([10]) == []\nassert op_neg_odds_sortabs([2, 4, 6]) == []\nassert op_neg_odds_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_trimends_beforezero", "entry_point": "op_neg_trimends_beforezero", "primitives": ["neg", "trimends", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_neg_trimends_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_trimends_beforezero([1, 2, 3, 4]) == []\nassert op_neg_trimends_beforezero([]) == []\nassert op_neg_trimends_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_beforezero([5, 5, 5]) == []\nassert op_neg_trimends_beforezero([3, 1, 2]) == []\nassert op_neg_trimends_beforezero([10]) == []\nassert op_neg_trimends_beforezero([2, 4, 6]) == []\nassert op_neg_trimends_beforezero([-7, 12, -7]) == []"}
{"id": "op_negate_odds_oremptyzero", "entry_point": "op_negate_odds_oremptyzero", "primitives": ["negate", "odds", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then if empty, use a single zero.", "solution": "def op_negate_odds_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_odds_oremptyzero([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_odds_oremptyzero([]) == [0]\nassert op_negate_odds_oremptyzero([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_odds_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_odds_oremptyzero([3, 1, 2]) == [-3, -1]\nassert op_negate_odds_oremptyzero([10]) == [0]\nassert op_negate_odds_oremptyzero([2, 4, 6]) == [0]\nassert op_negate_odds_oremptyzero([-7, 12, -7]) == [7, 7]"}
{"id": "op_sorta_sortabs_haszero", "entry_point": "op_sorta_sortabs_haszero", "primitives": ["sorta", "sortabs", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then return whether the list contains a zero.", "solution": "def op_sorta_sortabs_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_sorta_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_sorta_sortabs_haszero([]) == False\nassert op_sorta_sortabs_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_sortabs_haszero([5, 5, 5]) == False\nassert op_sorta_sortabs_haszero([3, 1, 2]) == False\nassert op_sorta_sortabs_haszero([10]) == False\nassert op_sorta_sortabs_haszero([2, 4, 6]) == False\nassert op_sorta_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_clamp10_last3", "entry_point": "op_sorta_clamp10_last3", "primitives": ["sorta", "clamp10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then keep only the last three.", "solution": "def op_sorta_clamp10_last3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_sorta_clamp10_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_clamp10_last3([]) == []\nassert op_sorta_clamp10_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sorta_clamp10_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_last3([10]) == [10]\nassert op_sorta_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_last3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_square_uniq_min", "entry_point": "op_square_uniq_min", "primitives": ["square", "uniq", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_square_uniq_min(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_square_uniq_min([1, 2, 3, 4]) == 1\nassert op_square_uniq_min([]) == 0\nassert op_square_uniq_min([-2, -1, 0, 1, 2]) == 0\nassert op_square_uniq_min([5, 5, 5]) == 25\nassert op_square_uniq_min([3, 1, 2]) == 1\nassert op_square_uniq_min([10]) == 100\nassert op_square_uniq_min([2, 4, 6]) == 4\nassert op_square_uniq_min([-7, 12, -7]) == 49"}
{"id": "op_dropzeros_div3_first3", "entry_point": "op_dropzeros_div3_first3", "primitives": ["dropzeros", "div3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then keep only the first three.", "solution": "def op_dropzeros_div3_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_div3_first3([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_first3([]) == []\nassert op_dropzeros_div3_first3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_first3([5, 5, 5]) == []\nassert op_dropzeros_div3_first3([3, 1, 2]) == [3]\nassert op_dropzeros_div3_first3([10]) == []\nassert op_dropzeros_div3_first3([2, 4, 6]) == [6]\nassert op_dropzeros_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_odds_div3_dropfirst", "entry_point": "op_odds_div3_dropfirst", "primitives": ["odds", "div3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then drop the first element.", "solution": "def op_odds_div3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_odds_div3_dropfirst([1, 2, 3, 4]) == []\nassert op_odds_div3_dropfirst([]) == []\nassert op_odds_div3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_dropfirst([5, 5, 5]) == []\nassert op_odds_div3_dropfirst([3, 1, 2]) == []\nassert op_odds_div3_dropfirst([10]) == []\nassert op_odds_div3_dropfirst([2, 4, 6]) == []\nassert op_odds_div3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_rev_dec", "entry_point": "op_add10_rev_dec", "primitives": ["add10", "rev", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then subtract one from each.", "solution": "def op_add10_rev_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_rev_dec([1, 2, 3, 4]) == [13, 12, 11, 10]\nassert op_add10_rev_dec([]) == []\nassert op_add10_rev_dec([-2, -1, 0, 1, 2]) == [11, 10, 9, 8, 7]\nassert op_add10_rev_dec([5, 5, 5]) == [14, 14, 14]\nassert op_add10_rev_dec([3, 1, 2]) == [11, 10, 12]\nassert op_add10_rev_dec([10]) == [19]\nassert op_add10_rev_dec([2, 4, 6]) == [15, 13, 11]\nassert op_add10_rev_dec([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_ages_odds_pos", "entry_point": "op_ages_odds_pos", "primitives": ["ages", "odds", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then keep the positive numbers.", "solution": "def op_ages_odds_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_odds_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_odds_pos([]) == []\nassert op_ages_odds_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_odds_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_pos_absval_inc", "entry_point": "op_pos_absval_inc", "primitives": ["pos", "absval", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then add one to each.", "solution": "def op_pos_absval_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_pos_absval_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_pos_absval_inc([]) == []\nassert op_pos_absval_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_pos_absval_inc([5, 5, 5]) == [6, 6, 6]\nassert op_pos_absval_inc([3, 1, 2]) == [4, 2, 3]\nassert op_pos_absval_inc([10]) == [11]\nassert op_pos_absval_inc([2, 4, 6]) == [3, 5, 7]\nassert op_pos_absval_inc([-7, 12, -7]) == [13]"}
{"id": "op_double_trimends_len", "entry_point": "op_double_trimends_len", "primitives": ["double", "trimends", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then return how many remain.", "solution": "def op_double_trimends_len(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_double_trimends_len([1, 2, 3, 4]) == 2\nassert op_double_trimends_len([]) == 0\nassert op_double_trimends_len([-2, -1, 0, 1, 2]) == 3\nassert op_double_trimends_len([5, 5, 5]) == 1\nassert op_double_trimends_len([3, 1, 2]) == 1\nassert op_double_trimends_len([10]) == 0\nassert op_double_trimends_len([2, 4, 6]) == 1\nassert op_double_trimends_len([-7, 12, -7]) == 1"}
{"id": "op_uniq_dropfirst_takewhilepos", "entry_point": "op_uniq_dropfirst_takewhilepos", "primitives": ["uniq", "dropfirst", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then take values while they are positive.", "solution": "def op_uniq_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_dropfirst_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_dropfirst_takewhilepos([]) == []\nassert op_uniq_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_dropfirst_takewhilepos([5, 5, 5]) == []\nassert op_uniq_dropfirst_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_uniq_dropfirst_takewhilepos([10]) == []\nassert op_uniq_dropfirst_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_uniq_dropfirst_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_trimends_beforezero_rev", "entry_point": "op_trimends_beforezero_rev", "primitives": ["trimends", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then reverse the order.", "solution": "def op_trimends_beforezero_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_beforezero_rev([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_beforezero_rev([]) == []\nassert op_trimends_beforezero_rev([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero_rev([5, 5, 5]) == [5]\nassert op_trimends_beforezero_rev([3, 1, 2]) == [1]\nassert op_trimends_beforezero_rev([10]) == []\nassert op_trimends_beforezero_rev([2, 4, 6]) == [4]\nassert op_trimends_beforezero_rev([-7, 12, -7]) == [12]"}
{"id": "op_inc_pos_odds", "entry_point": "op_inc_pos_odds", "primitives": ["inc", "pos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_inc_pos_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_pos_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_pos_odds([]) == []\nassert op_inc_pos_odds([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_inc_pos_odds([5, 5, 5]) == []\nassert op_inc_pos_odds([3, 1, 2]) == [3]\nassert op_inc_pos_odds([10]) == [11]\nassert op_inc_pos_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_pos_odds([-7, 12, -7]) == [13]"}
{"id": "op_pos_dropzeros_first3", "entry_point": "op_pos_dropzeros_first3", "primitives": ["pos", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the zeros, then keep only the first three.", "solution": "def op_pos_dropzeros_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_pos_dropzeros_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_dropzeros_first3([]) == []\nassert op_pos_dropzeros_first3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_dropzeros_first3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_dropzeros_first3([10]) == [10]\nassert op_pos_dropzeros_first3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropzeros_first3([-7, 12, -7]) == [12]"}
{"id": "op_odds_square_div3", "entry_point": "op_odds_square_div3", "primitives": ["odds", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then keep multiples of three.", "solution": "def op_odds_square_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_square_div3([1, 2, 3, 4]) == [9]\nassert op_odds_square_div3([]) == []\nassert op_odds_square_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_square_div3([5, 5, 5]) == []\nassert op_odds_square_div3([3, 1, 2]) == [9]\nassert op_odds_square_div3([10]) == []\nassert op_odds_square_div3([2, 4, 6]) == []\nassert op_odds_square_div3([-7, 12, -7]) == []"}
{"id": "op_neg_clamp10_counteven", "entry_point": "op_neg_clamp10_counteven", "primitives": ["neg", "clamp10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then return how many values are even.", "solution": "def op_neg_clamp10_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_clamp10_counteven([1, 2, 3, 4]) == 0\nassert op_neg_clamp10_counteven([]) == 0\nassert op_neg_clamp10_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_clamp10_counteven([5, 5, 5]) == 0\nassert op_neg_clamp10_counteven([3, 1, 2]) == 0\nassert op_neg_clamp10_counteven([10]) == 0\nassert op_neg_clamp10_counteven([2, 4, 6]) == 0\nassert op_neg_clamp10_counteven([-7, 12, -7]) == 0"}
{"id": "op_sorta_div3_max", "entry_point": "op_sorta_div3_max", "primitives": ["sorta", "div3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep multiples of three, then return the maximum (0 if empty).", "solution": "def op_sorta_div3_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return max(r) if r else 0", "tests": "assert op_sorta_div3_max([1, 2, 3, 4]) == 3\nassert op_sorta_div3_max([]) == 0\nassert op_sorta_div3_max([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_div3_max([5, 5, 5]) == 0\nassert op_sorta_div3_max([3, 1, 2]) == 3\nassert op_sorta_div3_max([10]) == 0\nassert op_sorta_div3_max([2, 4, 6]) == 6\nassert op_sorta_div3_max([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_odds_dropfirst", "entry_point": "op_oremptyzero_odds_dropfirst", "primitives": ["oremptyzero", "odds", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then drop the first element.", "solution": "def op_oremptyzero_odds_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_odds_dropfirst([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_odds_dropfirst([]) == []\nassert op_oremptyzero_odds_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_oremptyzero_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_odds_dropfirst([3, 1, 2]) == [1]\nassert op_oremptyzero_odds_dropfirst([10]) == []\nassert op_oremptyzero_odds_dropfirst([2, 4, 6]) == []\nassert op_oremptyzero_odds_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_ages_first3_neg", "entry_point": "op_ages_first3_neg", "primitives": ["ages", "first3", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then keep the negative numbers.", "solution": "def op_ages_first3_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_first3_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_first3_neg([]) == []\nassert op_ages_first3_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_first3_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_trimends_neg_sorta", "entry_point": "op_trimends_neg_sorta", "primitives": ["trimends", "neg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then sort ascending.", "solution": "def op_trimends_neg_sorta(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_trimends_neg_sorta([1, 2, 3, 4]) == []\nassert op_trimends_neg_sorta([]) == []\nassert op_trimends_neg_sorta([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_neg_sorta([5, 5, 5]) == []\nassert op_trimends_neg_sorta([3, 1, 2]) == []\nassert op_trimends_neg_sorta([10]) == []\nassert op_trimends_neg_sorta([2, 4, 6]) == []\nassert op_trimends_neg_sorta([-7, 12, -7]) == []"}
{"id": "op_last3_absval_oremptyzero", "entry_point": "op_last3_absval_oremptyzero", "primitives": ["last3", "absval", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_last3_absval_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_absval_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_absval_oremptyzero([]) == [0]\nassert op_last3_absval_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_absval_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_last3_absval_oremptyzero([10]) == [10]\nassert op_last3_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_last3_absval_oremptyzero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_square_dropfirst_counteven", "entry_point": "op_square_dropfirst_counteven", "primitives": ["square", "dropfirst", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then return how many values are even.", "solution": "def op_square_dropfirst_counteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_square_dropfirst_counteven([1, 2, 3, 4]) == 2\nassert op_square_dropfirst_counteven([]) == 0\nassert op_square_dropfirst_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_square_dropfirst_counteven([5, 5, 5]) == 0\nassert op_square_dropfirst_counteven([3, 1, 2]) == 1\nassert op_square_dropfirst_counteven([10]) == 0\nassert op_square_dropfirst_counteven([2, 4, 6]) == 2\nassert op_square_dropfirst_counteven([-7, 12, -7]) == 1"}
{"id": "op_add10_dec_takewhilepos", "entry_point": "op_add10_dec_takewhilepos", "primitives": ["add10", "dec", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then take values while they are positive.", "solution": "def op_add10_dec_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_add10_dec_takewhilepos([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_dec_takewhilepos([]) == []\nassert op_add10_dec_takewhilepos([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_dec_takewhilepos([5, 5, 5]) == [14, 14, 14]\nassert op_add10_dec_takewhilepos([3, 1, 2]) == [12, 10, 11]\nassert op_add10_dec_takewhilepos([10]) == [19]\nassert op_add10_dec_takewhilepos([2, 4, 6]) == [11, 13, 15]\nassert op_add10_dec_takewhilepos([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_pos_oremptyzero_absval", "entry_point": "op_pos_oremptyzero_absval", "primitives": ["pos", "oremptyzero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero, then take the absolute value of each.", "solution": "def op_pos_oremptyzero_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_oremptyzero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_oremptyzero_absval([]) == [0]\nassert op_pos_oremptyzero_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_pos_oremptyzero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_pos_oremptyzero_absval([10]) == [10]\nassert op_pos_oremptyzero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_pos_oremptyzero_absval([-7, 12, -7]) == [12]"}
{"id": "op_ages_negate_padto3", "entry_point": "op_ages_negate_padto3", "primitives": ["ages", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then pad with zeros to at least three elements.", "solution": "def op_ages_negate_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_negate_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12, 0]\nassert op_ages_negate_padto3([]) == [0, 0, 0]\nassert op_ages_negate_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_negate_padto3([{'name': 'Fi', 'age': 41}]) == [-41, 0, 0]"}
{"id": "op_sorta_beforezero_negate", "entry_point": "op_sorta_beforezero_negate", "primitives": ["sorta", "beforezero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then negate each.", "solution": "def op_sorta_beforezero_negate(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_sorta_beforezero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_beforezero_negate([]) == []\nassert op_sorta_beforezero_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sorta_beforezero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_beforezero_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_beforezero_negate([10]) == [-10]\nassert op_sorta_beforezero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_beforezero_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_neg_trimends_negate", "entry_point": "op_neg_trimends_negate", "primitives": ["neg", "trimends", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then negate each.", "solution": "def op_neg_trimends_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_trimends_negate([1, 2, 3, 4]) == []\nassert op_neg_trimends_negate([]) == []\nassert op_neg_trimends_negate([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_negate([5, 5, 5]) == []\nassert op_neg_trimends_negate([3, 1, 2]) == []\nassert op_neg_trimends_negate([10]) == []\nassert op_neg_trimends_negate([2, 4, 6]) == []\nassert op_neg_trimends_negate([-7, 12, -7]) == []"}
{"id": "op_div3_dropfirst_firsteven", "entry_point": "op_div3_dropfirst_firsteven", "primitives": ["div3", "dropfirst", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then return the first even value (0 if none).", "solution": "def op_div3_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_dropfirst_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_dropfirst_firsteven([]) == 0\nassert op_div3_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_div3_dropfirst_firsteven([3, 1, 2]) == 0\nassert op_div3_dropfirst_firsteven([10]) == 0\nassert op_div3_dropfirst_firsteven([2, 4, 6]) == 0\nassert op_div3_dropfirst_firsteven([-7, 12, -7]) == 0"}
{"id": "op_absval_div3_issorted", "entry_point": "op_absval_div3_issorted", "primitives": ["absval", "div3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_absval_div3_issorted(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_absval_div3_issorted([1, 2, 3, 4]) == True\nassert op_absval_div3_issorted([]) == True\nassert op_absval_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_absval_div3_issorted([5, 5, 5]) == True\nassert op_absval_div3_issorted([3, 1, 2]) == True\nassert op_absval_div3_issorted([10]) == True\nassert op_absval_div3_issorted([2, 4, 6]) == True\nassert op_absval_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_clamp10_takewhilepos_firsteven", "entry_point": "op_clamp10_takewhilepos_firsteven", "primitives": ["clamp10", "takewhilepos", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_clamp10_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_clamp10_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_clamp10_takewhilepos_firsteven([]) == 0\nassert op_clamp10_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_clamp10_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_clamp10_takewhilepos_firsteven([10]) == 10\nassert op_clamp10_takewhilepos_firsteven([2, 4, 6]) == 2\nassert op_clamp10_takewhilepos_firsteven([-7, 12, -7]) == 0"}
{"id": "op_neg_dropfirst_firsteven", "entry_point": "op_neg_dropfirst_firsteven", "primitives": ["neg", "dropfirst", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then return the first even value (0 if none).", "solution": "def op_neg_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_dropfirst_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_dropfirst_firsteven([]) == 0\nassert op_neg_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_neg_dropfirst_firsteven([3, 1, 2]) == 0\nassert op_neg_dropfirst_firsteven([10]) == 0\nassert op_neg_dropfirst_firsteven([2, 4, 6]) == 0\nassert op_neg_dropfirst_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_sorta_pos", "entry_point": "op_dropzeros_sorta_pos", "primitives": ["dropzeros", "sorta", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then keep the positive numbers.", "solution": "def op_dropzeros_sorta_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sorta_pos([]) == []\nassert op_dropzeros_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sorta_pos([10]) == [10]\nassert op_dropzeros_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_takewhilepos_square", "entry_point": "op_uniq_takewhilepos_square", "primitives": ["uniq", "takewhilepos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then square each.", "solution": "def op_uniq_takewhilepos_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_takewhilepos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_takewhilepos_square([]) == []\nassert op_uniq_takewhilepos_square([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos_square([5, 5, 5]) == [25]\nassert op_uniq_takewhilepos_square([3, 1, 2]) == [9, 1, 4]\nassert op_uniq_takewhilepos_square([10]) == [100]\nassert op_uniq_takewhilepos_square([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_takewhilepos_square([-7, 12, -7]) == []"}
{"id": "op_rev_double_anyeven", "entry_point": "op_rev_double_anyeven", "primitives": ["rev", "double", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then return whether any value is even.", "solution": "def op_rev_double_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_double_anyeven([1, 2, 3, 4]) == True\nassert op_rev_double_anyeven([]) == False\nassert op_rev_double_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_double_anyeven([5, 5, 5]) == True\nassert op_rev_double_anyeven([3, 1, 2]) == True\nassert op_rev_double_anyeven([10]) == True\nassert op_rev_double_anyeven([2, 4, 6]) == True\nassert op_rev_double_anyeven([-7, 12, -7]) == True"}
{"id": "op_dec_uniq_min", "entry_point": "op_dec_uniq_min", "primitives": ["dec", "uniq", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_dec_uniq_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_dec_uniq_min([1, 2, 3, 4]) == 0\nassert op_dec_uniq_min([]) == 0\nassert op_dec_uniq_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_uniq_min([5, 5, 5]) == 4\nassert op_dec_uniq_min([3, 1, 2]) == 0\nassert op_dec_uniq_min([10]) == 9\nassert op_dec_uniq_min([2, 4, 6]) == 1\nassert op_dec_uniq_min([-7, 12, -7]) == -8"}
{"id": "op_first3_trimends_takewhilepos", "entry_point": "op_first3_trimends_takewhilepos", "primitives": ["first3", "trimends", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then take values while they are positive.", "solution": "def op_first3_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_first3_trimends_takewhilepos([1, 2, 3, 4]) == [2]\nassert op_first3_trimends_takewhilepos([]) == []\nassert op_first3_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_first3_trimends_takewhilepos([5, 5, 5]) == [5]\nassert op_first3_trimends_takewhilepos([3, 1, 2]) == [1]\nassert op_first3_trimends_takewhilepos([10]) == []\nassert op_first3_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_first3_trimends_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_sorta_len", "entry_point": "op_dropzeros_sorta_len", "primitives": ["dropzeros", "sorta", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then return how many remain.", "solution": "def op_dropzeros_sorta_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    return len(r)", "tests": "assert op_dropzeros_sorta_len([1, 2, 3, 4]) == 4\nassert op_dropzeros_sorta_len([]) == 0\nassert op_dropzeros_sorta_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_sorta_len([5, 5, 5]) == 3\nassert op_dropzeros_sorta_len([3, 1, 2]) == 3\nassert op_dropzeros_sorta_len([10]) == 1\nassert op_dropzeros_sorta_len([2, 4, 6]) == 3\nassert op_dropzeros_sorta_len([-7, 12, -7]) == 3"}
{"id": "op_trimends_takewhilepos_dropfirst", "entry_point": "op_trimends_takewhilepos_dropfirst", "primitives": ["trimends", "takewhilepos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive, then drop the first element.", "solution": "def op_trimends_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_takewhilepos_dropfirst([1, 2, 3, 4]) == [3]\nassert op_trimends_takewhilepos_dropfirst([]) == []\nassert op_trimends_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_trimends_takewhilepos_dropfirst([5, 5, 5]) == []\nassert op_trimends_takewhilepos_dropfirst([3, 1, 2]) == []\nassert op_trimends_takewhilepos_dropfirst([10]) == []\nassert op_trimends_takewhilepos_dropfirst([2, 4, 6]) == []\nassert op_trimends_takewhilepos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_dropfirst_inc_rev", "entry_point": "op_dropfirst_inc_rev", "primitives": ["dropfirst", "inc", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add one to each, then reverse the order.", "solution": "def op_dropfirst_inc_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_inc_rev([1, 2, 3, 4]) == [5, 4, 3]\nassert op_dropfirst_inc_rev([]) == []\nassert op_dropfirst_inc_rev([-2, -1, 0, 1, 2]) == [3, 2, 1, 0]\nassert op_dropfirst_inc_rev([5, 5, 5]) == [6, 6]\nassert op_dropfirst_inc_rev([3, 1, 2]) == [3, 2]\nassert op_dropfirst_inc_rev([10]) == []\nassert op_dropfirst_inc_rev([2, 4, 6]) == [7, 5]\nassert op_dropfirst_inc_rev([-7, 12, -7]) == [-6, 13]"}
{"id": "op_double_square_sorta", "entry_point": "op_double_square_sorta", "primitives": ["double", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then sort ascending.", "solution": "def op_double_square_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_double_square_sorta([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_double_square_sorta([]) == []\nassert op_double_square_sorta([-2, -1, 0, 1, 2]) == [0, 4, 4, 16, 16]\nassert op_double_square_sorta([5, 5, 5]) == [100, 100, 100]\nassert op_double_square_sorta([3, 1, 2]) == [4, 16, 36]\nassert op_double_square_sorta([10]) == [400]\nassert op_double_square_sorta([2, 4, 6]) == [16, 64, 144]\nassert op_double_square_sorta([-7, 12, -7]) == [196, 196, 576]"}
{"id": "op_oremptyzero_add10_len", "entry_point": "op_oremptyzero_add10_len", "primitives": ["oremptyzero", "add10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then return how many remain.", "solution": "def op_oremptyzero_add10_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_oremptyzero_add10_len([1, 2, 3, 4]) == 4\nassert op_oremptyzero_add10_len([]) == 1\nassert op_oremptyzero_add10_len([-2, -1, 0, 1, 2]) == 5\nassert op_oremptyzero_add10_len([5, 5, 5]) == 3\nassert op_oremptyzero_add10_len([3, 1, 2]) == 3\nassert op_oremptyzero_add10_len([10]) == 1\nassert op_oremptyzero_add10_len([2, 4, 6]) == 3\nassert op_oremptyzero_add10_len([-7, 12, -7]) == 3"}
{"id": "op_uniq_sorta_gt5", "entry_point": "op_uniq_sorta_gt5", "primitives": ["uniq", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then keep values greater than five.", "solution": "def op_uniq_sorta_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_sorta_gt5([1, 2, 3, 4]) == []\nassert op_uniq_sorta_gt5([]) == []\nassert op_uniq_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_sorta_gt5([5, 5, 5]) == []\nassert op_uniq_sorta_gt5([3, 1, 2]) == []\nassert op_uniq_sorta_gt5([10]) == [10]\nassert op_uniq_sorta_gt5([2, 4, 6]) == [6]\nassert op_uniq_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_square_takewhilepos_haszero", "entry_point": "op_square_takewhilepos_haszero", "primitives": ["square", "takewhilepos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then return whether the list contains a zero.", "solution": "def op_square_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_square_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_square_takewhilepos_haszero([]) == False\nassert op_square_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_square_takewhilepos_haszero([5, 5, 5]) == False\nassert op_square_takewhilepos_haszero([3, 1, 2]) == False\nassert op_square_takewhilepos_haszero([10]) == False\nassert op_square_takewhilepos_haszero([2, 4, 6]) == False\nassert op_square_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_names_prefixup_firstchar", "entry_point": "op_names_prefixup_firstchar", "primitives": ["names", "prefixup", "firstchar"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then prefix each with a hash, then keep the first character of each (dropping empties).", "solution": "def op_names_prefixup_firstchar(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = ['#' + s for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_names_prefixup_firstchar([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['#', '#']\nassert op_names_prefixup_firstchar([]) == []\nassert op_names_prefixup_firstchar([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['#', '#', '#']\nassert op_names_prefixup_firstchar([{'name': 'Fi', 'age': 41}]) == ['#']"}
{"id": "op_uniq_double_firsteven", "entry_point": "op_uniq_double_firsteven", "primitives": ["uniq", "double", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then return the first even value (0 if none).", "solution": "def op_uniq_double_firsteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_uniq_double_firsteven([1, 2, 3, 4]) == 2\nassert op_uniq_double_firsteven([]) == 0\nassert op_uniq_double_firsteven([-2, -1, 0, 1, 2]) == -4\nassert op_uniq_double_firsteven([5, 5, 5]) == 10\nassert op_uniq_double_firsteven([3, 1, 2]) == 6\nassert op_uniq_double_firsteven([10]) == 20\nassert op_uniq_double_firsteven([2, 4, 6]) == 4\nassert op_uniq_double_firsteven([-7, 12, -7]) == -14"}
{"id": "op_neg_clamp10_sortabs", "entry_point": "op_neg_clamp10_sortabs", "primitives": ["neg", "clamp10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then sort by absolute value.", "solution": "def op_neg_clamp10_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_clamp10_sortabs([1, 2, 3, 4]) == []\nassert op_neg_clamp10_sortabs([]) == []\nassert op_neg_clamp10_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_clamp10_sortabs([5, 5, 5]) == []\nassert op_neg_clamp10_sortabs([3, 1, 2]) == []\nassert op_neg_clamp10_sortabs([10]) == []\nassert op_neg_clamp10_sortabs([2, 4, 6]) == []\nassert op_neg_clamp10_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_strip_lower_uniqs", "entry_point": "op_strip_lower_uniqs", "primitives": ["strip", "lower", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then lowercase each string, then drop duplicate strings keeping the first.", "solution": "def op_strip_lower_uniqs(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_strip_lower_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_strip_lower_uniqs([]) == []\nassert op_strip_lower_uniqs(['  a ', '', 'BC', 'bc']) == ['a', '', 'bc']\nassert op_strip_lower_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_strip_lower_uniqs(['x']) == ['x']\nassert op_strip_lower_uniqs(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_square_add10_sorta", "entry_point": "op_square_add10_sorta", "primitives": ["square", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each, then sort ascending.", "solution": "def op_square_add10_sorta(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_square_add10_sorta([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_square_add10_sorta([]) == []\nassert op_square_add10_sorta([-2, -1, 0, 1, 2]) == [10, 11, 11, 14, 14]\nassert op_square_add10_sorta([5, 5, 5]) == [35, 35, 35]\nassert op_square_add10_sorta([3, 1, 2]) == [11, 14, 19]\nassert op_square_add10_sorta([10]) == [110]\nassert op_square_add10_sorta([2, 4, 6]) == [14, 26, 46]\nassert op_square_add10_sorta([-7, 12, -7]) == [59, 59, 154]"}
{"id": "op_dec_dropfirst_last3", "entry_point": "op_dec_dropfirst_last3", "primitives": ["dec", "dropfirst", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first element, then keep only the last three.", "solution": "def op_dec_dropfirst_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_dropfirst_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropfirst_last3([]) == []\nassert op_dec_dropfirst_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dec_dropfirst_last3([5, 5, 5]) == [4, 4]\nassert op_dec_dropfirst_last3([3, 1, 2]) == [0, 1]\nassert op_dec_dropfirst_last3([10]) == []\nassert op_dec_dropfirst_last3([2, 4, 6]) == [3, 5]\nassert op_dec_dropfirst_last3([-7, 12, -7]) == [11, -8]"}
{"id": "op_dropwhileneg_padto3_dropfirst", "entry_point": "op_dropwhileneg_padto3_dropfirst", "primitives": ["dropwhileneg", "padto3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_dropwhileneg_padto3_dropfirst(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_dropwhileneg_padto3_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_padto3_dropfirst([]) == [0, 0]\nassert op_dropwhileneg_padto3_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_padto3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_padto3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropwhileneg_padto3_dropfirst([10]) == [0, 0]\nassert op_dropwhileneg_padto3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropwhileneg_padto3_dropfirst([-7, 12, -7]) == [-7, 0]"}
{"id": "op_oremptyzero_pos_dropwhileneg", "entry_point": "op_oremptyzero_pos_dropwhileneg", "primitives": ["oremptyzero", "pos", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then drop the leading negative values.", "solution": "def op_oremptyzero_pos_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_pos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_pos_dropwhileneg([]) == []\nassert op_oremptyzero_pos_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_oremptyzero_pos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_pos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_pos_dropwhileneg([10]) == [10]\nassert op_oremptyzero_pos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_pos_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_gt5_rev_evens", "entry_point": "op_gt5_rev_evens", "primitives": ["gt5", "rev", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then keep the even numbers.", "solution": "def op_gt5_rev_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_gt5_rev_evens([1, 2, 3, 4]) == []\nassert op_gt5_rev_evens([]) == []\nassert op_gt5_rev_evens([-2, -1, 0, 1, 2]) == []\nassert op_gt5_rev_evens([5, 5, 5]) == []\nassert op_gt5_rev_evens([3, 1, 2]) == []\nassert op_gt5_rev_evens([10]) == [10]\nassert op_gt5_rev_evens([2, 4, 6]) == [6]\nassert op_gt5_rev_evens([-7, 12, -7]) == [12]"}
{"id": "op_padto3_inc_last3", "entry_point": "op_padto3_inc_last3", "primitives": ["padto3", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then keep only the last three.", "solution": "def op_padto3_inc_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_inc_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_padto3_inc_last3([]) == [1, 1, 1]\nassert op_padto3_inc_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_padto3_inc_last3([5, 5, 5]) == [6, 6, 6]\nassert op_padto3_inc_last3([3, 1, 2]) == [4, 2, 3]\nassert op_padto3_inc_last3([10]) == [11, 1, 1]\nassert op_padto3_inc_last3([2, 4, 6]) == [3, 5, 7]\nassert op_padto3_inc_last3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropzeros_sortabs_padto3", "entry_point": "op_dropzeros_sortabs_padto3", "primitives": ["dropzeros", "sortabs", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_sortabs_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_sortabs_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sortabs_padto3([]) == [0, 0, 0]\nassert op_dropzeros_sortabs_padto3([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_dropzeros_sortabs_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortabs_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sortabs_padto3([10]) == [10, 0, 0]\nassert op_dropzeros_sortabs_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sortabs_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_uniq_max", "entry_point": "op_sortabs_uniq_max", "primitives": ["sortabs", "uniq", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_sortabs_uniq_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_sortabs_uniq_max([1, 2, 3, 4]) == 4\nassert op_sortabs_uniq_max([]) == 0\nassert op_sortabs_uniq_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_uniq_max([5, 5, 5]) == 5\nassert op_sortabs_uniq_max([3, 1, 2]) == 3\nassert op_sortabs_uniq_max([10]) == 10\nassert op_sortabs_uniq_max([2, 4, 6]) == 6\nassert op_sortabs_uniq_max([-7, 12, -7]) == 12"}
{"id": "op_dec_gt5_padto3", "entry_point": "op_dec_gt5_padto3", "primitives": ["dec", "gt5", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then pad with zeros to at least three elements.", "solution": "def op_dec_gt5_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_gt5_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_dec_gt5_padto3([]) == [0, 0, 0]\nassert op_dec_gt5_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_dec_gt5_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_dec_gt5_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_dec_gt5_padto3([10]) == [9, 0, 0]\nassert op_dec_gt5_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_dec_gt5_padto3([-7, 12, -7]) == [11, 0, 0]"}
{"id": "op_dropzeros_rev_inc", "entry_point": "op_dropzeros_rev_inc", "primitives": ["dropzeros", "rev", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then add one to each.", "solution": "def op_dropzeros_rev_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropzeros_rev_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_dropzeros_rev_inc([]) == []\nassert op_dropzeros_rev_inc([-2, -1, 0, 1, 2]) == [3, 2, 0, -1]\nassert op_dropzeros_rev_inc([5, 5, 5]) == [6, 6, 6]\nassert op_dropzeros_rev_inc([3, 1, 2]) == [3, 2, 4]\nassert op_dropzeros_rev_inc([10]) == [11]\nassert op_dropzeros_rev_inc([2, 4, 6]) == [7, 5, 3]\nassert op_dropzeros_rev_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropzeros_div3_takewhilepos", "entry_point": "op_dropzeros_div3_takewhilepos", "primitives": ["dropzeros", "div3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then take values while they are positive.", "solution": "def op_dropzeros_div3_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_div3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_takewhilepos([]) == []\nassert op_dropzeros_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_takewhilepos([5, 5, 5]) == []\nassert op_dropzeros_div3_takewhilepos([3, 1, 2]) == [3]\nassert op_dropzeros_div3_takewhilepos([10]) == []\nassert op_dropzeros_div3_takewhilepos([2, 4, 6]) == [6]\nassert op_dropzeros_div3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_odds_first3_add10", "entry_point": "op_odds_first3_add10", "primitives": ["odds", "first3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three, then add ten to each.", "solution": "def op_odds_first3_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_odds_first3_add10([1, 2, 3, 4]) == [11, 13]\nassert op_odds_first3_add10([]) == []\nassert op_odds_first3_add10([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_first3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_odds_first3_add10([3, 1, 2]) == [13, 11]\nassert op_odds_first3_add10([10]) == []\nassert op_odds_first3_add10([2, 4, 6]) == []\nassert op_odds_first3_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_uniq_dropzeros_beforezero", "entry_point": "op_uniq_dropzeros_beforezero", "primitives": ["uniq", "dropzeros", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then keep everything before the first zero.", "solution": "def op_uniq_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_dropzeros_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_dropzeros_beforezero([]) == []\nassert op_uniq_dropzeros_beforezero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_uniq_dropzeros_beforezero([5, 5, 5]) == [5]\nassert op_uniq_dropzeros_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_dropzeros_beforezero([10]) == [10]\nassert op_uniq_dropzeros_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_dropzeros_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_evens_dec_gt5", "entry_point": "op_evens_dec_gt5", "primitives": ["evens", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then subtract one from each, then keep values greater than five.", "solution": "def op_evens_dec_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_dec_gt5([1, 2, 3, 4]) == []\nassert op_evens_dec_gt5([]) == []\nassert op_evens_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_dec_gt5([5, 5, 5]) == []\nassert op_evens_dec_gt5([3, 1, 2]) == []\nassert op_evens_dec_gt5([10]) == [9]\nassert op_evens_dec_gt5([2, 4, 6]) == []\nassert op_evens_dec_gt5([-7, 12, -7]) == [11]"}
{"id": "op_odds_add10_min", "entry_point": "op_odds_add10_min", "primitives": ["odds", "add10", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_odds_add10_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_odds_add10_min([1, 2, 3, 4]) == 11\nassert op_odds_add10_min([]) == 0\nassert op_odds_add10_min([-2, -1, 0, 1, 2]) == 9\nassert op_odds_add10_min([5, 5, 5]) == 15\nassert op_odds_add10_min([3, 1, 2]) == 11\nassert op_odds_add10_min([10]) == 0\nassert op_odds_add10_min([2, 4, 6]) == 0\nassert op_odds_add10_min([-7, 12, -7]) == 3"}
{"id": "op_sorta_double_haszero", "entry_point": "op_sorta_double_haszero", "primitives": ["sorta", "double", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each, then return whether the list contains a zero.", "solution": "def op_sorta_double_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_sorta_double_haszero([1, 2, 3, 4]) == False\nassert op_sorta_double_haszero([]) == False\nassert op_sorta_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_double_haszero([5, 5, 5]) == False\nassert op_sorta_double_haszero([3, 1, 2]) == False\nassert op_sorta_double_haszero([10]) == False\nassert op_sorta_double_haszero([2, 4, 6]) == False\nassert op_sorta_double_haszero([-7, 12, -7]) == False"}
{"id": "op_double_dropfirst_anyeven", "entry_point": "op_double_dropfirst_anyeven", "primitives": ["double", "dropfirst", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then return whether any value is even.", "solution": "def op_double_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_double_dropfirst_anyeven([]) == False\nassert op_double_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_double_dropfirst_anyeven([5, 5, 5]) == True\nassert op_double_dropfirst_anyeven([3, 1, 2]) == True\nassert op_double_dropfirst_anyeven([10]) == False\nassert op_double_dropfirst_anyeven([2, 4, 6]) == True\nassert op_double_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_takewhilepos_sorta", "entry_point": "op_uniq_takewhilepos_sorta", "primitives": ["uniq", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then sort ascending.", "solution": "def op_uniq_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_takewhilepos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_takewhilepos_sorta([]) == []\nassert op_uniq_takewhilepos_sorta([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos_sorta([5, 5, 5]) == [5]\nassert op_uniq_takewhilepos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_takewhilepos_sorta([10]) == [10]\nassert op_uniq_takewhilepos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_takewhilepos_sorta([-7, 12, -7]) == []"}
{"id": "op_add10_uniq_sorta", "entry_point": "op_add10_uniq_sorta", "primitives": ["add10", "uniq", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then sort ascending.", "solution": "def op_add10_uniq_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return r", "tests": "assert op_add10_uniq_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_uniq_sorta([]) == []\nassert op_add10_uniq_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_uniq_sorta([5, 5, 5]) == [15]\nassert op_add10_uniq_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_uniq_sorta([10]) == [20]\nassert op_add10_uniq_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_uniq_sorta([-7, 12, -7]) == [3, 22]"}
{"id": "op_gt5_sorta_first3", "entry_point": "op_gt5_sorta_first3", "primitives": ["gt5", "sorta", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then keep only the first three.", "solution": "def op_gt5_sorta_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = r[:3]\n    return r", "tests": "assert op_gt5_sorta_first3([1, 2, 3, 4]) == []\nassert op_gt5_sorta_first3([]) == []\nassert op_gt5_sorta_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_first3([5, 5, 5]) == []\nassert op_gt5_sorta_first3([3, 1, 2]) == []\nassert op_gt5_sorta_first3([10]) == [10]\nassert op_gt5_sorta_first3([2, 4, 6]) == [6]\nassert op_gt5_sorta_first3([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_negate_min", "entry_point": "op_sortabs_negate_min", "primitives": ["sortabs", "negate", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then negate each, then return the minimum (0 if empty).", "solution": "def op_sortabs_negate_min(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return min(r) if r else 0", "tests": "assert op_sortabs_negate_min([1, 2, 3, 4]) == -4\nassert op_sortabs_negate_min([]) == 0\nassert op_sortabs_negate_min([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_negate_min([5, 5, 5]) == -5\nassert op_sortabs_negate_min([3, 1, 2]) == -3\nassert op_sortabs_negate_min([10]) == -10\nassert op_sortabs_negate_min([2, 4, 6]) == -6\nassert op_sortabs_negate_min([-7, 12, -7]) == -12"}
{"id": "op_pos_div3_min", "entry_point": "op_pos_div3_min", "primitives": ["pos", "div3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_pos_div3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_pos_div3_min([1, 2, 3, 4]) == 3\nassert op_pos_div3_min([]) == 0\nassert op_pos_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_pos_div3_min([5, 5, 5]) == 0\nassert op_pos_div3_min([3, 1, 2]) == 3\nassert op_pos_div3_min([10]) == 0\nassert op_pos_div3_min([2, 4, 6]) == 6\nassert op_pos_div3_min([-7, 12, -7]) == 12"}
{"id": "op_odds_gt5_clamp10", "entry_point": "op_odds_gt5_clamp10", "primitives": ["odds", "gt5", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep values greater than five, then cap each value at 10.", "solution": "def op_odds_gt5_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_odds_gt5_clamp10([1, 2, 3, 4]) == []\nassert op_odds_gt5_clamp10([]) == []\nassert op_odds_gt5_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_odds_gt5_clamp10([5, 5, 5]) == []\nassert op_odds_gt5_clamp10([3, 1, 2]) == []\nassert op_odds_gt5_clamp10([10]) == []\nassert op_odds_gt5_clamp10([2, 4, 6]) == []\nassert op_odds_gt5_clamp10([-7, 12, -7]) == []"}
{"id": "op_sortabs_sorta_square", "entry_point": "op_sortabs_sorta_square", "primitives": ["sortabs", "sorta", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then square each.", "solution": "def op_sortabs_sorta_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_sorta_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_sorta_square([]) == []\nassert op_sortabs_sorta_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sortabs_sorta_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_sorta_square([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_sorta_square([10]) == [100]\nassert op_sortabs_sorta_square([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_sorta_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_ages_takewhilepos_oremptyzero", "entry_point": "op_ages_takewhilepos_oremptyzero", "primitives": ["ages", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_ages_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_takewhilepos_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos_oremptyzero([]) == [0]\nassert op_ages_takewhilepos_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_neg_clamp10_issorted", "entry_point": "op_neg_clamp10_issorted", "primitives": ["neg", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_neg_clamp10_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_neg_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_neg_clamp10_issorted([]) == True\nassert op_neg_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_neg_clamp10_issorted([5, 5, 5]) == True\nassert op_neg_clamp10_issorted([3, 1, 2]) == True\nassert op_neg_clamp10_issorted([10]) == True\nassert op_neg_clamp10_issorted([2, 4, 6]) == True\nassert op_neg_clamp10_issorted([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_clamp10_counteven", "entry_point": "op_oremptyzero_clamp10_counteven", "primitives": ["oremptyzero", "clamp10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then return how many values are even.", "solution": "def op_oremptyzero_clamp10_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_clamp10_counteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_clamp10_counteven([]) == 1\nassert op_oremptyzero_clamp10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_oremptyzero_clamp10_counteven([5, 5, 5]) == 0\nassert op_oremptyzero_clamp10_counteven([3, 1, 2]) == 1\nassert op_oremptyzero_clamp10_counteven([10]) == 1\nassert op_oremptyzero_clamp10_counteven([2, 4, 6]) == 3\nassert op_oremptyzero_clamp10_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_inc_takewhilepos", "entry_point": "op_sortd_inc_takewhilepos", "primitives": ["sortd", "inc", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then take values while they are positive.", "solution": "def op_sortd_inc_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_inc_takewhilepos([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_inc_takewhilepos([]) == []\nassert op_sortd_inc_takewhilepos([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_sortd_inc_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_inc_takewhilepos([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_inc_takewhilepos([10]) == [11]\nassert op_sortd_inc_takewhilepos([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_inc_takewhilepos([-7, 12, -7]) == [13]"}
{"id": "op_ages_div3_uniq", "entry_point": "op_ages_div3_uniq", "primitives": ["ages", "div3", "uniq"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three, then drop duplicates keeping first occurrence.", "solution": "def op_ages_div3_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_div3_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_div3_uniq([]) == []\nassert op_ages_div3_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_div3_uniq([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_pos_clamp10_first3", "entry_point": "op_pos_clamp10_first3", "primitives": ["pos", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then keep only the first three.", "solution": "def op_pos_clamp10_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_pos_clamp10_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_pos_clamp10_first3([]) == []\nassert op_pos_clamp10_first3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_clamp10_first3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_clamp10_first3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10_first3([10]) == [10]\nassert op_pos_clamp10_first3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10_first3([-7, 12, -7]) == [10]"}
{"id": "op_oremptyzero_last3_first3", "entry_point": "op_oremptyzero_last3_first3", "primitives": ["oremptyzero", "last3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then keep only the first three.", "solution": "def op_oremptyzero_last3_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_last3_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_last3_first3([]) == [0]\nassert op_oremptyzero_last3_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_last3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_last3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_last3_first3([10]) == [10]\nassert op_oremptyzero_last3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_last3_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_add10_neg_sum", "entry_point": "op_add10_neg_sum", "primitives": ["add10", "neg", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then return their sum.", "solution": "def op_add10_neg_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_add10_neg_sum([1, 2, 3, 4]) == 0\nassert op_add10_neg_sum([]) == 0\nassert op_add10_neg_sum([-2, -1, 0, 1, 2]) == 0\nassert op_add10_neg_sum([5, 5, 5]) == 0\nassert op_add10_neg_sum([3, 1, 2]) == 0\nassert op_add10_neg_sum([10]) == 0\nassert op_add10_neg_sum([2, 4, 6]) == 0\nassert op_add10_neg_sum([-7, 12, -7]) == 0"}
{"id": "op_inc_rev_anyeven", "entry_point": "op_inc_rev_anyeven", "primitives": ["inc", "rev", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then return whether any value is even.", "solution": "def op_inc_rev_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_rev_anyeven([1, 2, 3, 4]) == True\nassert op_inc_rev_anyeven([]) == False\nassert op_inc_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_rev_anyeven([5, 5, 5]) == True\nassert op_inc_rev_anyeven([3, 1, 2]) == True\nassert op_inc_rev_anyeven([10]) == False\nassert op_inc_rev_anyeven([2, 4, 6]) == False\nassert op_inc_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_padto3_dec_gt5", "entry_point": "op_padto3_dec_gt5", "primitives": ["padto3", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then keep values greater than five.", "solution": "def op_padto3_dec_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_dec_gt5([1, 2, 3, 4]) == []\nassert op_padto3_dec_gt5([]) == []\nassert op_padto3_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_dec_gt5([5, 5, 5]) == []\nassert op_padto3_dec_gt5([3, 1, 2]) == []\nassert op_padto3_dec_gt5([10]) == [9]\nassert op_padto3_dec_gt5([2, 4, 6]) == []\nassert op_padto3_dec_gt5([-7, 12, -7]) == [11]"}
{"id": "op_negate_dropzeros_dec", "entry_point": "op_negate_dropzeros_dec", "primitives": ["negate", "dropzeros", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then subtract one from each.", "solution": "def op_negate_dropzeros_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_dropzeros_dec([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_negate_dropzeros_dec([]) == []\nassert op_negate_dropzeros_dec([-2, -1, 0, 1, 2]) == [1, 0, -2, -3]\nassert op_negate_dropzeros_dec([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_dropzeros_dec([3, 1, 2]) == [-4, -2, -3]\nassert op_negate_dropzeros_dec([10]) == [-11]\nassert op_negate_dropzeros_dec([2, 4, 6]) == [-3, -5, -7]\nassert op_negate_dropzeros_dec([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_oremptyzero_dropzeros_alldistinct", "entry_point": "op_oremptyzero_dropzeros_alldistinct", "primitives": ["oremptyzero", "dropzeros", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then return whether all values are distinct.", "solution": "def op_oremptyzero_dropzeros_alldistinct(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return len(r) == len(set(r))", "tests": "assert op_oremptyzero_dropzeros_alldistinct([1, 2, 3, 4]) == True\nassert op_oremptyzero_dropzeros_alldistinct([]) == True\nassert op_oremptyzero_dropzeros_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_dropzeros_alldistinct([5, 5, 5]) == False\nassert op_oremptyzero_dropzeros_alldistinct([3, 1, 2]) == True\nassert op_oremptyzero_dropzeros_alldistinct([10]) == True\nassert op_oremptyzero_dropzeros_alldistinct([2, 4, 6]) == True\nassert op_oremptyzero_dropzeros_alldistinct([-7, 12, -7]) == False"}
{"id": "op_evens_double_sortabs", "entry_point": "op_evens_double_sortabs", "primitives": ["evens", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then sort by absolute value.", "solution": "def op_evens_double_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_double_sortabs([1, 2, 3, 4]) == [4, 8]\nassert op_evens_double_sortabs([]) == []\nassert op_evens_double_sortabs([-2, -1, 0, 1, 2]) == [0, -4, 4]\nassert op_evens_double_sortabs([5, 5, 5]) == []\nassert op_evens_double_sortabs([3, 1, 2]) == [4]\nassert op_evens_double_sortabs([10]) == [20]\nassert op_evens_double_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_evens_double_sortabs([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_square_haszero", "entry_point": "op_takewhilepos_square_haszero", "primitives": ["takewhilepos", "square", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then return whether the list contains a zero.", "solution": "def op_takewhilepos_square_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_takewhilepos_square_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_square_haszero([]) == False\nassert op_takewhilepos_square_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_square_haszero([5, 5, 5]) == False\nassert op_takewhilepos_square_haszero([3, 1, 2]) == False\nassert op_takewhilepos_square_haszero([10]) == False\nassert op_takewhilepos_square_haszero([2, 4, 6]) == False\nassert op_takewhilepos_square_haszero([-7, 12, -7]) == False"}
{"id": "op_square_double_issorted", "entry_point": "op_square_double_issorted", "primitives": ["square", "double", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then return whether the list is sorted ascending.", "solution": "def op_square_double_issorted(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_square_double_issorted([1, 2, 3, 4]) == True\nassert op_square_double_issorted([]) == True\nassert op_square_double_issorted([-2, -1, 0, 1, 2]) == False\nassert op_square_double_issorted([5, 5, 5]) == True\nassert op_square_double_issorted([3, 1, 2]) == False\nassert op_square_double_issorted([10]) == True\nassert op_square_double_issorted([2, 4, 6]) == True\nassert op_square_double_issorted([-7, 12, -7]) == False"}
{"id": "op_beforezero_inc_uniq", "entry_point": "op_beforezero_inc_uniq", "primitives": ["beforezero", "inc", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_inc_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_inc_uniq([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_beforezero_inc_uniq([]) == []\nassert op_beforezero_inc_uniq([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_beforezero_inc_uniq([5, 5, 5]) == [6]\nassert op_beforezero_inc_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_beforezero_inc_uniq([10]) == [11]\nassert op_beforezero_inc_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_beforezero_inc_uniq([-7, 12, -7]) == [-6, 13]"}
{"id": "op_first3_dropfirst_dropwhileneg", "entry_point": "op_first3_dropfirst_dropwhileneg", "primitives": ["first3", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then drop the leading negative values.", "solution": "def op_first3_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_dropfirst_dropwhileneg([1, 2, 3, 4]) == [2, 3]\nassert op_first3_dropfirst_dropwhileneg([]) == []\nassert op_first3_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropfirst_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_first3_dropfirst_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_first3_dropfirst_dropwhileneg([10]) == []\nassert op_first3_dropfirst_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_first3_dropfirst_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_neg_trimends_first3", "entry_point": "op_neg_trimends_first3", "primitives": ["neg", "trimends", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then keep only the first three.", "solution": "def op_neg_trimends_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_neg_trimends_first3([1, 2, 3, 4]) == []\nassert op_neg_trimends_first3([]) == []\nassert op_neg_trimends_first3([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_first3([5, 5, 5]) == []\nassert op_neg_trimends_first3([3, 1, 2]) == []\nassert op_neg_trimends_first3([10]) == []\nassert op_neg_trimends_first3([2, 4, 6]) == []\nassert op_neg_trimends_first3([-7, 12, -7]) == []"}
{"id": "op_pos_rev_double", "entry_point": "op_pos_rev_double", "primitives": ["pos", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then double each.", "solution": "def op_pos_rev_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_pos_rev_double([]) == []\nassert op_pos_rev_double([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_pos_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_pos_rev_double([10]) == [20]\nassert op_pos_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_pos_rev_double([-7, 12, -7]) == [24]"}
{"id": "op_uniq_add10_sortabs", "entry_point": "op_uniq_add10_sortabs", "primitives": ["uniq", "add10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then sort by absolute value.", "solution": "def op_uniq_add10_sortabs(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_uniq_add10_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10_sortabs([]) == []\nassert op_uniq_add10_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10_sortabs([5, 5, 5]) == [15]\nassert op_uniq_add10_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_uniq_add10_sortabs([10]) == [20]\nassert op_uniq_add10_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_sortabs([-7, 12, -7]) == [3, 22]"}
{"id": "op_square_dropzeros_min", "entry_point": "op_square_dropzeros_min", "primitives": ["square", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_square_dropzeros_min(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_square_dropzeros_min([1, 2, 3, 4]) == 1\nassert op_square_dropzeros_min([]) == 0\nassert op_square_dropzeros_min([-2, -1, 0, 1, 2]) == 1\nassert op_square_dropzeros_min([5, 5, 5]) == 25\nassert op_square_dropzeros_min([3, 1, 2]) == 1\nassert op_square_dropzeros_min([10]) == 100\nassert op_square_dropzeros_min([2, 4, 6]) == 4\nassert op_square_dropzeros_min([-7, 12, -7]) == 49"}
{"id": "op_pos_sortabs_counteven", "entry_point": "op_pos_sortabs_counteven", "primitives": ["pos", "sortabs", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then return how many values are even.", "solution": "def op_pos_sortabs_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_sortabs_counteven([1, 2, 3, 4]) == 2\nassert op_pos_sortabs_counteven([]) == 0\nassert op_pos_sortabs_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_pos_sortabs_counteven([5, 5, 5]) == 0\nassert op_pos_sortabs_counteven([3, 1, 2]) == 1\nassert op_pos_sortabs_counteven([10]) == 1\nassert op_pos_sortabs_counteven([2, 4, 6]) == 3\nassert op_pos_sortabs_counteven([-7, 12, -7]) == 1"}
{"id": "op_sorta_dec_haszero", "entry_point": "op_sorta_dec_haszero", "primitives": ["sorta", "dec", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_sorta_dec_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_sorta_dec_haszero([1, 2, 3, 4]) == True\nassert op_sorta_dec_haszero([]) == False\nassert op_sorta_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_dec_haszero([5, 5, 5]) == False\nassert op_sorta_dec_haszero([3, 1, 2]) == True\nassert op_sorta_dec_haszero([10]) == False\nassert op_sorta_dec_haszero([2, 4, 6]) == False\nassert op_sorta_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_div3_first3", "entry_point": "op_dropfirst_div3_first3", "primitives": ["dropfirst", "div3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep multiples of three, then keep only the first three.", "solution": "def op_dropfirst_div3_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_div3_first3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_div3_first3([]) == []\nassert op_dropfirst_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropfirst_div3_first3([5, 5, 5]) == []\nassert op_dropfirst_div3_first3([3, 1, 2]) == []\nassert op_dropfirst_div3_first3([10]) == []\nassert op_dropfirst_div3_first3([2, 4, 6]) == [6]\nassert op_dropfirst_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_sortd_pos", "entry_point": "op_clamp10_sortd_pos", "primitives": ["clamp10", "sortd", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then keep the positive numbers.", "solution": "def op_clamp10_sortd_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_sortd_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_sortd_pos([]) == []\nassert op_clamp10_sortd_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_sortd_pos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortd_pos([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_sortd_pos([10]) == [10]\nassert op_clamp10_sortd_pos([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_sortd_pos([-7, 12, -7]) == [10]"}
{"id": "op_evens_trimends_dropwhileneg", "entry_point": "op_evens_trimends_dropwhileneg", "primitives": ["evens", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_evens_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_evens_trimends_dropwhileneg([1, 2, 3, 4]) == []\nassert op_evens_trimends_dropwhileneg([]) == []\nassert op_evens_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_trimends_dropwhileneg([5, 5, 5]) == []\nassert op_evens_trimends_dropwhileneg([3, 1, 2]) == []\nassert op_evens_trimends_dropwhileneg([10]) == []\nassert op_evens_trimends_dropwhileneg([2, 4, 6]) == [4]\nassert op_evens_trimends_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_beforezero_sorta_gt5", "entry_point": "op_beforezero_sorta_gt5", "primitives": ["beforezero", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then keep values greater than five.", "solution": "def op_beforezero_sorta_gt5(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_beforezero_sorta_gt5([1, 2, 3, 4]) == []\nassert op_beforezero_sorta_gt5([]) == []\nassert op_beforezero_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_sorta_gt5([5, 5, 5]) == []\nassert op_beforezero_sorta_gt5([3, 1, 2]) == []\nassert op_beforezero_sorta_gt5([10]) == [10]\nassert op_beforezero_sorta_gt5([2, 4, 6]) == [6]\nassert op_beforezero_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_strip_uniqs_lens", "entry_point": "op_strip_uniqs_lens", "primitives": ["strip", "uniqs", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first, then return the total number of characters.", "solution": "def op_strip_uniqs_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    return sum(len(s) for s in r)", "tests": "assert op_strip_uniqs_lens(['Hello', 'world']) == 10\nassert op_strip_uniqs_lens([]) == 0\nassert op_strip_uniqs_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_strip_uniqs_lens(['one', 'one', 'Two']) == 6\nassert op_strip_uniqs_lens(['x']) == 1\nassert op_strip_uniqs_lens(['abc', 'de', '']) == 5"}
{"id": "op_sortd_dropwhileneg_pos", "entry_point": "op_sortd_dropwhileneg_pos", "primitives": ["sortd", "dropwhileneg", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_sortd_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_dropwhileneg_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_dropwhileneg_pos([]) == []\nassert op_sortd_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropwhileneg_pos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropwhileneg_pos([10]) == [10]\nassert op_sortd_dropwhileneg_pos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropwhileneg_pos([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_clamp10_gt5", "entry_point": "op_beforezero_clamp10_gt5", "primitives": ["beforezero", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10, then keep values greater than five.", "solution": "def op_beforezero_clamp10_gt5(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_beforezero_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_beforezero_clamp10_gt5([]) == []\nassert op_beforezero_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_clamp10_gt5([5, 5, 5]) == []\nassert op_beforezero_clamp10_gt5([3, 1, 2]) == []\nassert op_beforezero_clamp10_gt5([10]) == [10]\nassert op_beforezero_clamp10_gt5([2, 4, 6]) == [6]\nassert op_beforezero_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_odds_rev_allpos", "entry_point": "op_odds_rev_allpos", "primitives": ["odds", "rev", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then return whether all values are positive.", "solution": "def op_odds_rev_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return all(x > 0 for x in r)", "tests": "assert op_odds_rev_allpos([1, 2, 3, 4]) == True\nassert op_odds_rev_allpos([]) == True\nassert op_odds_rev_allpos([-2, -1, 0, 1, 2]) == False\nassert op_odds_rev_allpos([5, 5, 5]) == True\nassert op_odds_rev_allpos([3, 1, 2]) == True\nassert op_odds_rev_allpos([10]) == True\nassert op_odds_rev_allpos([2, 4, 6]) == True\nassert op_odds_rev_allpos([-7, 12, -7]) == False"}
{"id": "op_dec_dropfirst_oremptyzero", "entry_point": "op_dec_dropfirst_oremptyzero", "primitives": ["dec", "dropfirst", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first element, then if empty, use a single zero.", "solution": "def op_dec_dropfirst_oremptyzero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    r = r if r else [0]\n    return r", "tests": "assert op_dec_dropfirst_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropfirst_oremptyzero([]) == [0]\nassert op_dec_dropfirst_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dec_dropfirst_oremptyzero([5, 5, 5]) == [4, 4]\nassert op_dec_dropfirst_oremptyzero([3, 1, 2]) == [0, 1]\nassert op_dec_dropfirst_oremptyzero([10]) == [0]\nassert op_dec_dropfirst_oremptyzero([2, 4, 6]) == [3, 5]\nassert op_dec_dropfirst_oremptyzero([-7, 12, -7]) == [11, -8]"}
{"id": "op_odds_last3_issorted", "entry_point": "op_odds_last3_issorted", "primitives": ["odds", "last3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_odds_last3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_odds_last3_issorted([1, 2, 3, 4]) == True\nassert op_odds_last3_issorted([]) == True\nassert op_odds_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_last3_issorted([5, 5, 5]) == True\nassert op_odds_last3_issorted([3, 1, 2]) == False\nassert op_odds_last3_issorted([10]) == True\nassert op_odds_last3_issorted([2, 4, 6]) == True\nassert op_odds_last3_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_first3_square", "entry_point": "op_padto3_first3_square", "primitives": ["padto3", "first3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then square each.", "solution": "def op_padto3_first3_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_first3_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_padto3_first3_square([]) == [0, 0, 0]\nassert op_padto3_first3_square([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_padto3_first3_square([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_first3_square([3, 1, 2]) == [9, 1, 4]\nassert op_padto3_first3_square([10]) == [100, 0, 0]\nassert op_padto3_first3_square([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_first3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sorta_clamp10_max", "entry_point": "op_sorta_clamp10_max", "primitives": ["sorta", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_sorta_clamp10_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_sorta_clamp10_max([1, 2, 3, 4]) == 4\nassert op_sorta_clamp10_max([]) == 0\nassert op_sorta_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_clamp10_max([5, 5, 5]) == 5\nassert op_sorta_clamp10_max([3, 1, 2]) == 3\nassert op_sorta_clamp10_max([10]) == 10\nassert op_sorta_clamp10_max([2, 4, 6]) == 6\nassert op_sorta_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_ages_dropzeros_oremptyzero", "entry_point": "op_ages_dropzeros_oremptyzero", "primitives": ["ages", "dropzeros", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros, then if empty, use a single zero.", "solution": "def op_ages_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_dropzeros_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropzeros_oremptyzero([]) == [0]\nassert op_ages_dropzeros_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropzeros_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortabs_trimends_firsteven", "entry_point": "op_sortabs_trimends_firsteven", "primitives": ["sortabs", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_sortabs_trimends_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_sortabs_trimends_firsteven([]) == 0\nassert op_sortabs_trimends_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_trimends_firsteven([5, 5, 5]) == 0\nassert op_sortabs_trimends_firsteven([3, 1, 2]) == 2\nassert op_sortabs_trimends_firsteven([10]) == 0\nassert op_sortabs_trimends_firsteven([2, 4, 6]) == 4\nassert op_sortabs_trimends_firsteven([-7, 12, -7]) == 0"}
{"id": "op_uniq_dropfirst_anyeven", "entry_point": "op_uniq_dropfirst_anyeven", "primitives": ["uniq", "dropfirst", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then return whether any value is even.", "solution": "def op_uniq_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_dropfirst_anyeven([]) == False\nassert op_uniq_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_dropfirst_anyeven([5, 5, 5]) == False\nassert op_uniq_dropfirst_anyeven([3, 1, 2]) == True\nassert op_uniq_dropfirst_anyeven([10]) == False\nassert op_uniq_dropfirst_anyeven([2, 4, 6]) == True\nassert op_uniq_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropfirst_evens_anyeven", "entry_point": "op_dropfirst_evens_anyeven", "primitives": ["dropfirst", "evens", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then return whether any value is even.", "solution": "def op_dropfirst_evens_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_evens_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_evens_anyeven([]) == False\nassert op_dropfirst_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_evens_anyeven([5, 5, 5]) == False\nassert op_dropfirst_evens_anyeven([3, 1, 2]) == True\nassert op_dropfirst_evens_anyeven([10]) == False\nassert op_dropfirst_evens_anyeven([2, 4, 6]) == True\nassert op_dropfirst_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_nonempty_dropshort_lens", "entry_point": "op_nonempty_dropshort_lens", "primitives": ["nonempty", "dropshort", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop strings shorter than three characters, then return the total number of characters.", "solution": "def op_nonempty_dropshort_lens(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return sum(len(s) for s in r)", "tests": "assert op_nonempty_dropshort_lens(['Hello', 'world']) == 10\nassert op_nonempty_dropshort_lens([]) == 0\nassert op_nonempty_dropshort_lens(['  a ', '', 'BC', 'bc']) == 4\nassert op_nonempty_dropshort_lens(['one', 'one', 'Two']) == 9\nassert op_nonempty_dropshort_lens(['x']) == 0\nassert op_nonempty_dropshort_lens(['abc', 'de', '']) == 3"}
{"id": "op_ages_oremptyzero_add10", "entry_point": "op_ages_oremptyzero_add10", "primitives": ["ages", "oremptyzero", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then add ten to each.", "solution": "def op_ages_oremptyzero_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_oremptyzero_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_oremptyzero_add10([]) == [10]\nassert op_ages_oremptyzero_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_oremptyzero_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_dropzeros_square_dropfirst", "entry_point": "op_dropzeros_square_dropfirst", "primitives": ["dropzeros", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each, then drop the first element.", "solution": "def op_dropzeros_square_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_square_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropzeros_square_dropfirst([]) == []\nassert op_dropzeros_square_dropfirst([-2, -1, 0, 1, 2]) == [1, 1, 4]\nassert op_dropzeros_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_dropzeros_square_dropfirst([3, 1, 2]) == [1, 4]\nassert op_dropzeros_square_dropfirst([10]) == []\nassert op_dropzeros_square_dropfirst([2, 4, 6]) == [16, 36]\nassert op_dropzeros_square_dropfirst([-7, 12, -7]) == [144, 49]"}
{"id": "op_dropfirst_square_beforezero", "entry_point": "op_dropfirst_square_beforezero", "primitives": ["dropfirst", "square", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then keep everything before the first zero.", "solution": "def op_dropfirst_square_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_square_beforezero([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropfirst_square_beforezero([]) == []\nassert op_dropfirst_square_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_square_beforezero([5, 5, 5]) == [25, 25]\nassert op_dropfirst_square_beforezero([3, 1, 2]) == [1, 4]\nassert op_dropfirst_square_beforezero([10]) == []\nassert op_dropfirst_square_beforezero([2, 4, 6]) == [16, 36]\nassert op_dropfirst_square_beforezero([-7, 12, -7]) == [144, 49]"}
{"id": "op_div3_evens_haszero", "entry_point": "op_div3_evens_haszero", "primitives": ["div3", "evens", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then return whether the list contains a zero.", "solution": "def op_div3_evens_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return 0 in r", "tests": "assert op_div3_evens_haszero([1, 2, 3, 4]) == False\nassert op_div3_evens_haszero([]) == False\nassert op_div3_evens_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_evens_haszero([5, 5, 5]) == False\nassert op_div3_evens_haszero([3, 1, 2]) == False\nassert op_div3_evens_haszero([10]) == False\nassert op_div3_evens_haszero([2, 4, 6]) == False\nassert op_div3_evens_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_dropwhileneg_firsteven", "entry_point": "op_sortd_dropwhileneg_firsteven", "primitives": ["sortd", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_sortd_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortd_dropwhileneg_firsteven([1, 2, 3, 4]) == 4\nassert op_sortd_dropwhileneg_firsteven([]) == 0\nassert op_sortd_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_sortd_dropwhileneg_firsteven([3, 1, 2]) == 2\nassert op_sortd_dropwhileneg_firsteven([10]) == 10\nassert op_sortd_dropwhileneg_firsteven([2, 4, 6]) == 6\nassert op_sortd_dropwhileneg_firsteven([-7, 12, -7]) == 12"}
{"id": "op_last3_dec_gt5", "entry_point": "op_last3_dec_gt5", "primitives": ["last3", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then keep values greater than five.", "solution": "def op_last3_dec_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_dec_gt5([1, 2, 3, 4]) == []\nassert op_last3_dec_gt5([]) == []\nassert op_last3_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_dec_gt5([5, 5, 5]) == []\nassert op_last3_dec_gt5([3, 1, 2]) == []\nassert op_last3_dec_gt5([10]) == [9]\nassert op_last3_dec_gt5([2, 4, 6]) == []\nassert op_last3_dec_gt5([-7, 12, -7]) == [11]"}
{"id": "op_takewhilepos_gt5_first3", "entry_point": "op_takewhilepos_gt5_first3", "primitives": ["takewhilepos", "gt5", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then keep only the first three.", "solution": "def op_takewhilepos_gt5_first3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_takewhilepos_gt5_first3([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_first3([]) == []\nassert op_takewhilepos_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_first3([5, 5, 5]) == []\nassert op_takewhilepos_gt5_first3([3, 1, 2]) == []\nassert op_takewhilepos_gt5_first3([10]) == [10]\nassert op_takewhilepos_gt5_first3([2, 4, 6]) == [6]\nassert op_takewhilepos_gt5_first3([-7, 12, -7]) == []"}
{"id": "op_inc_neg_len", "entry_point": "op_inc_neg_len", "primitives": ["inc", "neg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then return how many remain.", "solution": "def op_inc_neg_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_inc_neg_len([1, 2, 3, 4]) == 0\nassert op_inc_neg_len([]) == 0\nassert op_inc_neg_len([-2, -1, 0, 1, 2]) == 1\nassert op_inc_neg_len([5, 5, 5]) == 0\nassert op_inc_neg_len([3, 1, 2]) == 0\nassert op_inc_neg_len([10]) == 0\nassert op_inc_neg_len([2, 4, 6]) == 0\nassert op_inc_neg_len([-7, 12, -7]) == 2"}
{"id": "op_neg_evens_padto3", "entry_point": "op_neg_evens_padto3", "primitives": ["neg", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_neg_evens_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_evens_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_evens_padto3([]) == [0, 0, 0]\nassert op_neg_evens_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 0]\nassert op_neg_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_evens_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_evens_padto3([10]) == [0, 0, 0]\nassert op_neg_evens_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_evens_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_uniq_evens_alldistinct", "entry_point": "op_uniq_evens_alldistinct", "primitives": ["uniq", "evens", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_uniq_evens_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_uniq_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_evens_alldistinct([]) == True\nassert op_uniq_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_uniq_evens_alldistinct([5, 5, 5]) == True\nassert op_uniq_evens_alldistinct([3, 1, 2]) == True\nassert op_uniq_evens_alldistinct([10]) == True\nassert op_uniq_evens_alldistinct([2, 4, 6]) == True\nassert op_uniq_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortd_odds_oremptyzero", "entry_point": "op_sortd_odds_oremptyzero", "primitives": ["sortd", "odds", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then if empty, use a single zero.", "solution": "def op_sortd_odds_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_odds_oremptyzero([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_odds_oremptyzero([]) == [0]\nassert op_sortd_odds_oremptyzero([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_odds_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_odds_oremptyzero([3, 1, 2]) == [3, 1]\nassert op_sortd_odds_oremptyzero([10]) == [0]\nassert op_sortd_odds_oremptyzero([2, 4, 6]) == [0]\nassert op_sortd_odds_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortd_dropwhileneg_sum", "entry_point": "op_sortd_dropwhileneg_sum", "primitives": ["sortd", "dropwhileneg", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then return their sum.", "solution": "def op_sortd_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_sortd_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_sortd_dropwhileneg_sum([]) == 0\nassert op_sortd_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_sortd_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_sortd_dropwhileneg_sum([10]) == 10\nassert op_sortd_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_sortd_dropwhileneg_sum([-7, 12, -7]) == -2"}
{"id": "op_first3_gt5_sortabs", "entry_point": "op_first3_gt5_sortabs", "primitives": ["first3", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then sort by absolute value.", "solution": "def op_first3_gt5_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_first3_gt5_sortabs([]) == []\nassert op_first3_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_first3_gt5_sortabs([5, 5, 5]) == []\nassert op_first3_gt5_sortabs([3, 1, 2]) == []\nassert op_first3_gt5_sortabs([10]) == [10]\nassert op_first3_gt5_sortabs([2, 4, 6]) == [6]\nassert op_first3_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_negate_dropwhileneg_oremptyzero", "entry_point": "op_negate_dropwhileneg_oremptyzero", "primitives": ["negate", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_negate_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_dropwhileneg_oremptyzero([5, 5, 5]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([3, 1, 2]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([10]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([2, 4, 6]) == [0]\nassert op_negate_dropwhileneg_oremptyzero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_takewhilepos_absval_evens", "entry_point": "op_takewhilepos_absval_evens", "primitives": ["takewhilepos", "absval", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then keep the even numbers.", "solution": "def op_takewhilepos_absval_evens(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_takewhilepos_absval_evens([1, 2, 3, 4]) == [2, 4]\nassert op_takewhilepos_absval_evens([]) == []\nassert op_takewhilepos_absval_evens([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_absval_evens([5, 5, 5]) == []\nassert op_takewhilepos_absval_evens([3, 1, 2]) == [2]\nassert op_takewhilepos_absval_evens([10]) == [10]\nassert op_takewhilepos_absval_evens([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_absval_evens([-7, 12, -7]) == []"}
{"id": "op_div3_double_dropfirst", "entry_point": "op_div3_double_dropfirst", "primitives": ["div3", "double", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then drop the first element.", "solution": "def op_div3_double_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_div3_double_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_double_dropfirst([]) == []\nassert op_div3_double_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_dropfirst([5, 5, 5]) == []\nassert op_div3_double_dropfirst([3, 1, 2]) == []\nassert op_div3_double_dropfirst([10]) == []\nassert op_div3_double_dropfirst([2, 4, 6]) == []\nassert op_div3_double_dropfirst([-7, 12, -7]) == []"}
{"id": "op_last3_trimends_uniq", "entry_point": "op_last3_trimends_uniq", "primitives": ["last3", "trimends", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_last3_trimends_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_trimends_uniq([1, 2, 3, 4]) == [3]\nassert op_last3_trimends_uniq([]) == []\nassert op_last3_trimends_uniq([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_trimends_uniq([5, 5, 5]) == [5]\nassert op_last3_trimends_uniq([3, 1, 2]) == [1]\nassert op_last3_trimends_uniq([10]) == []\nassert op_last3_trimends_uniq([2, 4, 6]) == [4]\nassert op_last3_trimends_uniq([-7, 12, -7]) == [12]"}
{"id": "op_rev_uniq_square", "entry_point": "op_rev_uniq_square", "primitives": ["rev", "uniq", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then square each.", "solution": "def op_rev_uniq_square(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_rev_uniq_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_uniq_square([]) == []\nassert op_rev_uniq_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_rev_uniq_square([5, 5, 5]) == [25]\nassert op_rev_uniq_square([3, 1, 2]) == [4, 1, 9]\nassert op_rev_uniq_square([10]) == [100]\nassert op_rev_uniq_square([2, 4, 6]) == [36, 16, 4]\nassert op_rev_uniq_square([-7, 12, -7]) == [49, 144]"}
{"id": "op_beforezero_sortabs_min", "entry_point": "op_beforezero_sortabs_min", "primitives": ["beforezero", "sortabs", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_beforezero_sortabs_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_beforezero_sortabs_min([1, 2, 3, 4]) == 1\nassert op_beforezero_sortabs_min([]) == 0\nassert op_beforezero_sortabs_min([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_sortabs_min([5, 5, 5]) == 5\nassert op_beforezero_sortabs_min([3, 1, 2]) == 1\nassert op_beforezero_sortabs_min([10]) == 10\nassert op_beforezero_sortabs_min([2, 4, 6]) == 2\nassert op_beforezero_sortabs_min([-7, 12, -7]) == -7"}
{"id": "op_last3_dec_prod", "entry_point": "op_last3_dec_prod", "primitives": ["last3", "dec", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then return their product.", "solution": "def op_last3_dec_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_last3_dec_prod([1, 2, 3, 4]) == 6\nassert op_last3_dec_prod([]) == 1\nassert op_last3_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_last3_dec_prod([5, 5, 5]) == 64\nassert op_last3_dec_prod([3, 1, 2]) == 0\nassert op_last3_dec_prod([10]) == 9\nassert op_last3_dec_prod([2, 4, 6]) == 15\nassert op_last3_dec_prod([-7, 12, -7]) == 704"}
{"id": "op_absval_first3_allpos", "entry_point": "op_absval_first3_allpos", "primitives": ["absval", "first3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then return whether all values are positive.", "solution": "def op_absval_first3_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_first3_allpos([1, 2, 3, 4]) == True\nassert op_absval_first3_allpos([]) == True\nassert op_absval_first3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_absval_first3_allpos([5, 5, 5]) == True\nassert op_absval_first3_allpos([3, 1, 2]) == True\nassert op_absval_first3_allpos([10]) == True\nassert op_absval_first3_allpos([2, 4, 6]) == True\nassert op_absval_first3_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_add10_double", "entry_point": "op_negate_add10_double", "primitives": ["negate", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then double each.", "solution": "def op_negate_add10_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_add10_double([1, 2, 3, 4]) == [18, 16, 14, 12]\nassert op_negate_add10_double([]) == []\nassert op_negate_add10_double([-2, -1, 0, 1, 2]) == [24, 22, 20, 18, 16]\nassert op_negate_add10_double([5, 5, 5]) == [10, 10, 10]\nassert op_negate_add10_double([3, 1, 2]) == [14, 18, 16]\nassert op_negate_add10_double([10]) == [0]\nassert op_negate_add10_double([2, 4, 6]) == [16, 12, 8]\nassert op_negate_add10_double([-7, 12, -7]) == [34, -4, 34]"}
{"id": "op_evens_div3_haszero", "entry_point": "op_evens_div3_haszero", "primitives": ["evens", "div3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then return whether the list contains a zero.", "solution": "def op_evens_div3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return 0 in r", "tests": "assert op_evens_div3_haszero([1, 2, 3, 4]) == False\nassert op_evens_div3_haszero([]) == False\nassert op_evens_div3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_evens_div3_haszero([5, 5, 5]) == False\nassert op_evens_div3_haszero([3, 1, 2]) == False\nassert op_evens_div3_haszero([10]) == False\nassert op_evens_div3_haszero([2, 4, 6]) == False\nassert op_evens_div3_haszero([-7, 12, -7]) == False"}
{"id": "op_beforezero_div3_double", "entry_point": "op_beforezero_div3_double", "primitives": ["beforezero", "div3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three, then double each.", "solution": "def op_beforezero_div3_double(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_beforezero_div3_double([1, 2, 3, 4]) == [6]\nassert op_beforezero_div3_double([]) == []\nassert op_beforezero_div3_double([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_div3_double([5, 5, 5]) == []\nassert op_beforezero_div3_double([3, 1, 2]) == [6]\nassert op_beforezero_div3_double([10]) == []\nassert op_beforezero_div3_double([2, 4, 6]) == [12]\nassert op_beforezero_div3_double([-7, 12, -7]) == [24]"}
{"id": "op_trimends_beforezero_add10", "entry_point": "op_trimends_beforezero_add10", "primitives": ["trimends", "beforezero", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then add ten to each.", "solution": "def op_trimends_beforezero_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_beforezero_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_beforezero_add10([]) == []\nassert op_trimends_beforezero_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_trimends_beforezero_add10([5, 5, 5]) == [15]\nassert op_trimends_beforezero_add10([3, 1, 2]) == [11]\nassert op_trimends_beforezero_add10([10]) == []\nassert op_trimends_beforezero_add10([2, 4, 6]) == [14]\nassert op_trimends_beforezero_add10([-7, 12, -7]) == [22]"}
{"id": "op_evens_div3_firsteven", "entry_point": "op_evens_div3_firsteven", "primitives": ["evens", "div3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then return the first even value (0 if none).", "solution": "def op_evens_div3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_evens_div3_firsteven([1, 2, 3, 4]) == 0\nassert op_evens_div3_firsteven([]) == 0\nassert op_evens_div3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_evens_div3_firsteven([5, 5, 5]) == 0\nassert op_evens_div3_firsteven([3, 1, 2]) == 0\nassert op_evens_div3_firsteven([10]) == 0\nassert op_evens_div3_firsteven([2, 4, 6]) == 6\nassert op_evens_div3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_last3_sorta_double", "entry_point": "op_last3_sorta_double", "primitives": ["last3", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then double each.", "solution": "def op_last3_sorta_double(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_last3_sorta_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_sorta_double([]) == []\nassert op_last3_sorta_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_last3_sorta_double([5, 5, 5]) == [10, 10, 10]\nassert op_last3_sorta_double([3, 1, 2]) == [2, 4, 6]\nassert op_last3_sorta_double([10]) == [20]\nassert op_last3_sorta_double([2, 4, 6]) == [4, 8, 12]\nassert op_last3_sorta_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_rev_trimends_len", "entry_point": "op_rev_trimends_len", "primitives": ["rev", "trimends", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then return how many remain.", "solution": "def op_rev_trimends_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_rev_trimends_len([1, 2, 3, 4]) == 2\nassert op_rev_trimends_len([]) == 0\nassert op_rev_trimends_len([-2, -1, 0, 1, 2]) == 3\nassert op_rev_trimends_len([5, 5, 5]) == 1\nassert op_rev_trimends_len([3, 1, 2]) == 1\nassert op_rev_trimends_len([10]) == 0\nassert op_rev_trimends_len([2, 4, 6]) == 1\nassert op_rev_trimends_len([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_uniq_absval", "entry_point": "op_dropzeros_uniq_absval", "primitives": ["dropzeros", "uniq", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_dropzeros_uniq_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_uniq_absval([]) == []\nassert op_dropzeros_uniq_absval([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_uniq_absval([5, 5, 5]) == [5]\nassert op_dropzeros_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_uniq_absval([10]) == [10]\nassert op_dropzeros_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_uniq_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_double_dec_trimends", "entry_point": "op_double_dec_trimends", "primitives": ["double", "dec", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then drop the first and last elements.", "solution": "def op_double_dec_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_dec_trimends([1, 2, 3, 4]) == [3, 5]\nassert op_double_dec_trimends([]) == []\nassert op_double_dec_trimends([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_double_dec_trimends([5, 5, 5]) == [9]\nassert op_double_dec_trimends([3, 1, 2]) == [1]\nassert op_double_dec_trimends([10]) == []\nassert op_double_dec_trimends([2, 4, 6]) == [7]\nassert op_double_dec_trimends([-7, 12, -7]) == [23]"}
{"id": "op_nonempty_upper_uniqs", "entry_point": "op_nonempty_upper_uniqs", "primitives": ["nonempty", "upper", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then uppercase each string, then drop duplicate strings keeping the first.", "solution": "def op_nonempty_upper_uniqs(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.upper() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_nonempty_upper_uniqs(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_nonempty_upper_uniqs([]) == []\nassert op_nonempty_upper_uniqs(['  a ', '', 'BC', 'bc']) == ['  A ', 'BC']\nassert op_nonempty_upper_uniqs(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_nonempty_upper_uniqs(['x']) == ['X']\nassert op_nonempty_upper_uniqs(['abc', 'de', '']) == ['ABC', 'DE']"}
{"id": "op_double_gt5_last3", "entry_point": "op_double_gt5_last3", "primitives": ["double", "gt5", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then keep only the last three.", "solution": "def op_double_gt5_last3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    return r", "tests": "assert op_double_gt5_last3([1, 2, 3, 4]) == [6, 8]\nassert op_double_gt5_last3([]) == []\nassert op_double_gt5_last3([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_last3([5, 5, 5]) == [10, 10, 10]\nassert op_double_gt5_last3([3, 1, 2]) == [6]\nassert op_double_gt5_last3([10]) == [20]\nassert op_double_gt5_last3([2, 4, 6]) == [8, 12]\nassert op_double_gt5_last3([-7, 12, -7]) == [24]"}
{"id": "op_evens_inc_uniq", "entry_point": "op_evens_inc_uniq", "primitives": ["evens", "inc", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_evens_inc_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_evens_inc_uniq([1, 2, 3, 4]) == [3, 5]\nassert op_evens_inc_uniq([]) == []\nassert op_evens_inc_uniq([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_evens_inc_uniq([5, 5, 5]) == []\nassert op_evens_inc_uniq([3, 1, 2]) == [3]\nassert op_evens_inc_uniq([10]) == [11]\nassert op_evens_inc_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_evens_inc_uniq([-7, 12, -7]) == [13]"}
{"id": "op_oremptyzero_first3_uniq", "entry_point": "op_oremptyzero_first3_uniq", "primitives": ["oremptyzero", "first3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_first3_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_first3_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_first3_uniq([]) == [0]\nassert op_oremptyzero_first3_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_oremptyzero_first3_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_first3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_first3_uniq([10]) == [10]\nassert op_oremptyzero_first3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_first3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_clamp10_square_dropzeros", "entry_point": "op_clamp10_square_dropzeros", "primitives": ["clamp10", "square", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then drop the zeros.", "solution": "def op_clamp10_square_dropzeros(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_clamp10_square_dropzeros([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_square_dropzeros([]) == []\nassert op_clamp10_square_dropzeros([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_clamp10_square_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square_dropzeros([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_square_dropzeros([10]) == [100]\nassert op_clamp10_square_dropzeros([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_square_dropzeros([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_last3_sortd_first3", "entry_point": "op_last3_sortd_first3", "primitives": ["last3", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then keep only the first three.", "solution": "def op_last3_sortd_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_last3_sortd_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_sortd_first3([]) == []\nassert op_last3_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_sortd_first3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortd_first3([3, 1, 2]) == [3, 2, 1]\nassert op_last3_sortd_first3([10]) == [10]\nassert op_last3_sortd_first3([2, 4, 6]) == [6, 4, 2]\nassert op_last3_sortd_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_odds_beforezero_dropzeros", "entry_point": "op_odds_beforezero_dropzeros", "primitives": ["odds", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then drop the zeros.", "solution": "def op_odds_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_beforezero_dropzeros([1, 2, 3, 4]) == [1, 3]\nassert op_odds_beforezero_dropzeros([]) == []\nassert op_odds_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_odds_beforezero_dropzeros([3, 1, 2]) == [3, 1]\nassert op_odds_beforezero_dropzeros([10]) == []\nassert op_odds_beforezero_dropzeros([2, 4, 6]) == []\nassert op_odds_beforezero_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_uniq_neg", "entry_point": "op_pos_uniq_neg", "primitives": ["pos", "uniq", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then keep the negative numbers.", "solution": "def op_pos_uniq_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_pos_uniq_neg([1, 2, 3, 4]) == []\nassert op_pos_uniq_neg([]) == []\nassert op_pos_uniq_neg([-2, -1, 0, 1, 2]) == []\nassert op_pos_uniq_neg([5, 5, 5]) == []\nassert op_pos_uniq_neg([3, 1, 2]) == []\nassert op_pos_uniq_neg([10]) == []\nassert op_pos_uniq_neg([2, 4, 6]) == []\nassert op_pos_uniq_neg([-7, 12, -7]) == []"}
{"id": "op_negate_absval_add10", "entry_point": "op_negate_absval_add10", "primitives": ["negate", "absval", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then add ten to each.", "solution": "def op_negate_absval_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_absval_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_negate_absval_add10([]) == []\nassert op_negate_absval_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 11, 12]\nassert op_negate_absval_add10([5, 5, 5]) == [15, 15, 15]\nassert op_negate_absval_add10([3, 1, 2]) == [13, 11, 12]\nassert op_negate_absval_add10([10]) == [20]\nassert op_negate_absval_add10([2, 4, 6]) == [12, 14, 16]\nassert op_negate_absval_add10([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_rev_double_dropzeros", "entry_point": "op_rev_double_dropzeros", "primitives": ["rev", "double", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then drop the zeros.", "solution": "def op_rev_double_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_double_dropzeros([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_dropzeros([]) == []\nassert op_rev_double_dropzeros([-2, -1, 0, 1, 2]) == [4, 2, -2, -4]\nassert op_rev_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_dropzeros([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_dropzeros([10]) == [20]\nassert op_rev_double_dropzeros([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_trimends_last3_alldistinct", "entry_point": "op_trimends_last3_alldistinct", "primitives": ["trimends", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then return whether all values are distinct.", "solution": "def op_trimends_last3_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_trimends_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_last3_alldistinct([]) == True\nassert op_trimends_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_last3_alldistinct([5, 5, 5]) == True\nassert op_trimends_last3_alldistinct([3, 1, 2]) == True\nassert op_trimends_last3_alldistinct([10]) == True\nassert op_trimends_last3_alldistinct([2, 4, 6]) == True\nassert op_trimends_last3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_negate_dropfirst_dropzeros", "entry_point": "op_negate_dropfirst_dropzeros", "primitives": ["negate", "dropfirst", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then drop the zeros.", "solution": "def op_negate_dropfirst_dropzeros(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_negate_dropfirst_dropzeros([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_dropfirst_dropzeros([]) == []\nassert op_negate_dropfirst_dropzeros([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_negate_dropfirst_dropzeros([5, 5, 5]) == [-5, -5]\nassert op_negate_dropfirst_dropzeros([3, 1, 2]) == [-1, -2]\nassert op_negate_dropfirst_dropzeros([10]) == []\nassert op_negate_dropfirst_dropzeros([2, 4, 6]) == [-4, -6]\nassert op_negate_dropfirst_dropzeros([-7, 12, -7]) == [-12, 7]"}
{"id": "op_last3_clamp10_sorta", "entry_point": "op_last3_clamp10_sorta", "primitives": ["last3", "clamp10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then sort ascending.", "solution": "def op_last3_clamp10_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_clamp10_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_clamp10_sorta([]) == []\nassert op_last3_clamp10_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_clamp10_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_clamp10_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_clamp10_sorta([10]) == [10]\nassert op_last3_clamp10_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_clamp10_sorta([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_inc_div3_uniq", "entry_point": "op_inc_div3_uniq", "primitives": ["inc", "div3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then drop duplicates keeping first occurrence.", "solution": "def op_inc_div3_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_div3_uniq([1, 2, 3, 4]) == [3]\nassert op_inc_div3_uniq([]) == []\nassert op_inc_div3_uniq([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_inc_div3_uniq([5, 5, 5]) == [6]\nassert op_inc_div3_uniq([3, 1, 2]) == [3]\nassert op_inc_div3_uniq([10]) == []\nassert op_inc_div3_uniq([2, 4, 6]) == [3]\nassert op_inc_div3_uniq([-7, 12, -7]) == [-6]"}
{"id": "op_sortd_odds_trimends", "entry_point": "op_sortd_odds_trimends", "primitives": ["sortd", "odds", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_sortd_odds_trimends(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortd_odds_trimends([1, 2, 3, 4]) == []\nassert op_sortd_odds_trimends([]) == []\nassert op_sortd_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_sortd_odds_trimends([5, 5, 5]) == [5]\nassert op_sortd_odds_trimends([3, 1, 2]) == []\nassert op_sortd_odds_trimends([10]) == []\nassert op_sortd_odds_trimends([2, 4, 6]) == []\nassert op_sortd_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_first3_sortabs", "entry_point": "op_sorta_first3_sortabs", "primitives": ["sorta", "first3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then sort by absolute value.", "solution": "def op_sorta_first3_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_first3_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_first3_sortabs([]) == []\nassert op_sorta_first3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_sorta_first3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_first3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_first3_sortabs([10]) == [10]\nassert op_sorta_first3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_first3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_neg_clamp10_max", "entry_point": "op_neg_clamp10_max", "primitives": ["neg", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_neg_clamp10_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_neg_clamp10_max([1, 2, 3, 4]) == 0\nassert op_neg_clamp10_max([]) == 0\nassert op_neg_clamp10_max([-2, -1, 0, 1, 2]) == -1\nassert op_neg_clamp10_max([5, 5, 5]) == 0\nassert op_neg_clamp10_max([3, 1, 2]) == 0\nassert op_neg_clamp10_max([10]) == 0\nassert op_neg_clamp10_max([2, 4, 6]) == 0\nassert op_neg_clamp10_max([-7, 12, -7]) == -7"}
{"id": "op_rev_inc_oremptyzero", "entry_point": "op_rev_inc_oremptyzero", "primitives": ["rev", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then if empty, use a single zero.", "solution": "def op_rev_inc_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_inc_oremptyzero([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_rev_inc_oremptyzero([]) == [0]\nassert op_rev_inc_oremptyzero([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_rev_inc_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_rev_inc_oremptyzero([3, 1, 2]) == [3, 2, 4]\nassert op_rev_inc_oremptyzero([10]) == [11]\nassert op_rev_inc_oremptyzero([2, 4, 6]) == [7, 5, 3]\nassert op_rev_inc_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropzeros_absval_clamp10", "entry_point": "op_dropzeros_absval_clamp10", "primitives": ["dropzeros", "absval", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then cap each value at 10.", "solution": "def op_dropzeros_absval_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_absval_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_absval_clamp10([]) == []\nassert op_dropzeros_absval_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_absval_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_absval_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_absval_clamp10([10]) == [10]\nassert op_dropzeros_absval_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_sorta_gt5_dropwhileneg", "entry_point": "op_sorta_gt5_dropwhileneg", "primitives": ["sorta", "gt5", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five, then drop the leading negative values.", "solution": "def op_sorta_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sorta_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_sorta_gt5_dropwhileneg([]) == []\nassert op_sorta_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_sorta_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_sorta_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_sorta_gt5_dropwhileneg([10]) == [10]\nassert op_sorta_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_sorta_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_evens_takewhilepos_div3", "entry_point": "op_evens_takewhilepos_div3", "primitives": ["evens", "takewhilepos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then keep multiples of three.", "solution": "def op_evens_takewhilepos_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_takewhilepos_div3([1, 2, 3, 4]) == []\nassert op_evens_takewhilepos_div3([]) == []\nassert op_evens_takewhilepos_div3([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_div3([5, 5, 5]) == []\nassert op_evens_takewhilepos_div3([3, 1, 2]) == []\nassert op_evens_takewhilepos_div3([10]) == []\nassert op_evens_takewhilepos_div3([2, 4, 6]) == [6]\nassert op_evens_takewhilepos_div3([-7, 12, -7]) == [12]"}
{"id": "op_ages_pos_negate", "entry_point": "op_ages_pos_negate", "primitives": ["ages", "pos", "negate"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers, then negate each.", "solution": "def op_ages_pos_negate(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_ages_pos_negate([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_pos_negate([]) == []\nassert op_ages_pos_negate([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_pos_negate([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_first3_add10_sum", "entry_point": "op_first3_add10_sum", "primitives": ["first3", "add10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then return their sum.", "solution": "def op_first3_add10_sum(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_first3_add10_sum([1, 2, 3, 4]) == 36\nassert op_first3_add10_sum([]) == 0\nassert op_first3_add10_sum([-2, -1, 0, 1, 2]) == 27\nassert op_first3_add10_sum([5, 5, 5]) == 45\nassert op_first3_add10_sum([3, 1, 2]) == 36\nassert op_first3_add10_sum([10]) == 20\nassert op_first3_add10_sum([2, 4, 6]) == 42\nassert op_first3_add10_sum([-7, 12, -7]) == 28"}
{"id": "op_add10_sorta_inc", "entry_point": "op_add10_sorta_inc", "primitives": ["add10", "sorta", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then add one to each.", "solution": "def op_add10_sorta_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_sorta_inc([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_add10_sorta_inc([]) == []\nassert op_add10_sorta_inc([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_add10_sorta_inc([5, 5, 5]) == [16, 16, 16]\nassert op_add10_sorta_inc([3, 1, 2]) == [12, 13, 14]\nassert op_add10_sorta_inc([10]) == [21]\nassert op_add10_sorta_inc([2, 4, 6]) == [13, 15, 17]\nassert op_add10_sorta_inc([-7, 12, -7]) == [4, 4, 23]"}
{"id": "op_takewhilepos_sortabs_min", "entry_point": "op_takewhilepos_sortabs_min", "primitives": ["takewhilepos", "sortabs", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_sortabs_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_sortabs_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_sortabs_min([]) == 0\nassert op_takewhilepos_sortabs_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sortabs_min([5, 5, 5]) == 5\nassert op_takewhilepos_sortabs_min([3, 1, 2]) == 1\nassert op_takewhilepos_sortabs_min([10]) == 10\nassert op_takewhilepos_sortabs_min([2, 4, 6]) == 2\nassert op_takewhilepos_sortabs_min([-7, 12, -7]) == 0"}
{"id": "op_padto3_first3_takewhilepos", "entry_point": "op_padto3_first3_takewhilepos", "primitives": ["padto3", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then take values while they are positive.", "solution": "def op_padto3_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_padto3_first3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_first3_takewhilepos([]) == []\nassert op_padto3_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_padto3_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_first3_takewhilepos([10]) == [10]\nassert op_padto3_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_first3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_clamp10_takewhilepos_dec", "entry_point": "op_clamp10_takewhilepos_dec", "primitives": ["clamp10", "takewhilepos", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive, then subtract one from each.", "solution": "def op_clamp10_takewhilepos_dec(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_clamp10_takewhilepos_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_clamp10_takewhilepos_dec([]) == []\nassert op_clamp10_takewhilepos_dec([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_takewhilepos_dec([5, 5, 5]) == [4, 4, 4]\nassert op_clamp10_takewhilepos_dec([3, 1, 2]) == [2, 0, 1]\nassert op_clamp10_takewhilepos_dec([10]) == [9]\nassert op_clamp10_takewhilepos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_clamp10_takewhilepos_dec([-7, 12, -7]) == []"}
{"id": "op_sortabs_odds_min", "entry_point": "op_sortabs_odds_min", "primitives": ["sortabs", "odds", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the odd numbers, then return the minimum (0 if empty).", "solution": "def op_sortabs_odds_min(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return min(r) if r else 0", "tests": "assert op_sortabs_odds_min([1, 2, 3, 4]) == 1\nassert op_sortabs_odds_min([]) == 0\nassert op_sortabs_odds_min([-2, -1, 0, 1, 2]) == -1\nassert op_sortabs_odds_min([5, 5, 5]) == 5\nassert op_sortabs_odds_min([3, 1, 2]) == 1\nassert op_sortabs_odds_min([10]) == 0\nassert op_sortabs_odds_min([2, 4, 6]) == 0\nassert op_sortabs_odds_min([-7, 12, -7]) == -7"}
{"id": "op_dropwhileneg_dec_padto3", "entry_point": "op_dropwhileneg_dec_padto3", "primitives": ["dropwhileneg", "dec", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_dropwhileneg_dec_padto3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropwhileneg_dec_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropwhileneg_dec_padto3([]) == [0, 0, 0]\nassert op_dropwhileneg_dec_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dropwhileneg_dec_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dropwhileneg_dec_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_dropwhileneg_dec_padto3([10]) == [9, 0, 0]\nassert op_dropwhileneg_dec_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dropwhileneg_dec_padto3([-7, 12, -7]) == [11, -8, 0]"}
{"id": "op_sorta_dropzeros_first3", "entry_point": "op_sorta_dropzeros_first3", "primitives": ["sorta", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then keep only the first three.", "solution": "def op_sorta_dropzeros_first3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_sorta_dropzeros_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_dropzeros_first3([]) == []\nassert op_sorta_dropzeros_first3([-2, -1, 0, 1, 2]) == [-2, -1, 1]\nassert op_sorta_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropzeros_first3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropzeros_first3([10]) == [10]\nassert op_sorta_dropzeros_first3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropzeros_first3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_padto3_neg_max", "entry_point": "op_padto3_neg_max", "primitives": ["padto3", "neg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_padto3_neg_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_padto3_neg_max([1, 2, 3, 4]) == 0\nassert op_padto3_neg_max([]) == 0\nassert op_padto3_neg_max([-2, -1, 0, 1, 2]) == -1\nassert op_padto3_neg_max([5, 5, 5]) == 0\nassert op_padto3_neg_max([3, 1, 2]) == 0\nassert op_padto3_neg_max([10]) == 0\nassert op_padto3_neg_max([2, 4, 6]) == 0\nassert op_padto3_neg_max([-7, 12, -7]) == -7"}
{"id": "op_ages_negate_pos", "entry_point": "op_ages_negate_pos", "primitives": ["ages", "negate", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then keep the positive numbers.", "solution": "def op_ages_negate_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_negate_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_negate_pos([]) == []\nassert op_ages_negate_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_negate_pos([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_oremptyzero_dec_dropwhileneg", "entry_point": "op_oremptyzero_dec_dropwhileneg", "primitives": ["oremptyzero", "dec", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then drop the leading negative values.", "solution": "def op_oremptyzero_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_dec_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_oremptyzero_dec_dropwhileneg([]) == []\nassert op_oremptyzero_dec_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_oremptyzero_dec_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_oremptyzero_dec_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_oremptyzero_dec_dropwhileneg([10]) == [9]\nassert op_oremptyzero_dec_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_oremptyzero_dec_dropwhileneg([-7, 12, -7]) == [11, -8]"}
{"id": "op_sorta_dropzeros_sortabs", "entry_point": "op_sorta_dropzeros_sortabs", "primitives": ["sorta", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then sort by absolute value.", "solution": "def op_sorta_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_dropzeros_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropzeros_sortabs([]) == []\nassert op_sorta_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sorta_dropzeros_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropzeros_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropzeros_sortabs([10]) == [10]\nassert op_sorta_dropzeros_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropzeros_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_last3_padto3_counteven", "entry_point": "op_last3_padto3_counteven", "primitives": ["last3", "padto3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_last3_padto3_counteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_last3_padto3_counteven([1, 2, 3, 4]) == 2\nassert op_last3_padto3_counteven([]) == 3\nassert op_last3_padto3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_last3_padto3_counteven([5, 5, 5]) == 0\nassert op_last3_padto3_counteven([3, 1, 2]) == 1\nassert op_last3_padto3_counteven([10]) == 3\nassert op_last3_padto3_counteven([2, 4, 6]) == 3\nassert op_last3_padto3_counteven([-7, 12, -7]) == 1"}
{"id": "op_names_dropshort_anyempty", "entry_point": "op_names_dropshort_anyempty", "primitives": ["names", "dropshort", "anyempty"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop strings shorter than three characters, then return whether any string is empty.", "solution": "def op_names_dropshort_anyempty(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if len(s) >= 3]\n    return any(s == '' for s in r)", "tests": "assert op_names_dropshort_anyempty([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_names_dropshort_anyempty([]) == False\nassert op_names_dropshort_anyempty([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_names_dropshort_anyempty([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_evens_uniq_gt5", "entry_point": "op_evens_uniq_gt5", "primitives": ["evens", "uniq", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_evens_uniq_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_evens_uniq_gt5([1, 2, 3, 4]) == []\nassert op_evens_uniq_gt5([]) == []\nassert op_evens_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_evens_uniq_gt5([5, 5, 5]) == []\nassert op_evens_uniq_gt5([3, 1, 2]) == []\nassert op_evens_uniq_gt5([10]) == [10]\nassert op_evens_uniq_gt5([2, 4, 6]) == [6]\nassert op_evens_uniq_gt5([-7, 12, -7]) == [12]"}
{"id": "op_div3_absval_haszero", "entry_point": "op_div3_absval_haszero", "primitives": ["div3", "absval", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_div3_absval_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_div3_absval_haszero([1, 2, 3, 4]) == False\nassert op_div3_absval_haszero([]) == False\nassert op_div3_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_absval_haszero([5, 5, 5]) == False\nassert op_div3_absval_haszero([3, 1, 2]) == False\nassert op_div3_absval_haszero([10]) == False\nassert op_div3_absval_haszero([2, 4, 6]) == False\nassert op_div3_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_div3_odds", "entry_point": "op_oremptyzero_div3_odds", "primitives": ["oremptyzero", "div3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep multiples of three, then keep the odd numbers.", "solution": "def op_oremptyzero_div3_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_div3_odds([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_div3_odds([]) == []\nassert op_oremptyzero_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_div3_odds([5, 5, 5]) == []\nassert op_oremptyzero_div3_odds([3, 1, 2]) == [3]\nassert op_oremptyzero_div3_odds([10]) == []\nassert op_oremptyzero_div3_odds([2, 4, 6]) == []\nassert op_oremptyzero_div3_odds([-7, 12, -7]) == []"}
{"id": "op_dropshort_firstchar_longest", "entry_point": "op_dropshort_firstchar_longest", "primitives": ["dropshort", "firstchar", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_dropshort_firstchar_longest(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_dropshort_firstchar_longest(['Hello', 'world']) == 'H'\nassert op_dropshort_firstchar_longest([]) == ''\nassert op_dropshort_firstchar_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_dropshort_firstchar_longest(['one', 'one', 'Two']) == 'o'\nassert op_dropshort_firstchar_longest(['x']) == ''\nassert op_dropshort_firstchar_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_dropfirst_sortabs_sortd", "entry_point": "op_dropfirst_sortabs_sortd", "primitives": ["dropfirst", "sortabs", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then sort descending.", "solution": "def op_dropfirst_sortabs_sortd(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropfirst_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_sortabs_sortd([]) == []\nassert op_dropfirst_sortabs_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_sortabs_sortd([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortabs_sortd([3, 1, 2]) == [2, 1]\nassert op_dropfirst_sortabs_sortd([10]) == []\nassert op_dropfirst_sortabs_sortd([2, 4, 6]) == [6, 4]\nassert op_dropfirst_sortabs_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortlen_lower_maxlen", "entry_point": "op_sortlen_lower_maxlen", "primitives": ["sortlen", "lower", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then lowercase each string, then return the length of the longest string (0 if none).", "solution": "def op_sortlen_lower_maxlen(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.lower() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortlen_lower_maxlen(['Hello', 'world']) == 5\nassert op_sortlen_lower_maxlen([]) == 0\nassert op_sortlen_lower_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortlen_lower_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortlen_lower_maxlen(['x']) == 1\nassert op_sortlen_lower_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_clamp10_add10_anyeven", "entry_point": "op_clamp10_add10_anyeven", "primitives": ["clamp10", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then return whether any value is even.", "solution": "def op_clamp10_add10_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_add10_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_add10_anyeven([]) == False\nassert op_clamp10_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_add10_anyeven([5, 5, 5]) == False\nassert op_clamp10_add10_anyeven([3, 1, 2]) == True\nassert op_clamp10_add10_anyeven([10]) == True\nassert op_clamp10_add10_anyeven([2, 4, 6]) == True\nassert op_clamp10_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_dropfirst_first3", "entry_point": "op_uniq_dropfirst_first3", "primitives": ["uniq", "dropfirst", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then keep only the first three.", "solution": "def op_uniq_dropfirst_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = r[:3]\n    return r", "tests": "assert op_uniq_dropfirst_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_dropfirst_first3([]) == []\nassert op_uniq_dropfirst_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_uniq_dropfirst_first3([5, 5, 5]) == []\nassert op_uniq_dropfirst_first3([3, 1, 2]) == [1, 2]\nassert op_uniq_dropfirst_first3([10]) == []\nassert op_uniq_dropfirst_first3([2, 4, 6]) == [4, 6]\nassert op_uniq_dropfirst_first3([-7, 12, -7]) == [12]"}
{"id": "op_first3_gt5_haszero", "entry_point": "op_first3_gt5_haszero", "primitives": ["first3", "gt5", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then return whether the list contains a zero.", "solution": "def op_first3_gt5_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_first3_gt5_haszero([1, 2, 3, 4]) == False\nassert op_first3_gt5_haszero([]) == False\nassert op_first3_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_first3_gt5_haszero([5, 5, 5]) == False\nassert op_first3_gt5_haszero([3, 1, 2]) == False\nassert op_first3_gt5_haszero([10]) == False\nassert op_first3_gt5_haszero([2, 4, 6]) == False\nassert op_first3_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_takewhilepos_odds", "entry_point": "op_padto3_takewhilepos_odds", "primitives": ["padto3", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then keep the odd numbers.", "solution": "def op_padto3_takewhilepos_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_takewhilepos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_takewhilepos_odds([]) == []\nassert op_padto3_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_takewhilepos_odds([10]) == []\nassert op_padto3_takewhilepos_odds([2, 4, 6]) == []\nassert op_padto3_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_beforezero_add10_len", "entry_point": "op_beforezero_add10_len", "primitives": ["beforezero", "add10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then return how many remain.", "solution": "def op_beforezero_add10_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_beforezero_add10_len([1, 2, 3, 4]) == 4\nassert op_beforezero_add10_len([]) == 0\nassert op_beforezero_add10_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_add10_len([5, 5, 5]) == 3\nassert op_beforezero_add10_len([3, 1, 2]) == 3\nassert op_beforezero_add10_len([10]) == 1\nassert op_beforezero_add10_len([2, 4, 6]) == 3\nassert op_beforezero_add10_len([-7, 12, -7]) == 3"}
{"id": "op_neg_sorta_max", "entry_point": "op_neg_sorta_max", "primitives": ["neg", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_neg_sorta_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_neg_sorta_max([1, 2, 3, 4]) == 0\nassert op_neg_sorta_max([]) == 0\nassert op_neg_sorta_max([-2, -1, 0, 1, 2]) == -1\nassert op_neg_sorta_max([5, 5, 5]) == 0\nassert op_neg_sorta_max([3, 1, 2]) == 0\nassert op_neg_sorta_max([10]) == 0\nassert op_neg_sorta_max([2, 4, 6]) == 0\nassert op_neg_sorta_max([-7, 12, -7]) == -7"}
{"id": "op_add10_takewhilepos_absval", "entry_point": "op_add10_takewhilepos_absval", "primitives": ["add10", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then take the absolute value of each.", "solution": "def op_add10_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_takewhilepos_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_takewhilepos_absval([]) == []\nassert op_add10_takewhilepos_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_takewhilepos_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos_absval([3, 1, 2]) == [13, 11, 12]\nassert op_add10_takewhilepos_absval([10]) == [20]\nassert op_add10_takewhilepos_absval([2, 4, 6]) == [12, 14, 16]\nassert op_add10_takewhilepos_absval([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_oremptyzero_square_last3", "entry_point": "op_oremptyzero_square_last3", "primitives": ["oremptyzero", "square", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then keep only the last three.", "solution": "def op_oremptyzero_square_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_square_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_oremptyzero_square_last3([]) == [0]\nassert op_oremptyzero_square_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_oremptyzero_square_last3([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_square_last3([3, 1, 2]) == [9, 1, 4]\nassert op_oremptyzero_square_last3([10]) == [100]\nassert op_oremptyzero_square_last3([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_square_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_odds_takewhilepos_double", "entry_point": "op_odds_takewhilepos_double", "primitives": ["odds", "takewhilepos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take values while they are positive, then double each.", "solution": "def op_odds_takewhilepos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_takewhilepos_double([1, 2, 3, 4]) == [2, 6]\nassert op_odds_takewhilepos_double([]) == []\nassert op_odds_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_odds_takewhilepos_double([5, 5, 5]) == [10, 10, 10]\nassert op_odds_takewhilepos_double([3, 1, 2]) == [6, 2]\nassert op_odds_takewhilepos_double([10]) == []\nassert op_odds_takewhilepos_double([2, 4, 6]) == []\nassert op_odds_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_last3_oremptyzero_max", "entry_point": "op_last3_oremptyzero_max", "primitives": ["last3", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_last3_oremptyzero_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_last3_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_last3_oremptyzero_max([]) == 0\nassert op_last3_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_last3_oremptyzero_max([5, 5, 5]) == 5\nassert op_last3_oremptyzero_max([3, 1, 2]) == 3\nassert op_last3_oremptyzero_max([10]) == 10\nassert op_last3_oremptyzero_max([2, 4, 6]) == 6\nassert op_last3_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_padto3_dropwhileneg_first3", "entry_point": "op_padto3_dropwhileneg_first3", "primitives": ["padto3", "dropwhileneg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then keep only the first three.", "solution": "def op_padto3_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_dropwhileneg_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_dropwhileneg_first3([]) == [0, 0, 0]\nassert op_padto3_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_dropwhileneg_first3([10]) == [10, 0, 0]\nassert op_padto3_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_dropwhileneg_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_negate_evens", "entry_point": "op_dropfirst_negate_evens", "primitives": ["dropfirst", "negate", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then keep the even numbers.", "solution": "def op_dropfirst_negate_evens(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropfirst_negate_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_dropfirst_negate_evens([]) == []\nassert op_dropfirst_negate_evens([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_dropfirst_negate_evens([5, 5, 5]) == []\nassert op_dropfirst_negate_evens([3, 1, 2]) == [-2]\nassert op_dropfirst_negate_evens([10]) == []\nassert op_dropfirst_negate_evens([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_negate_evens([-7, 12, -7]) == [-12]"}
{"id": "op_negate_dropzeros_first3", "entry_point": "op_negate_dropzeros_first3", "primitives": ["negate", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then keep only the first three.", "solution": "def op_negate_dropzeros_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_negate_dropzeros_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_dropzeros_first3([]) == []\nassert op_negate_dropzeros_first3([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_negate_dropzeros_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_dropzeros_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_dropzeros_first3([10]) == [-10]\nassert op_negate_dropzeros_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_dropzeros_first3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_beforezero_pos_max", "entry_point": "op_beforezero_pos_max", "primitives": ["beforezero", "pos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_beforezero_pos_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_beforezero_pos_max([1, 2, 3, 4]) == 4\nassert op_beforezero_pos_max([]) == 0\nassert op_beforezero_pos_max([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_pos_max([5, 5, 5]) == 5\nassert op_beforezero_pos_max([3, 1, 2]) == 3\nassert op_beforezero_pos_max([10]) == 10\nassert op_beforezero_pos_max([2, 4, 6]) == 6\nassert op_beforezero_pos_max([-7, 12, -7]) == 12"}
{"id": "op_sorta_takewhilepos_negate", "entry_point": "op_sorta_takewhilepos_negate", "primitives": ["sorta", "takewhilepos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then negate each.", "solution": "def op_sorta_takewhilepos_negate(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sorta_takewhilepos_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_takewhilepos_negate([]) == []\nassert op_sorta_takewhilepos_negate([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_takewhilepos_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_takewhilepos_negate([10]) == [-10]\nassert op_sorta_takewhilepos_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_takewhilepos_negate([-7, 12, -7]) == []"}
{"id": "op_sortage_names_counts", "entry_point": "op_sortage_names_counts", "primitives": ["sortage", "names", "counts"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the names, then return how many strings remain.", "solution": "def op_sortage_names_counts(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['name'] for d in r]\n    return len(r)", "tests": "assert op_sortage_names_counts([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_sortage_names_counts([]) == 0\nassert op_sortage_names_counts([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_sortage_names_counts([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_dropfirst_rev_first3", "entry_point": "op_dropfirst_rev_first3", "primitives": ["dropfirst", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then keep only the first three.", "solution": "def op_dropfirst_rev_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_rev_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev_first3([]) == []\nassert op_dropfirst_rev_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropfirst_rev_first3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_rev_first3([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev_first3([10]) == []\nassert op_dropfirst_rev_first3([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_first3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sorta_evens_prod", "entry_point": "op_sorta_evens_prod", "primitives": ["sorta", "evens", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then return their product.", "solution": "def op_sorta_evens_prod(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_sorta_evens_prod([1, 2, 3, 4]) == 8\nassert op_sorta_evens_prod([]) == 1\nassert op_sorta_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_evens_prod([5, 5, 5]) == 1\nassert op_sorta_evens_prod([3, 1, 2]) == 2\nassert op_sorta_evens_prod([10]) == 10\nassert op_sorta_evens_prod([2, 4, 6]) == 48\nassert op_sorta_evens_prod([-7, 12, -7]) == 12"}
{"id": "op_pos_dropwhileneg_sortabs", "entry_point": "op_pos_dropwhileneg_sortabs", "primitives": ["pos", "dropwhileneg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then sort by absolute value.", "solution": "def op_pos_dropwhileneg_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_pos_dropwhileneg_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_dropwhileneg_sortabs([]) == []\nassert op_pos_dropwhileneg_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropwhileneg_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_pos_dropwhileneg_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_pos_dropwhileneg_sortabs([10]) == [10]\nassert op_pos_dropwhileneg_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropwhileneg_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_absval_trimends_oremptyzero", "entry_point": "op_absval_trimends_oremptyzero", "primitives": ["absval", "trimends", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then if empty, use a single zero.", "solution": "def op_absval_trimends_oremptyzero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    r = r if r else [0]\n    return r", "tests": "assert op_absval_trimends_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_absval_trimends_oremptyzero([]) == [0]\nassert op_absval_trimends_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_absval_trimends_oremptyzero([5, 5, 5]) == [5]\nassert op_absval_trimends_oremptyzero([3, 1, 2]) == [1]\nassert op_absval_trimends_oremptyzero([10]) == [0]\nassert op_absval_trimends_oremptyzero([2, 4, 6]) == [4]\nassert op_absval_trimends_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_rev_div3", "entry_point": "op_dropwhileneg_rev_div3", "primitives": ["dropwhileneg", "rev", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then keep multiples of three.", "solution": "def op_dropwhileneg_rev_div3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropwhileneg_rev_div3([1, 2, 3, 4]) == [3]\nassert op_dropwhileneg_rev_div3([]) == []\nassert op_dropwhileneg_rev_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_rev_div3([5, 5, 5]) == []\nassert op_dropwhileneg_rev_div3([3, 1, 2]) == [3]\nassert op_dropwhileneg_rev_div3([10]) == []\nassert op_dropwhileneg_rev_div3([2, 4, 6]) == [6]\nassert op_dropwhileneg_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_pos_clamp10_min", "entry_point": "op_pos_clamp10_min", "primitives": ["pos", "clamp10", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then return the minimum (0 if empty).", "solution": "def op_pos_clamp10_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return min(r) if r else 0", "tests": "assert op_pos_clamp10_min([1, 2, 3, 4]) == 1\nassert op_pos_clamp10_min([]) == 0\nassert op_pos_clamp10_min([-2, -1, 0, 1, 2]) == 1\nassert op_pos_clamp10_min([5, 5, 5]) == 5\nassert op_pos_clamp10_min([3, 1, 2]) == 1\nassert op_pos_clamp10_min([10]) == 10\nassert op_pos_clamp10_min([2, 4, 6]) == 2\nassert op_pos_clamp10_min([-7, 12, -7]) == 10"}
{"id": "op_square_takewhilepos_sum", "entry_point": "op_square_takewhilepos_sum", "primitives": ["square", "takewhilepos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then return their sum.", "solution": "def op_square_takewhilepos_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_square_takewhilepos_sum([1, 2, 3, 4]) == 30\nassert op_square_takewhilepos_sum([]) == 0\nassert op_square_takewhilepos_sum([-2, -1, 0, 1, 2]) == 5\nassert op_square_takewhilepos_sum([5, 5, 5]) == 75\nassert op_square_takewhilepos_sum([3, 1, 2]) == 14\nassert op_square_takewhilepos_sum([10]) == 100\nassert op_square_takewhilepos_sum([2, 4, 6]) == 56\nassert op_square_takewhilepos_sum([-7, 12, -7]) == 242"}
{"id": "op_uniq_sorta_clamp10", "entry_point": "op_uniq_sorta_clamp10", "primitives": ["uniq", "sorta", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then cap each value at 10.", "solution": "def op_uniq_sorta_clamp10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_uniq_sorta_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sorta_clamp10([]) == []\nassert op_uniq_sorta_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_sorta_clamp10([5, 5, 5]) == [5]\nassert op_uniq_sorta_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sorta_clamp10([10]) == [10]\nassert op_uniq_sorta_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sorta_clamp10([-7, 12, -7]) == [-7, 10]"}
{"id": "op_first3_double_takewhilepos", "entry_point": "op_first3_double_takewhilepos", "primitives": ["first3", "double", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then take values while they are positive.", "solution": "def op_first3_double_takewhilepos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_first3_double_takewhilepos([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_double_takewhilepos([]) == []\nassert op_first3_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_first3_double_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_first3_double_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_first3_double_takewhilepos([10]) == [20]\nassert op_first3_double_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_first3_double_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_gt5_rev_sorta", "entry_point": "op_gt5_rev_sorta", "primitives": ["gt5", "rev", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then sort ascending.", "solution": "def op_gt5_rev_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_rev_sorta([1, 2, 3, 4]) == []\nassert op_gt5_rev_sorta([]) == []\nassert op_gt5_rev_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_rev_sorta([5, 5, 5]) == []\nassert op_gt5_rev_sorta([3, 1, 2]) == []\nassert op_gt5_rev_sorta([10]) == [10]\nassert op_gt5_rev_sorta([2, 4, 6]) == [6]\nassert op_gt5_rev_sorta([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_first3_counteven", "entry_point": "op_oremptyzero_first3_counteven", "primitives": ["oremptyzero", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then return how many values are even.", "solution": "def op_oremptyzero_first3_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_first3_counteven([1, 2, 3, 4]) == 1\nassert op_oremptyzero_first3_counteven([]) == 1\nassert op_oremptyzero_first3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_first3_counteven([5, 5, 5]) == 0\nassert op_oremptyzero_first3_counteven([3, 1, 2]) == 1\nassert op_oremptyzero_first3_counteven([10]) == 1\nassert op_oremptyzero_first3_counteven([2, 4, 6]) == 3\nassert op_oremptyzero_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_odds_evens", "entry_point": "op_rev_odds_evens", "primitives": ["rev", "odds", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then keep the even numbers.", "solution": "def op_rev_odds_evens(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_rev_odds_evens([1, 2, 3, 4]) == []\nassert op_rev_odds_evens([]) == []\nassert op_rev_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_rev_odds_evens([5, 5, 5]) == []\nassert op_rev_odds_evens([3, 1, 2]) == []\nassert op_rev_odds_evens([10]) == []\nassert op_rev_odds_evens([2, 4, 6]) == []\nassert op_rev_odds_evens([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_trimends_absval", "entry_point": "op_oremptyzero_trimends_absval", "primitives": ["oremptyzero", "trimends", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_oremptyzero_trimends_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_trimends_absval([1, 2, 3, 4]) == [2, 3]\nassert op_oremptyzero_trimends_absval([]) == []\nassert op_oremptyzero_trimends_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_oremptyzero_trimends_absval([5, 5, 5]) == [5]\nassert op_oremptyzero_trimends_absval([3, 1, 2]) == [1]\nassert op_oremptyzero_trimends_absval([10]) == []\nassert op_oremptyzero_trimends_absval([2, 4, 6]) == [4]\nassert op_oremptyzero_trimends_absval([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_pos_issorted", "entry_point": "op_oremptyzero_pos_issorted", "primitives": ["oremptyzero", "pos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_pos_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_oremptyzero_pos_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_pos_issorted([]) == True\nassert op_oremptyzero_pos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_pos_issorted([5, 5, 5]) == True\nassert op_oremptyzero_pos_issorted([3, 1, 2]) == False\nassert op_oremptyzero_pos_issorted([10]) == True\nassert op_oremptyzero_pos_issorted([2, 4, 6]) == True\nassert op_oremptyzero_pos_issorted([-7, 12, -7]) == True"}
{"id": "op_ages_odds_absval", "entry_point": "op_ages_odds_absval", "primitives": ["ages", "odds", "absval"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then take the absolute value of each.", "solution": "def op_ages_odds_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_odds_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_odds_absval([]) == []\nassert op_ages_odds_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_odds_absval([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortd_oremptyzero_pos", "entry_point": "op_sortd_oremptyzero_pos", "primitives": ["sortd", "oremptyzero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_sortd_oremptyzero_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_oremptyzero_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_oremptyzero_pos([]) == []\nassert op_sortd_oremptyzero_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_oremptyzero_pos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_oremptyzero_pos([10]) == [10]\nassert op_sortd_oremptyzero_pos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_sorta_takewhilepos_max", "entry_point": "op_sorta_takewhilepos_max", "primitives": ["sorta", "takewhilepos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_sorta_takewhilepos_max(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_sorta_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_sorta_takewhilepos_max([]) == 0\nassert op_sorta_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_takewhilepos_max([5, 5, 5]) == 5\nassert op_sorta_takewhilepos_max([3, 1, 2]) == 3\nassert op_sorta_takewhilepos_max([10]) == 10\nassert op_sorta_takewhilepos_max([2, 4, 6]) == 6\nassert op_sorta_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_sortabs_rev_oremptyzero", "entry_point": "op_sortabs_rev_oremptyzero", "primitives": ["sortabs", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then if empty, use a single zero.", "solution": "def op_sortabs_rev_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_sortabs_rev_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_rev_oremptyzero([]) == [0]\nassert op_sortabs_rev_oremptyzero([-2, -1, 0, 1, 2]) == [2, -2, 1, -1, 0]\nassert op_sortabs_rev_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_rev_oremptyzero([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_rev_oremptyzero([10]) == [10]\nassert op_sortabs_rev_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_rev_oremptyzero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_first3_oremptyzero_min", "entry_point": "op_first3_oremptyzero_min", "primitives": ["first3", "oremptyzero", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_first3_oremptyzero_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_first3_oremptyzero_min([1, 2, 3, 4]) == 1\nassert op_first3_oremptyzero_min([]) == 0\nassert op_first3_oremptyzero_min([-2, -1, 0, 1, 2]) == -2\nassert op_first3_oremptyzero_min([5, 5, 5]) == 5\nassert op_first3_oremptyzero_min([3, 1, 2]) == 1\nassert op_first3_oremptyzero_min([10]) == 10\nassert op_first3_oremptyzero_min([2, 4, 6]) == 2\nassert op_first3_oremptyzero_min([-7, 12, -7]) == -7"}
{"id": "op_sortabs_neg_dropfirst", "entry_point": "op_sortabs_neg_dropfirst", "primitives": ["sortabs", "neg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then drop the first element.", "solution": "def op_sortabs_neg_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_sortabs_neg_dropfirst([]) == []\nassert op_sortabs_neg_dropfirst([-2, -1, 0, 1, 2]) == [-2]\nassert op_sortabs_neg_dropfirst([5, 5, 5]) == []\nassert op_sortabs_neg_dropfirst([3, 1, 2]) == []\nassert op_sortabs_neg_dropfirst([10]) == []\nassert op_sortabs_neg_dropfirst([2, 4, 6]) == []\nassert op_sortabs_neg_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_double_sorta_allpos", "entry_point": "op_double_sorta_allpos", "primitives": ["double", "sorta", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending, then return whether all values are positive.", "solution": "def op_double_sorta_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return all(x > 0 for x in r)", "tests": "assert op_double_sorta_allpos([1, 2, 3, 4]) == True\nassert op_double_sorta_allpos([]) == True\nassert op_double_sorta_allpos([-2, -1, 0, 1, 2]) == False\nassert op_double_sorta_allpos([5, 5, 5]) == True\nassert op_double_sorta_allpos([3, 1, 2]) == True\nassert op_double_sorta_allpos([10]) == True\nassert op_double_sorta_allpos([2, 4, 6]) == True\nassert op_double_sorta_allpos([-7, 12, -7]) == False"}
{"id": "op_padto3_rev_last3", "entry_point": "op_padto3_rev_last3", "primitives": ["padto3", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order, then keep only the last three.", "solution": "def op_padto3_rev_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_rev_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_padto3_rev_last3([]) == [0, 0, 0]\nassert op_padto3_rev_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_padto3_rev_last3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_rev_last3([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_rev_last3([10]) == [0, 0, 10]\nassert op_padto3_rev_last3([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_rev_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_double_sortabs_last3", "entry_point": "op_double_sortabs_last3", "primitives": ["double", "sortabs", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then keep only the last three.", "solution": "def op_double_sortabs_last3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_double_sortabs_last3([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_sortabs_last3([]) == []\nassert op_double_sortabs_last3([-2, -1, 0, 1, 2]) == [2, -4, 4]\nassert op_double_sortabs_last3([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortabs_last3([3, 1, 2]) == [2, 4, 6]\nassert op_double_sortabs_last3([10]) == [20]\nassert op_double_sortabs_last3([2, 4, 6]) == [4, 8, 12]\nassert op_double_sortabs_last3([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_beforezero_neg_div3", "entry_point": "op_beforezero_neg_div3", "primitives": ["beforezero", "neg", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then keep multiples of three.", "solution": "def op_beforezero_neg_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_neg_div3([1, 2, 3, 4]) == []\nassert op_beforezero_neg_div3([]) == []\nassert op_beforezero_neg_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_neg_div3([5, 5, 5]) == []\nassert op_beforezero_neg_div3([3, 1, 2]) == []\nassert op_beforezero_neg_div3([10]) == []\nassert op_beforezero_neg_div3([2, 4, 6]) == []\nassert op_beforezero_neg_div3([-7, 12, -7]) == []"}
{"id": "op_beforezero_padto3_max", "entry_point": "op_beforezero_padto3_max", "primitives": ["beforezero", "padto3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_beforezero_padto3_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_beforezero_padto3_max([1, 2, 3, 4]) == 4\nassert op_beforezero_padto3_max([]) == 0\nassert op_beforezero_padto3_max([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_padto3_max([5, 5, 5]) == 5\nassert op_beforezero_padto3_max([3, 1, 2]) == 3\nassert op_beforezero_padto3_max([10]) == 10\nassert op_beforezero_padto3_max([2, 4, 6]) == 6\nassert op_beforezero_padto3_max([-7, 12, -7]) == 12"}
{"id": "op_square_padto3_pos", "entry_point": "op_square_padto3_pos", "primitives": ["square", "padto3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then keep the positive numbers.", "solution": "def op_square_padto3_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_padto3_pos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_padto3_pos([]) == []\nassert op_square_padto3_pos([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_square_padto3_pos([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3_pos([3, 1, 2]) == [9, 1, 4]\nassert op_square_padto3_pos([10]) == [100]\nassert op_square_padto3_pos([2, 4, 6]) == [4, 16, 36]\nassert op_square_padto3_pos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_add10_dropfirst_oremptyzero", "entry_point": "op_add10_dropfirst_oremptyzero", "primitives": ["add10", "dropfirst", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then if empty, use a single zero.", "solution": "def op_add10_dropfirst_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_dropfirst_oremptyzero([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropfirst_oremptyzero([]) == [0]\nassert op_add10_dropfirst_oremptyzero([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_dropfirst_oremptyzero([5, 5, 5]) == [15, 15]\nassert op_add10_dropfirst_oremptyzero([3, 1, 2]) == [11, 12]\nassert op_add10_dropfirst_oremptyzero([10]) == [0]\nassert op_add10_dropfirst_oremptyzero([2, 4, 6]) == [14, 16]\nassert op_add10_dropfirst_oremptyzero([-7, 12, -7]) == [22, 3]"}
{"id": "op_clamp10_odds_issorted", "entry_point": "op_clamp10_odds_issorted", "primitives": ["clamp10", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_clamp10_odds_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_clamp10_odds_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_odds_issorted([]) == True\nassert op_clamp10_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_odds_issorted([5, 5, 5]) == True\nassert op_clamp10_odds_issorted([3, 1, 2]) == False\nassert op_clamp10_odds_issorted([10]) == True\nassert op_clamp10_odds_issorted([2, 4, 6]) == True\nassert op_clamp10_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_absval_trimends_square", "entry_point": "op_absval_trimends_square", "primitives": ["absval", "trimends", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then square each.", "solution": "def op_absval_trimends_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_trimends_square([1, 2, 3, 4]) == [4, 9]\nassert op_absval_trimends_square([]) == []\nassert op_absval_trimends_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_absval_trimends_square([5, 5, 5]) == [25]\nassert op_absval_trimends_square([3, 1, 2]) == [1]\nassert op_absval_trimends_square([10]) == []\nassert op_absval_trimends_square([2, 4, 6]) == [16]\nassert op_absval_trimends_square([-7, 12, -7]) == [144]"}
{"id": "op_dropwhileneg_clamp10_takewhilepos", "entry_point": "op_dropwhileneg_clamp10_takewhilepos", "primitives": ["dropwhileneg", "clamp10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then take values while they are positive.", "solution": "def op_dropwhileneg_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_clamp10_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_clamp10_takewhilepos([]) == []\nassert op_dropwhileneg_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_clamp10_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_clamp10_takewhilepos([10]) == [10]\nassert op_dropwhileneg_clamp10_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_clamp10_takewhilepos([-7, 12, -7]) == [10]"}
{"id": "op_takewhilepos_evens_sortd", "entry_point": "op_takewhilepos_evens_sortd", "primitives": ["takewhilepos", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers, then sort descending.", "solution": "def op_takewhilepos_evens_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_takewhilepos_evens_sortd([]) == []\nassert op_takewhilepos_evens_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens_sortd([5, 5, 5]) == []\nassert op_takewhilepos_evens_sortd([3, 1, 2]) == [2]\nassert op_takewhilepos_evens_sortd([10]) == [10]\nassert op_takewhilepos_evens_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_evens_sortd([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sortabs_add10", "entry_point": "op_takewhilepos_sortabs_add10", "primitives": ["takewhilepos", "sortabs", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then add ten to each.", "solution": "def op_takewhilepos_sortabs_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_sortabs_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_takewhilepos_sortabs_add10([]) == []\nassert op_takewhilepos_sortabs_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_add10([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_sortabs_add10([3, 1, 2]) == [11, 12, 13]\nassert op_takewhilepos_sortabs_add10([10]) == [20]\nassert op_takewhilepos_sortabs_add10([2, 4, 6]) == [12, 14, 16]\nassert op_takewhilepos_sortabs_add10([-7, 12, -7]) == []"}
{"id": "op_rev_beforezero_inc", "entry_point": "op_rev_beforezero_inc", "primitives": ["rev", "beforezero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then add one to each.", "solution": "def op_rev_beforezero_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_beforezero_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_rev_beforezero_inc([]) == []\nassert op_rev_beforezero_inc([-2, -1, 0, 1, 2]) == [3, 2]\nassert op_rev_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_rev_beforezero_inc([3, 1, 2]) == [3, 2, 4]\nassert op_rev_beforezero_inc([10]) == [11]\nassert op_rev_beforezero_inc([2, 4, 6]) == [7, 5, 3]\nassert op_rev_beforezero_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_last3_inc_anyeven", "entry_point": "op_last3_inc_anyeven", "primitives": ["last3", "inc", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then return whether any value is even.", "solution": "def op_last3_inc_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_inc_anyeven([1, 2, 3, 4]) == True\nassert op_last3_inc_anyeven([]) == False\nassert op_last3_inc_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_inc_anyeven([5, 5, 5]) == True\nassert op_last3_inc_anyeven([3, 1, 2]) == True\nassert op_last3_inc_anyeven([10]) == False\nassert op_last3_inc_anyeven([2, 4, 6]) == False\nassert op_last3_inc_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_dropzeros_odds", "entry_point": "op_clamp10_dropzeros_odds", "primitives": ["clamp10", "dropzeros", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then keep the odd numbers.", "solution": "def op_clamp10_dropzeros_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_dropzeros_odds([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_dropzeros_odds([]) == []\nassert op_clamp10_dropzeros_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_dropzeros_odds([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropzeros_odds([3, 1, 2]) == [3, 1]\nassert op_clamp10_dropzeros_odds([10]) == []\nassert op_clamp10_dropzeros_odds([2, 4, 6]) == []\nassert op_clamp10_dropzeros_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_double_gt5", "entry_point": "op_uniq_double_gt5", "primitives": ["uniq", "double", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then keep values greater than five.", "solution": "def op_uniq_double_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_uniq_double_gt5([]) == []\nassert op_uniq_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_double_gt5([5, 5, 5]) == [10]\nassert op_uniq_double_gt5([3, 1, 2]) == [6]\nassert op_uniq_double_gt5([10]) == [20]\nassert op_uniq_double_gt5([2, 4, 6]) == [8, 12]\nassert op_uniq_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_dropfirst_beforezero_trimends", "entry_point": "op_dropfirst_beforezero_trimends", "primitives": ["dropfirst", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_dropfirst_beforezero_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_beforezero_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_beforezero_trimends([]) == []\nassert op_dropfirst_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_beforezero_trimends([5, 5, 5]) == []\nassert op_dropfirst_beforezero_trimends([3, 1, 2]) == []\nassert op_dropfirst_beforezero_trimends([10]) == []\nassert op_dropfirst_beforezero_trimends([2, 4, 6]) == []\nassert op_dropfirst_beforezero_trimends([-7, 12, -7]) == []"}
{"id": "op_trimends_sortabs_odds", "entry_point": "op_trimends_sortabs_odds", "primitives": ["trimends", "sortabs", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then keep the odd numbers.", "solution": "def op_trimends_sortabs_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_sortabs_odds([1, 2, 3, 4]) == [3]\nassert op_trimends_sortabs_odds([]) == []\nassert op_trimends_sortabs_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_sortabs_odds([5, 5, 5]) == [5]\nassert op_trimends_sortabs_odds([3, 1, 2]) == [1]\nassert op_trimends_sortabs_odds([10]) == []\nassert op_trimends_sortabs_odds([2, 4, 6]) == []\nassert op_trimends_sortabs_odds([-7, 12, -7]) == []"}
{"id": "op_trimends_evens_div3", "entry_point": "op_trimends_evens_div3", "primitives": ["trimends", "evens", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then keep multiples of three.", "solution": "def op_trimends_evens_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_evens_div3([1, 2, 3, 4]) == []\nassert op_trimends_evens_div3([]) == []\nassert op_trimends_evens_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_evens_div3([5, 5, 5]) == []\nassert op_trimends_evens_div3([3, 1, 2]) == []\nassert op_trimends_evens_div3([10]) == []\nassert op_trimends_evens_div3([2, 4, 6]) == []\nassert op_trimends_evens_div3([-7, 12, -7]) == [12]"}
{"id": "op_ages_last3_pos", "entry_point": "op_ages_last3_pos", "primitives": ["ages", "last3", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then keep the positive numbers.", "solution": "def op_ages_last3_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_last3_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_last3_pos([]) == []\nassert op_ages_last3_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_last3_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_takewhilepos_inc_counteven", "entry_point": "op_takewhilepos_inc_counteven", "primitives": ["takewhilepos", "inc", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then return how many values are even.", "solution": "def op_takewhilepos_inc_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_inc_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_inc_counteven([]) == 0\nassert op_takewhilepos_inc_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_inc_counteven([5, 5, 5]) == 3\nassert op_takewhilepos_inc_counteven([3, 1, 2]) == 2\nassert op_takewhilepos_inc_counteven([10]) == 0\nassert op_takewhilepos_inc_counteven([2, 4, 6]) == 0\nassert op_takewhilepos_inc_counteven([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_evens_beforezero", "entry_point": "op_oremptyzero_evens_beforezero", "primitives": ["oremptyzero", "evens", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_oremptyzero_evens_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_evens_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_evens_beforezero([]) == []\nassert op_oremptyzero_evens_beforezero([-2, -1, 0, 1, 2]) == [-2]\nassert op_oremptyzero_evens_beforezero([5, 5, 5]) == []\nassert op_oremptyzero_evens_beforezero([3, 1, 2]) == [2]\nassert op_oremptyzero_evens_beforezero([10]) == [10]\nassert op_oremptyzero_evens_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_padto3_takewhilepos_sortd", "entry_point": "op_padto3_takewhilepos_sortd", "primitives": ["padto3", "takewhilepos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then sort descending.", "solution": "def op_padto3_takewhilepos_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_takewhilepos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_takewhilepos_sortd([]) == []\nassert op_padto3_takewhilepos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_padto3_takewhilepos_sortd([10]) == [10]\nassert op_padto3_takewhilepos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_takewhilepos_sortd([-7, 12, -7]) == []"}
{"id": "op_last3_neg_add10", "entry_point": "op_last3_neg_add10", "primitives": ["last3", "neg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then add ten to each.", "solution": "def op_last3_neg_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_neg_add10([1, 2, 3, 4]) == []\nassert op_last3_neg_add10([]) == []\nassert op_last3_neg_add10([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_add10([5, 5, 5]) == []\nassert op_last3_neg_add10([3, 1, 2]) == []\nassert op_last3_neg_add10([10]) == []\nassert op_last3_neg_add10([2, 4, 6]) == []\nassert op_last3_neg_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_upper_strip_sortalpha", "entry_point": "op_upper_strip_sortalpha", "primitives": ["upper", "strip", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then trim whitespace from each, then sort alphabetically.", "solution": "def op_upper_strip_sortalpha(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.strip() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_upper_strip_sortalpha(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_strip_sortalpha([]) == []\nassert op_upper_strip_sortalpha(['  a ', '', 'BC', 'bc']) == ['', 'A', 'BC', 'BC']\nassert op_upper_strip_sortalpha(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_strip_sortalpha(['x']) == ['X']\nassert op_upper_strip_sortalpha(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_pos_div3_add10", "entry_point": "op_pos_div3_add10", "primitives": ["pos", "div3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then add ten to each.", "solution": "def op_pos_div3_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_div3_add10([1, 2, 3, 4]) == [13]\nassert op_pos_div3_add10([]) == []\nassert op_pos_div3_add10([-2, -1, 0, 1, 2]) == []\nassert op_pos_div3_add10([5, 5, 5]) == []\nassert op_pos_div3_add10([3, 1, 2]) == [13]\nassert op_pos_div3_add10([10]) == []\nassert op_pos_div3_add10([2, 4, 6]) == [16]\nassert op_pos_div3_add10([-7, 12, -7]) == [22]"}
{"id": "op_dropzeros_dropwhileneg_absval", "entry_point": "op_dropzeros_dropwhileneg_absval", "primitives": ["dropzeros", "dropwhileneg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then take the absolute value of each.", "solution": "def op_dropzeros_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_dropwhileneg_absval([]) == []\nassert op_dropzeros_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_dropwhileneg_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_dropwhileneg_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_dropwhileneg_absval([10]) == [10]\nassert op_dropzeros_dropwhileneg_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_dropwhileneg_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_sortabs_add10_dropfirst", "entry_point": "op_sortabs_add10_dropfirst", "primitives": ["sortabs", "add10", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add ten to each, then drop the first element.", "solution": "def op_sortabs_add10_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_add10_dropfirst([1, 2, 3, 4]) == [12, 13, 14]\nassert op_sortabs_add10_dropfirst([]) == []\nassert op_sortabs_add10_dropfirst([-2, -1, 0, 1, 2]) == [9, 11, 8, 12]\nassert op_sortabs_add10_dropfirst([5, 5, 5]) == [15, 15]\nassert op_sortabs_add10_dropfirst([3, 1, 2]) == [12, 13]\nassert op_sortabs_add10_dropfirst([10]) == []\nassert op_sortabs_add10_dropfirst([2, 4, 6]) == [14, 16]\nassert op_sortabs_add10_dropfirst([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropfirst_trimends_beforezero", "entry_point": "op_dropfirst_trimends_beforezero", "primitives": ["dropfirst", "trimends", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_dropfirst_trimends_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_trimends_beforezero([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_beforezero([]) == []\nassert op_dropfirst_trimends_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_trimends_beforezero([5, 5, 5]) == []\nassert op_dropfirst_trimends_beforezero([3, 1, 2]) == []\nassert op_dropfirst_trimends_beforezero([10]) == []\nassert op_dropfirst_trimends_beforezero([2, 4, 6]) == []\nassert op_dropfirst_trimends_beforezero([-7, 12, -7]) == []"}
{"id": "op_div3_odds_double", "entry_point": "op_div3_odds_double", "primitives": ["div3", "odds", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then double each.", "solution": "def op_div3_odds_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_odds_double([1, 2, 3, 4]) == [6]\nassert op_div3_odds_double([]) == []\nassert op_div3_odds_double([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_double([5, 5, 5]) == []\nassert op_div3_odds_double([3, 1, 2]) == [6]\nassert op_div3_odds_double([10]) == []\nassert op_div3_odds_double([2, 4, 6]) == []\nassert op_div3_odds_double([-7, 12, -7]) == []"}
{"id": "op_nonempty_upper_counts", "entry_point": "op_nonempty_upper_counts", "primitives": ["nonempty", "upper", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then uppercase each string, then return how many strings remain.", "solution": "def op_nonempty_upper_counts(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.upper() for s in r]\n    return len(r)", "tests": "assert op_nonempty_upper_counts(['Hello', 'world']) == 2\nassert op_nonempty_upper_counts([]) == 0\nassert op_nonempty_upper_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_nonempty_upper_counts(['one', 'one', 'Two']) == 3\nassert op_nonempty_upper_counts(['x']) == 1\nassert op_nonempty_upper_counts(['abc', 'de', '']) == 2"}
{"id": "op_dropfirst_first3_prod", "entry_point": "op_dropfirst_first3_prod", "primitives": ["dropfirst", "first3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then return their product.", "solution": "def op_dropfirst_first3_prod(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_dropfirst_first3_prod([1, 2, 3, 4]) == 24\nassert op_dropfirst_first3_prod([]) == 1\nassert op_dropfirst_first3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_first3_prod([5, 5, 5]) == 25\nassert op_dropfirst_first3_prod([3, 1, 2]) == 2\nassert op_dropfirst_first3_prod([10]) == 1\nassert op_dropfirst_first3_prod([2, 4, 6]) == 24\nassert op_dropfirst_first3_prod([-7, 12, -7]) == -84"}
{"id": "op_first3_dropzeros_allpos", "entry_point": "op_first3_dropzeros_allpos", "primitives": ["first3", "dropzeros", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then return whether all values are positive.", "solution": "def op_first3_dropzeros_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_first3_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_first3_dropzeros_allpos([]) == True\nassert op_first3_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_first3_dropzeros_allpos([5, 5, 5]) == True\nassert op_first3_dropzeros_allpos([3, 1, 2]) == True\nassert op_first3_dropzeros_allpos([10]) == True\nassert op_first3_dropzeros_allpos([2, 4, 6]) == True\nassert op_first3_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_div3_padto3", "entry_point": "op_last3_div3_padto3", "primitives": ["last3", "div3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then pad with zeros to at least three elements.", "solution": "def op_last3_div3_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_div3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_last3_div3_padto3([]) == [0, 0, 0]\nassert op_last3_div3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_last3_div3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_last3_div3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_last3_div3_padto3([10]) == [0, 0, 0]\nassert op_last3_div3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_last3_div3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sorta_add10_firsteven", "entry_point": "op_sorta_add10_firsteven", "primitives": ["sorta", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then return the first even value (0 if none).", "solution": "def op_sorta_add10_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_sorta_add10_firsteven([]) == 0\nassert op_sorta_add10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_sorta_add10_firsteven([5, 5, 5]) == 0\nassert op_sorta_add10_firsteven([3, 1, 2]) == 12\nassert op_sorta_add10_firsteven([10]) == 20\nassert op_sorta_add10_firsteven([2, 4, 6]) == 12\nassert op_sorta_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_evens_sortabs_min", "entry_point": "op_evens_sortabs_min", "primitives": ["evens", "sortabs", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_evens_sortabs_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_evens_sortabs_min([1, 2, 3, 4]) == 2\nassert op_evens_sortabs_min([]) == 0\nassert op_evens_sortabs_min([-2, -1, 0, 1, 2]) == -2\nassert op_evens_sortabs_min([5, 5, 5]) == 0\nassert op_evens_sortabs_min([3, 1, 2]) == 2\nassert op_evens_sortabs_min([10]) == 10\nassert op_evens_sortabs_min([2, 4, 6]) == 2\nassert op_evens_sortabs_min([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_last3_gt5", "entry_point": "op_dropwhileneg_last3_gt5", "primitives": ["dropwhileneg", "last3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then keep values greater than five.", "solution": "def op_dropwhileneg_last3_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_last3_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_last3_gt5([]) == []\nassert op_dropwhileneg_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_last3_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_last3_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_last3_gt5([10]) == [10]\nassert op_dropwhileneg_last3_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_last3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_div3_gt5_last3", "entry_point": "op_div3_gt5_last3", "primitives": ["div3", "gt5", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then keep only the last three.", "solution": "def op_div3_gt5_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_gt5_last3([1, 2, 3, 4]) == []\nassert op_div3_gt5_last3([]) == []\nassert op_div3_gt5_last3([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_last3([5, 5, 5]) == []\nassert op_div3_gt5_last3([3, 1, 2]) == []\nassert op_div3_gt5_last3([10]) == []\nassert op_div3_gt5_last3([2, 4, 6]) == [6]\nassert op_div3_gt5_last3([-7, 12, -7]) == [12]"}
{"id": "op_odds_padto3_gt5", "entry_point": "op_odds_padto3_gt5", "primitives": ["odds", "padto3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements, then keep values greater than five.", "solution": "def op_odds_padto3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_padto3_gt5([1, 2, 3, 4]) == []\nassert op_odds_padto3_gt5([]) == []\nassert op_odds_padto3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_padto3_gt5([5, 5, 5]) == []\nassert op_odds_padto3_gt5([3, 1, 2]) == []\nassert op_odds_padto3_gt5([10]) == []\nassert op_odds_padto3_gt5([2, 4, 6]) == []\nassert op_odds_padto3_gt5([-7, 12, -7]) == []"}
{"id": "op_sortabs_sortd_prod", "entry_point": "op_sortabs_sortd_prod", "primitives": ["sortabs", "sortd", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort descending, then return their product.", "solution": "def op_sortabs_sortd_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_sortd_prod([1, 2, 3, 4]) == 24\nassert op_sortabs_sortd_prod([]) == 1\nassert op_sortabs_sortd_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_sortd_prod([5, 5, 5]) == 125\nassert op_sortabs_sortd_prod([3, 1, 2]) == 6\nassert op_sortabs_sortd_prod([10]) == 10\nassert op_sortabs_sortd_prod([2, 4, 6]) == 48\nassert op_sortabs_sortd_prod([-7, 12, -7]) == 588"}
{"id": "op_rev_double_last3", "entry_point": "op_rev_double_last3", "primitives": ["rev", "double", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then keep only the last three.", "solution": "def op_rev_double_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_rev_double_last3([1, 2, 3, 4]) == [6, 4, 2]\nassert op_rev_double_last3([]) == []\nassert op_rev_double_last3([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_rev_double_last3([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_last3([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_last3([10]) == [20]\nassert op_rev_double_last3([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_last3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_square_beforezero_sum", "entry_point": "op_square_beforezero_sum", "primitives": ["square", "beforezero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then return their sum.", "solution": "def op_square_beforezero_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(r)", "tests": "assert op_square_beforezero_sum([1, 2, 3, 4]) == 30\nassert op_square_beforezero_sum([]) == 0\nassert op_square_beforezero_sum([-2, -1, 0, 1, 2]) == 5\nassert op_square_beforezero_sum([5, 5, 5]) == 75\nassert op_square_beforezero_sum([3, 1, 2]) == 14\nassert op_square_beforezero_sum([10]) == 100\nassert op_square_beforezero_sum([2, 4, 6]) == 56\nassert op_square_beforezero_sum([-7, 12, -7]) == 242"}
{"id": "op_absval_last3_dropwhileneg", "entry_point": "op_absval_last3_dropwhileneg", "primitives": ["absval", "last3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then drop the leading negative values.", "solution": "def op_absval_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_last3_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_last3_dropwhileneg([]) == []\nassert op_absval_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_last3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_last3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_absval_last3_dropwhileneg([10]) == [10]\nassert op_absval_last3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_absval_last3_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_first3_sortabs_takewhilepos", "entry_point": "op_first3_sortabs_takewhilepos", "primitives": ["first3", "sortabs", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then take values while they are positive.", "solution": "def op_first3_sortabs_takewhilepos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_first3_sortabs_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs_takewhilepos([]) == []\nassert op_first3_sortabs_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_first3_sortabs_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs_takewhilepos([10]) == [10]\nassert op_first3_sortabs_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_padto3_odds_last3", "entry_point": "op_padto3_odds_last3", "primitives": ["padto3", "odds", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then keep only the last three.", "solution": "def op_padto3_odds_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_odds_last3([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_odds_last3([]) == []\nassert op_padto3_odds_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_padto3_odds_last3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_odds_last3([3, 1, 2]) == [3, 1]\nassert op_padto3_odds_last3([10]) == []\nassert op_padto3_odds_last3([2, 4, 6]) == []\nassert op_padto3_odds_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_rev_odds_inc", "entry_point": "op_rev_odds_inc", "primitives": ["rev", "odds", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then add one to each.", "solution": "def op_rev_odds_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_odds_inc([1, 2, 3, 4]) == [4, 2]\nassert op_rev_odds_inc([]) == []\nassert op_rev_odds_inc([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_rev_odds_inc([5, 5, 5]) == [6, 6, 6]\nassert op_rev_odds_inc([3, 1, 2]) == [2, 4]\nassert op_rev_odds_inc([10]) == []\nassert op_rev_odds_inc([2, 4, 6]) == []\nassert op_rev_odds_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_ages_clamp10_prod", "entry_point": "op_ages_clamp10_prod", "primitives": ["ages", "clamp10", "prod"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then return their product.", "solution": "def op_ages_clamp10_prod(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_ages_clamp10_prod([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 100\nassert op_ages_clamp10_prod([]) == 1\nassert op_ages_clamp10_prod([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1000\nassert op_ages_clamp10_prod([{'name': 'Fi', 'age': 41}]) == 10"}
{"id": "op_beforezero_gt5_padto3", "entry_point": "op_beforezero_gt5_padto3", "primitives": ["beforezero", "gt5", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then pad with zeros to at least three elements.", "solution": "def op_beforezero_gt5_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_gt5_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_beforezero_gt5_padto3([]) == [0, 0, 0]\nassert op_beforezero_gt5_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_beforezero_gt5_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_beforezero_gt5_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_beforezero_gt5_padto3([10]) == [10, 0, 0]\nassert op_beforezero_gt5_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_beforezero_gt5_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_add10_square_inc", "entry_point": "op_add10_square_inc", "primitives": ["add10", "square", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then add one to each.", "solution": "def op_add10_square_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_square_inc([1, 2, 3, 4]) == [122, 145, 170, 197]\nassert op_add10_square_inc([]) == []\nassert op_add10_square_inc([-2, -1, 0, 1, 2]) == [65, 82, 101, 122, 145]\nassert op_add10_square_inc([5, 5, 5]) == [226, 226, 226]\nassert op_add10_square_inc([3, 1, 2]) == [170, 122, 145]\nassert op_add10_square_inc([10]) == [401]\nassert op_add10_square_inc([2, 4, 6]) == [145, 197, 257]\nassert op_add10_square_inc([-7, 12, -7]) == [10, 485, 10]"}
{"id": "op_ages_div3_prod", "entry_point": "op_ages_div3_prod", "primitives": ["ages", "div3", "prod"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three, then return their product.", "solution": "def op_ages_div3_prod(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_ages_div3_prod([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 432\nassert op_ages_div3_prod([]) == 1\nassert op_ages_div3_prod([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 18\nassert op_ages_div3_prod([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_takewhilepos_div3_absval", "entry_point": "op_takewhilepos_div3_absval", "primitives": ["takewhilepos", "div3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three, then take the absolute value of each.", "solution": "def op_takewhilepos_div3_absval(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_takewhilepos_div3_absval([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_div3_absval([]) == []\nassert op_takewhilepos_div3_absval([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_div3_absval([5, 5, 5]) == []\nassert op_takewhilepos_div3_absval([3, 1, 2]) == [3]\nassert op_takewhilepos_div3_absval([10]) == []\nassert op_takewhilepos_div3_absval([2, 4, 6]) == [6]\nassert op_takewhilepos_div3_absval([-7, 12, -7]) == []"}
{"id": "op_padto3_inc_odds", "entry_point": "op_padto3_inc_odds", "primitives": ["padto3", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then keep the odd numbers.", "solution": "def op_padto3_inc_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_inc_odds([1, 2, 3, 4]) == [3, 5]\nassert op_padto3_inc_odds([]) == [1, 1, 1]\nassert op_padto3_inc_odds([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_padto3_inc_odds([5, 5, 5]) == []\nassert op_padto3_inc_odds([3, 1, 2]) == [3]\nassert op_padto3_inc_odds([10]) == [11, 1, 1]\nassert op_padto3_inc_odds([2, 4, 6]) == [3, 5, 7]\nassert op_padto3_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_sortabs_padto3_pos", "entry_point": "op_sortabs_padto3_pos", "primitives": ["sortabs", "padto3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then keep the positive numbers.", "solution": "def op_sortabs_padto3_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_padto3_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_padto3_pos([]) == []\nassert op_sortabs_padto3_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_padto3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_padto3_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_padto3_pos([10]) == [10]\nassert op_sortabs_padto3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_padto3_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_pos_absval", "entry_point": "op_dropfirst_pos_absval", "primitives": ["dropfirst", "pos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_dropfirst_pos_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_pos_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_pos_absval([]) == []\nassert op_dropfirst_pos_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropfirst_pos_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_pos_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_pos_absval([10]) == []\nassert op_dropfirst_pos_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_pos_absval([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortabs_add10", "entry_point": "op_rev_sortabs_add10", "primitives": ["rev", "sortabs", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then add ten to each.", "solution": "def op_rev_sortabs_add10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_rev_sortabs_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_rev_sortabs_add10([]) == []\nassert op_rev_sortabs_add10([-2, -1, 0, 1, 2]) == [10, 11, 9, 12, 8]\nassert op_rev_sortabs_add10([5, 5, 5]) == [15, 15, 15]\nassert op_rev_sortabs_add10([3, 1, 2]) == [11, 12, 13]\nassert op_rev_sortabs_add10([10]) == [20]\nassert op_rev_sortabs_add10([2, 4, 6]) == [12, 14, 16]\nassert op_rev_sortabs_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_pos_clamp10_negate", "entry_point": "op_pos_clamp10_negate", "primitives": ["pos", "clamp10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then negate each.", "solution": "def op_pos_clamp10_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_clamp10_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_clamp10_negate([]) == []\nassert op_pos_clamp10_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_clamp10_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_clamp10_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_pos_clamp10_negate([10]) == [-10]\nassert op_pos_clamp10_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_clamp10_negate([-7, 12, -7]) == [-10]"}
{"id": "op_div3_square_dec", "entry_point": "op_div3_square_dec", "primitives": ["div3", "square", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then subtract one from each.", "solution": "def op_div3_square_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_square_dec([1, 2, 3, 4]) == [8]\nassert op_div3_square_dec([]) == []\nassert op_div3_square_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_square_dec([5, 5, 5]) == []\nassert op_div3_square_dec([3, 1, 2]) == [8]\nassert op_div3_square_dec([10]) == []\nassert op_div3_square_dec([2, 4, 6]) == [35]\nassert op_div3_square_dec([-7, 12, -7]) == [143]"}
{"id": "op_evens_rev_anyeven", "entry_point": "op_evens_rev_anyeven", "primitives": ["evens", "rev", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then return whether any value is even.", "solution": "def op_evens_rev_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_rev_anyeven([1, 2, 3, 4]) == True\nassert op_evens_rev_anyeven([]) == False\nassert op_evens_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_evens_rev_anyeven([5, 5, 5]) == False\nassert op_evens_rev_anyeven([3, 1, 2]) == True\nassert op_evens_rev_anyeven([10]) == True\nassert op_evens_rev_anyeven([2, 4, 6]) == True\nassert op_evens_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortabs_dropzeros_padto3", "entry_point": "op_sortabs_dropzeros_padto3", "primitives": ["sortabs", "dropzeros", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then pad with zeros to at least three elements.", "solution": "def op_sortabs_dropzeros_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_dropzeros_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_dropzeros_padto3([]) == [0, 0, 0]\nassert op_sortabs_dropzeros_padto3([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_dropzeros_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_dropzeros_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_dropzeros_padto3([10]) == [10, 0, 0]\nassert op_sortabs_dropzeros_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropzeros_padto3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropzeros_beforezero_clamp10", "entry_point": "op_dropzeros_beforezero_clamp10", "primitives": ["dropzeros", "beforezero", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_dropzeros_beforezero_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_beforezero_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_beforezero_clamp10([]) == []\nassert op_dropzeros_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_beforezero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_beforezero_clamp10([10]) == [10]\nassert op_dropzeros_beforezero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_beforezero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_trimends_inc_oremptyzero", "entry_point": "op_trimends_inc_oremptyzero", "primitives": ["trimends", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then if empty, use a single zero.", "solution": "def op_trimends_inc_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_inc_oremptyzero([1, 2, 3, 4]) == [3, 4]\nassert op_trimends_inc_oremptyzero([]) == [0]\nassert op_trimends_inc_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_trimends_inc_oremptyzero([5, 5, 5]) == [6]\nassert op_trimends_inc_oremptyzero([3, 1, 2]) == [2]\nassert op_trimends_inc_oremptyzero([10]) == [0]\nassert op_trimends_inc_oremptyzero([2, 4, 6]) == [5]\nassert op_trimends_inc_oremptyzero([-7, 12, -7]) == [13]"}
{"id": "op_neg_uniq_evens", "entry_point": "op_neg_uniq_evens", "primitives": ["neg", "uniq", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_neg_uniq_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_uniq_evens([1, 2, 3, 4]) == []\nassert op_neg_uniq_evens([]) == []\nassert op_neg_uniq_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_uniq_evens([5, 5, 5]) == []\nassert op_neg_uniq_evens([3, 1, 2]) == []\nassert op_neg_uniq_evens([10]) == []\nassert op_neg_uniq_evens([2, 4, 6]) == []\nassert op_neg_uniq_evens([-7, 12, -7]) == []"}
{"id": "op_beforezero_evens_sorta", "entry_point": "op_beforezero_evens_sorta", "primitives": ["beforezero", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then sort ascending.", "solution": "def op_beforezero_evens_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_evens_sorta([1, 2, 3, 4]) == [2, 4]\nassert op_beforezero_evens_sorta([]) == []\nassert op_beforezero_evens_sorta([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_evens_sorta([5, 5, 5]) == []\nassert op_beforezero_evens_sorta([3, 1, 2]) == [2]\nassert op_beforezero_evens_sorta([10]) == [10]\nassert op_beforezero_evens_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_evens_sorta([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_negate_takewhilepos", "entry_point": "op_sortabs_negate_takewhilepos", "primitives": ["sortabs", "negate", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then negate each, then take values while they are positive.", "solution": "def op_sortabs_negate_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortabs_negate_takewhilepos([1, 2, 3, 4]) == []\nassert op_sortabs_negate_takewhilepos([]) == []\nassert op_sortabs_negate_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_negate_takewhilepos([5, 5, 5]) == []\nassert op_sortabs_negate_takewhilepos([3, 1, 2]) == []\nassert op_sortabs_negate_takewhilepos([10]) == []\nassert op_sortabs_negate_takewhilepos([2, 4, 6]) == []\nassert op_sortabs_negate_takewhilepos([-7, 12, -7]) == [7, 7]"}
{"id": "op_sortd_rev_neg", "entry_point": "op_sortd_rev_neg", "primitives": ["sortd", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then reverse the order, then keep the negative numbers.", "solution": "def op_sortd_rev_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_rev_neg([1, 2, 3, 4]) == []\nassert op_sortd_rev_neg([]) == []\nassert op_sortd_rev_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sortd_rev_neg([5, 5, 5]) == []\nassert op_sortd_rev_neg([3, 1, 2]) == []\nassert op_sortd_rev_neg([10]) == []\nassert op_sortd_rev_neg([2, 4, 6]) == []\nassert op_sortd_rev_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_dec_firsteven", "entry_point": "op_clamp10_dec_firsteven", "primitives": ["clamp10", "dec", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then return the first even value (0 if none).", "solution": "def op_clamp10_dec_firsteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_clamp10_dec_firsteven([1, 2, 3, 4]) == 0\nassert op_clamp10_dec_firsteven([]) == 0\nassert op_clamp10_dec_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_clamp10_dec_firsteven([5, 5, 5]) == 4\nassert op_clamp10_dec_firsteven([3, 1, 2]) == 2\nassert op_clamp10_dec_firsteven([10]) == 0\nassert op_clamp10_dec_firsteven([2, 4, 6]) == 0\nassert op_clamp10_dec_firsteven([-7, 12, -7]) == -8"}
{"id": "op_inc_sorta_odds", "entry_point": "op_inc_sorta_odds", "primitives": ["inc", "sorta", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then keep the odd numbers.", "solution": "def op_inc_sorta_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_sorta_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_sorta_odds([]) == []\nassert op_inc_sorta_odds([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_inc_sorta_odds([5, 5, 5]) == []\nassert op_inc_sorta_odds([3, 1, 2]) == [3]\nassert op_inc_sorta_odds([10]) == [11]\nassert op_inc_sorta_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta_odds([-7, 12, -7]) == [13]"}
{"id": "op_dec_add10_double", "entry_point": "op_dec_add10_double", "primitives": ["dec", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then double each.", "solution": "def op_dec_add10_double(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dec_add10_double([1, 2, 3, 4]) == [20, 22, 24, 26]\nassert op_dec_add10_double([]) == []\nassert op_dec_add10_double([-2, -1, 0, 1, 2]) == [14, 16, 18, 20, 22]\nassert op_dec_add10_double([5, 5, 5]) == [28, 28, 28]\nassert op_dec_add10_double([3, 1, 2]) == [24, 20, 22]\nassert op_dec_add10_double([10]) == [38]\nassert op_dec_add10_double([2, 4, 6]) == [22, 26, 30]\nassert op_dec_add10_double([-7, 12, -7]) == [4, 42, 4]"}
{"id": "op_pos_last3_dropfirst", "entry_point": "op_pos_last3_dropfirst", "primitives": ["pos", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then drop the first element.", "solution": "def op_pos_last3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_pos_last3_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_pos_last3_dropfirst([]) == []\nassert op_pos_last3_dropfirst([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_last3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_pos_last3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_pos_last3_dropfirst([10]) == []\nassert op_pos_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_pos_last3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dropwhileneg_add10", "entry_point": "op_takewhilepos_dropwhileneg_add10", "primitives": ["takewhilepos", "dropwhileneg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then add ten to each.", "solution": "def op_takewhilepos_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_takewhilepos_dropwhileneg_add10([]) == []\nassert op_takewhilepos_dropwhileneg_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_add10([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_dropwhileneg_add10([3, 1, 2]) == [13, 11, 12]\nassert op_takewhilepos_dropwhileneg_add10([10]) == [20]\nassert op_takewhilepos_dropwhileneg_add10([2, 4, 6]) == [12, 14, 16]\nassert op_takewhilepos_dropwhileneg_add10([-7, 12, -7]) == []"}
{"id": "op_sortd_beforezero_inc", "entry_point": "op_sortd_beforezero_inc", "primitives": ["sortd", "beforezero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then add one to each.", "solution": "def op_sortd_beforezero_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_beforezero_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_beforezero_inc([]) == []\nassert op_sortd_beforezero_inc([-2, -1, 0, 1, 2]) == [3, 2]\nassert op_sortd_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_beforezero_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_beforezero_inc([10]) == [11]\nassert op_sortd_beforezero_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_beforezero_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_gt5_double_rev", "entry_point": "op_gt5_double_rev", "primitives": ["gt5", "double", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then reverse the order.", "solution": "def op_gt5_double_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_gt5_double_rev([1, 2, 3, 4]) == []\nassert op_gt5_double_rev([]) == []\nassert op_gt5_double_rev([-2, -1, 0, 1, 2]) == []\nassert op_gt5_double_rev([5, 5, 5]) == []\nassert op_gt5_double_rev([3, 1, 2]) == []\nassert op_gt5_double_rev([10]) == [20]\nassert op_gt5_double_rev([2, 4, 6]) == [12]\nassert op_gt5_double_rev([-7, 12, -7]) == [24]"}
{"id": "op_add10_clamp10_allpos", "entry_point": "op_add10_clamp10_allpos", "primitives": ["add10", "clamp10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then return whether all values are positive.", "solution": "def op_add10_clamp10_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_clamp10_allpos([1, 2, 3, 4]) == True\nassert op_add10_clamp10_allpos([]) == True\nassert op_add10_clamp10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_clamp10_allpos([5, 5, 5]) == True\nassert op_add10_clamp10_allpos([3, 1, 2]) == True\nassert op_add10_clamp10_allpos([10]) == True\nassert op_add10_clamp10_allpos([2, 4, 6]) == True\nassert op_add10_clamp10_allpos([-7, 12, -7]) == True"}
{"id": "op_lower_firstchar_uniqs", "entry_point": "op_lower_firstchar_uniqs", "primitives": ["lower", "firstchar", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then keep the first character of each (dropping empties), then drop duplicate strings keeping the first.", "solution": "def op_lower_firstchar_uniqs(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[0] for s in r if s]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_lower_firstchar_uniqs(['Hello', 'world']) == ['h', 'w']\nassert op_lower_firstchar_uniqs([]) == []\nassert op_lower_firstchar_uniqs(['  a ', '', 'BC', 'bc']) == [' ', 'b']\nassert op_lower_firstchar_uniqs(['one', 'one', 'Two']) == ['o', 't']\nassert op_lower_firstchar_uniqs(['x']) == ['x']\nassert op_lower_firstchar_uniqs(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_trimends_sortabs_add10", "entry_point": "op_trimends_sortabs_add10", "primitives": ["trimends", "sortabs", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then add ten to each.", "solution": "def op_trimends_sortabs_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_sortabs_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_sortabs_add10([]) == []\nassert op_trimends_sortabs_add10([-2, -1, 0, 1, 2]) == [10, 9, 11]\nassert op_trimends_sortabs_add10([5, 5, 5]) == [15]\nassert op_trimends_sortabs_add10([3, 1, 2]) == [11]\nassert op_trimends_sortabs_add10([10]) == []\nassert op_trimends_sortabs_add10([2, 4, 6]) == [14]\nassert op_trimends_sortabs_add10([-7, 12, -7]) == [22]"}
{"id": "op_gt5_evens_sortabs", "entry_point": "op_gt5_evens_sortabs", "primitives": ["gt5", "evens", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then sort by absolute value.", "solution": "def op_gt5_evens_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_evens_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_evens_sortabs([]) == []\nassert op_gt5_evens_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens_sortabs([5, 5, 5]) == []\nassert op_gt5_evens_sortabs([3, 1, 2]) == []\nassert op_gt5_evens_sortabs([10]) == [10]\nassert op_gt5_evens_sortabs([2, 4, 6]) == [6]\nassert op_gt5_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_div3_uniq", "entry_point": "op_sortabs_div3_uniq", "primitives": ["sortabs", "div3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_div3_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_div3_uniq([1, 2, 3, 4]) == [3]\nassert op_sortabs_div3_uniq([]) == []\nassert op_sortabs_div3_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_sortabs_div3_uniq([5, 5, 5]) == []\nassert op_sortabs_div3_uniq([3, 1, 2]) == [3]\nassert op_sortabs_div3_uniq([10]) == []\nassert op_sortabs_div3_uniq([2, 4, 6]) == [6]\nassert op_sortabs_div3_uniq([-7, 12, -7]) == [12]"}
{"id": "op_add10_dropwhileneg_firsteven", "entry_point": "op_add10_dropwhileneg_firsteven", "primitives": ["add10", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_add10_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_dropwhileneg_firsteven([1, 2, 3, 4]) == 12\nassert op_add10_dropwhileneg_firsteven([]) == 0\nassert op_add10_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_add10_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_add10_dropwhileneg_firsteven([3, 1, 2]) == 12\nassert op_add10_dropwhileneg_firsteven([10]) == 20\nassert op_add10_dropwhileneg_firsteven([2, 4, 6]) == 12\nassert op_add10_dropwhileneg_firsteven([-7, 12, -7]) == 22"}
{"id": "op_dec_negate_square", "entry_point": "op_dec_negate_square", "primitives": ["dec", "negate", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then square each.", "solution": "def op_dec_negate_square(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dec_negate_square([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_dec_negate_square([]) == []\nassert op_dec_negate_square([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_dec_negate_square([5, 5, 5]) == [16, 16, 16]\nassert op_dec_negate_square([3, 1, 2]) == [4, 0, 1]\nassert op_dec_negate_square([10]) == [81]\nassert op_dec_negate_square([2, 4, 6]) == [1, 9, 25]\nassert op_dec_negate_square([-7, 12, -7]) == [64, 121, 64]"}
{"id": "op_negate_div3_sortabs", "entry_point": "op_negate_div3_sortabs", "primitives": ["negate", "div3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then sort by absolute value.", "solution": "def op_negate_div3_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_div3_sortabs([1, 2, 3, 4]) == [-3]\nassert op_negate_div3_sortabs([]) == []\nassert op_negate_div3_sortabs([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_div3_sortabs([5, 5, 5]) == []\nassert op_negate_div3_sortabs([3, 1, 2]) == [-3]\nassert op_negate_div3_sortabs([10]) == []\nassert op_negate_div3_sortabs([2, 4, 6]) == [-6]\nassert op_negate_div3_sortabs([-7, 12, -7]) == [-12]"}
{"id": "op_trimends_add10_dropwhileneg", "entry_point": "op_trimends_add10_dropwhileneg", "primitives": ["trimends", "add10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then drop the leading negative values.", "solution": "def op_trimends_add10_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_add10_dropwhileneg([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_add10_dropwhileneg([]) == []\nassert op_trimends_add10_dropwhileneg([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10_dropwhileneg([5, 5, 5]) == [15]\nassert op_trimends_add10_dropwhileneg([3, 1, 2]) == [11]\nassert op_trimends_add10_dropwhileneg([10]) == []\nassert op_trimends_add10_dropwhileneg([2, 4, 6]) == [14]\nassert op_trimends_add10_dropwhileneg([-7, 12, -7]) == [22]"}
{"id": "op_odds_double_add10", "entry_point": "op_odds_double_add10", "primitives": ["odds", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each, then add ten to each.", "solution": "def op_odds_double_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_odds_double_add10([1, 2, 3, 4]) == [12, 16]\nassert op_odds_double_add10([]) == []\nassert op_odds_double_add10([-2, -1, 0, 1, 2]) == [8, 12]\nassert op_odds_double_add10([5, 5, 5]) == [20, 20, 20]\nassert op_odds_double_add10([3, 1, 2]) == [16, 12]\nassert op_odds_double_add10([10]) == []\nassert op_odds_double_add10([2, 4, 6]) == []\nassert op_odds_double_add10([-7, 12, -7]) == [-4, -4]"}
{"id": "op_neg_beforezero_odds", "entry_point": "op_neg_beforezero_odds", "primitives": ["neg", "beforezero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_neg_beforezero_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_neg_beforezero_odds([1, 2, 3, 4]) == []\nassert op_neg_beforezero_odds([]) == []\nassert op_neg_beforezero_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_beforezero_odds([5, 5, 5]) == []\nassert op_neg_beforezero_odds([3, 1, 2]) == []\nassert op_neg_beforezero_odds([10]) == []\nassert op_neg_beforezero_odds([2, 4, 6]) == []\nassert op_neg_beforezero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_clamp10_rev", "entry_point": "op_dropwhileneg_clamp10_rev", "primitives": ["dropwhileneg", "clamp10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then reverse the order.", "solution": "def op_dropwhileneg_clamp10_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_clamp10_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_clamp10_rev([]) == []\nassert op_dropwhileneg_clamp10_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_clamp10_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_clamp10_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropwhileneg_clamp10_rev([10]) == [10]\nassert op_dropwhileneg_clamp10_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_clamp10_rev([-7, 12, -7]) == [-7, 10]"}
{"id": "op_dropzeros_gt5_max", "entry_point": "op_dropzeros_gt5_max", "primitives": ["dropzeros", "gt5", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five, then return the maximum (0 if empty).", "solution": "def op_dropzeros_gt5_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_gt5_max([1, 2, 3, 4]) == 0\nassert op_dropzeros_gt5_max([]) == 0\nassert op_dropzeros_gt5_max([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_gt5_max([5, 5, 5]) == 0\nassert op_dropzeros_gt5_max([3, 1, 2]) == 0\nassert op_dropzeros_gt5_max([10]) == 10\nassert op_dropzeros_gt5_max([2, 4, 6]) == 6\nassert op_dropzeros_gt5_max([-7, 12, -7]) == 12"}
{"id": "op_last3_odds_clamp10", "entry_point": "op_last3_odds_clamp10", "primitives": ["last3", "odds", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then cap each value at 10.", "solution": "def op_last3_odds_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_odds_clamp10([1, 2, 3, 4]) == [3]\nassert op_last3_odds_clamp10([]) == []\nassert op_last3_odds_clamp10([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_odds_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_odds_clamp10([3, 1, 2]) == [3, 1]\nassert op_last3_odds_clamp10([10]) == []\nassert op_last3_odds_clamp10([2, 4, 6]) == []\nassert op_last3_odds_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniqs_sortalpha_prefixup", "entry_point": "op_uniqs_sortalpha_prefixup", "primitives": ["uniqs", "sortalpha", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically, then prefix each with a hash.", "solution": "def op_uniqs_sortalpha_prefixup(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_uniqs_sortalpha_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_uniqs_sortalpha_prefixup([]) == []\nassert op_uniqs_sortalpha_prefixup(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_uniqs_sortalpha_prefixup(['one', 'one', 'Two']) == ['#Two', '#one']\nassert op_uniqs_sortalpha_prefixup(['x']) == ['#x']\nassert op_uniqs_sortalpha_prefixup(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_uniqs_strip_longest", "entry_point": "op_uniqs_strip_longest", "primitives": ["uniqs", "strip", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then trim whitespace from each, then return the longest string (empty if none).", "solution": "def op_uniqs_strip_longest(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.strip() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_uniqs_strip_longest(['Hello', 'world']) == 'Hello'\nassert op_uniqs_strip_longest([]) == ''\nassert op_uniqs_strip_longest(['  a ', '', 'BC', 'bc']) == 'BC'\nassert op_uniqs_strip_longest(['one', 'one', 'Two']) == 'one'\nassert op_uniqs_strip_longest(['x']) == 'x'\nassert op_uniqs_strip_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_sortabs_dec_firsteven", "entry_point": "op_sortabs_dec_firsteven", "primitives": ["sortabs", "dec", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then return the first even value (0 if none).", "solution": "def op_sortabs_dec_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_dec_firsteven([1, 2, 3, 4]) == 0\nassert op_sortabs_dec_firsteven([]) == 0\nassert op_sortabs_dec_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sortabs_dec_firsteven([5, 5, 5]) == 4\nassert op_sortabs_dec_firsteven([3, 1, 2]) == 0\nassert op_sortabs_dec_firsteven([10]) == 0\nassert op_sortabs_dec_firsteven([2, 4, 6]) == 0\nassert op_sortabs_dec_firsteven([-7, 12, -7]) == -8"}
{"id": "op_sorta_takewhilepos_div3", "entry_point": "op_sorta_takewhilepos_div3", "primitives": ["sorta", "takewhilepos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then keep multiples of three.", "solution": "def op_sorta_takewhilepos_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_takewhilepos_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_takewhilepos_div3([]) == []\nassert op_sorta_takewhilepos_div3([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos_div3([5, 5, 5]) == []\nassert op_sorta_takewhilepos_div3([3, 1, 2]) == [3]\nassert op_sorta_takewhilepos_div3([10]) == []\nassert op_sorta_takewhilepos_div3([2, 4, 6]) == [6]\nassert op_sorta_takewhilepos_div3([-7, 12, -7]) == []"}
{"id": "op_neg_gt5_dropfirst", "entry_point": "op_neg_gt5_dropfirst", "primitives": ["neg", "gt5", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep values greater than five, then drop the first element.", "solution": "def op_neg_gt5_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_neg_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_gt5_dropfirst([]) == []\nassert op_neg_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_neg_gt5_dropfirst([5, 5, 5]) == []\nassert op_neg_gt5_dropfirst([3, 1, 2]) == []\nassert op_neg_gt5_dropfirst([10]) == []\nassert op_neg_gt5_dropfirst([2, 4, 6]) == []\nassert op_neg_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_sortabs_dec", "entry_point": "op_add10_sortabs_dec", "primitives": ["add10", "sortabs", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then subtract one from each.", "solution": "def op_add10_sortabs_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_sortabs_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_sortabs_dec([]) == []\nassert op_add10_sortabs_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_sortabs_dec([5, 5, 5]) == [14, 14, 14]\nassert op_add10_sortabs_dec([3, 1, 2]) == [10, 11, 12]\nassert op_add10_sortabs_dec([10]) == [19]\nassert op_add10_sortabs_dec([2, 4, 6]) == [11, 13, 15]\nassert op_add10_sortabs_dec([-7, 12, -7]) == [2, 2, 21]"}
{"id": "op_sortd_takewhilepos_clamp10", "entry_point": "op_sortd_takewhilepos_clamp10", "primitives": ["sortd", "takewhilepos", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then cap each value at 10.", "solution": "def op_sortd_takewhilepos_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortd_takewhilepos_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_takewhilepos_clamp10([]) == []\nassert op_sortd_takewhilepos_clamp10([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_takewhilepos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_takewhilepos_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_takewhilepos_clamp10([10]) == [10]\nassert op_sortd_takewhilepos_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_takewhilepos_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_sortd_dropzeros_trimends", "entry_point": "op_sortd_dropzeros_trimends", "primitives": ["sortd", "dropzeros", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then drop the first and last elements.", "solution": "def op_sortd_dropzeros_trimends(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortd_dropzeros_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_sortd_dropzeros_trimends([]) == []\nassert op_sortd_dropzeros_trimends([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_dropzeros_trimends([5, 5, 5]) == [5]\nassert op_sortd_dropzeros_trimends([3, 1, 2]) == [2]\nassert op_sortd_dropzeros_trimends([10]) == []\nassert op_sortd_dropzeros_trimends([2, 4, 6]) == [4]\nassert op_sortd_dropzeros_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_inc_gt5_issorted", "entry_point": "op_inc_gt5_issorted", "primitives": ["inc", "gt5", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_inc_gt5_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_inc_gt5_issorted([1, 2, 3, 4]) == True\nassert op_inc_gt5_issorted([]) == True\nassert op_inc_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_gt5_issorted([5, 5, 5]) == True\nassert op_inc_gt5_issorted([3, 1, 2]) == True\nassert op_inc_gt5_issorted([10]) == True\nassert op_inc_gt5_issorted([2, 4, 6]) == True\nassert op_inc_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_evens_odds_neg", "entry_point": "op_evens_odds_neg", "primitives": ["evens", "odds", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then keep the negative numbers.", "solution": "def op_evens_odds_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_odds_neg([1, 2, 3, 4]) == []\nassert op_evens_odds_neg([]) == []\nassert op_evens_odds_neg([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_neg([5, 5, 5]) == []\nassert op_evens_odds_neg([3, 1, 2]) == []\nassert op_evens_odds_neg([10]) == []\nassert op_evens_odds_neg([2, 4, 6]) == []\nassert op_evens_odds_neg([-7, 12, -7]) == []"}
{"id": "op_odds_double_absval", "entry_point": "op_odds_double_absval", "primitives": ["odds", "double", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each, then take the absolute value of each.", "solution": "def op_odds_double_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_double_absval([1, 2, 3, 4]) == [2, 6]\nassert op_odds_double_absval([]) == []\nassert op_odds_double_absval([-2, -1, 0, 1, 2]) == [2, 2]\nassert op_odds_double_absval([5, 5, 5]) == [10, 10, 10]\nassert op_odds_double_absval([3, 1, 2]) == [6, 2]\nassert op_odds_double_absval([10]) == []\nassert op_odds_double_absval([2, 4, 6]) == []\nassert op_odds_double_absval([-7, 12, -7]) == [14, 14]"}
{"id": "op_sorta_dec_double", "entry_point": "op_sorta_dec_double", "primitives": ["sorta", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then double each.", "solution": "def op_sorta_dec_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_dec_double([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_sorta_dec_double([]) == []\nassert op_sorta_dec_double([-2, -1, 0, 1, 2]) == [-6, -4, -2, 0, 2]\nassert op_sorta_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_sorta_dec_double([3, 1, 2]) == [0, 2, 4]\nassert op_sorta_dec_double([10]) == [18]\nassert op_sorta_dec_double([2, 4, 6]) == [2, 6, 10]\nassert op_sorta_dec_double([-7, 12, -7]) == [-16, -16, 22]"}
{"id": "op_takewhilepos_sortabs_sortd", "entry_point": "op_takewhilepos_sortabs_sortd", "primitives": ["takewhilepos", "sortabs", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then sort descending.", "solution": "def op_takewhilepos_sortabs_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_sortabs_sortd([]) == []\nassert op_takewhilepos_sortabs_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortabs_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_sortabs_sortd([10]) == [10]\nassert op_takewhilepos_sortabs_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_sortabs_sortd([-7, 12, -7]) == []"}
{"id": "op_dropzeros_absval_evens", "entry_point": "op_dropzeros_absval_evens", "primitives": ["dropzeros", "absval", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then keep the even numbers.", "solution": "def op_dropzeros_absval_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropzeros_absval_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropzeros_absval_evens([]) == []\nassert op_dropzeros_absval_evens([-2, -1, 0, 1, 2]) == [2, 2]\nassert op_dropzeros_absval_evens([5, 5, 5]) == []\nassert op_dropzeros_absval_evens([3, 1, 2]) == [2]\nassert op_dropzeros_absval_evens([10]) == [10]\nassert op_dropzeros_absval_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval_evens([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_inc_firsteven", "entry_point": "op_dropzeros_inc_firsteven", "primitives": ["dropzeros", "inc", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then return the first even value (0 if none).", "solution": "def op_dropzeros_inc_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_inc_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_inc_firsteven([]) == 0\nassert op_dropzeros_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_inc_firsteven([5, 5, 5]) == 6\nassert op_dropzeros_inc_firsteven([3, 1, 2]) == 4\nassert op_dropzeros_inc_firsteven([10]) == 0\nassert op_dropzeros_inc_firsteven([2, 4, 6]) == 0\nassert op_dropzeros_inc_firsteven([-7, 12, -7]) == -6"}
{"id": "op_add10_square_len", "entry_point": "op_add10_square_len", "primitives": ["add10", "square", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then return how many remain.", "solution": "def op_add10_square_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_add10_square_len([1, 2, 3, 4]) == 4\nassert op_add10_square_len([]) == 0\nassert op_add10_square_len([-2, -1, 0, 1, 2]) == 5\nassert op_add10_square_len([5, 5, 5]) == 3\nassert op_add10_square_len([3, 1, 2]) == 3\nassert op_add10_square_len([10]) == 1\nassert op_add10_square_len([2, 4, 6]) == 3\nassert op_add10_square_len([-7, 12, -7]) == 3"}
{"id": "op_negate_sorta_rev", "entry_point": "op_negate_sorta_rev", "primitives": ["negate", "sorta", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then reverse the order.", "solution": "def op_negate_sorta_rev(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_negate_sorta_rev([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_sorta_rev([]) == []\nassert op_negate_sorta_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_sorta_rev([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sorta_rev([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sorta_rev([10]) == [-10]\nassert op_negate_sorta_rev([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sorta_rev([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_sortalpha_firstchar_strip", "entry_point": "op_sortalpha_firstchar_strip", "primitives": ["sortalpha", "firstchar", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then keep the first character of each (dropping empties), then trim whitespace from each.", "solution": "def op_sortalpha_firstchar_strip(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_sortalpha_firstchar_strip(['Hello', 'world']) == ['H', 'w']\nassert op_sortalpha_firstchar_strip([]) == []\nassert op_sortalpha_firstchar_strip(['  a ', '', 'BC', 'bc']) == ['', 'B', 'b']\nassert op_sortalpha_firstchar_strip(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_sortalpha_firstchar_strip(['x']) == ['x']\nassert op_sortalpha_firstchar_strip(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_dropwhileneg_square_dropfirst", "entry_point": "op_dropwhileneg_square_dropfirst", "primitives": ["dropwhileneg", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then drop the first element.", "solution": "def op_dropwhileneg_square_dropfirst(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_dropwhileneg_square_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropwhileneg_square_dropfirst([]) == []\nassert op_dropwhileneg_square_dropfirst([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_dropwhileneg_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_dropwhileneg_square_dropfirst([3, 1, 2]) == [1, 4]\nassert op_dropwhileneg_square_dropfirst([10]) == []\nassert op_dropwhileneg_square_dropfirst([2, 4, 6]) == [16, 36]\nassert op_dropwhileneg_square_dropfirst([-7, 12, -7]) == [49]"}
{"id": "op_takewhilepos_gt5_dropwhileneg", "entry_point": "op_takewhilepos_gt5_dropwhileneg", "primitives": ["takewhilepos", "gt5", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then drop the leading negative values.", "solution": "def op_takewhilepos_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_dropwhileneg([]) == []\nassert op_takewhilepos_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_takewhilepos_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_takewhilepos_gt5_dropwhileneg([10]) == [10]\nassert op_takewhilepos_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_takewhilepos_gt5_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dec_sorta_sum", "entry_point": "op_dec_sorta_sum", "primitives": ["dec", "sorta", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then return their sum.", "solution": "def op_dec_sorta_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_dec_sorta_sum([1, 2, 3, 4]) == 6\nassert op_dec_sorta_sum([]) == 0\nassert op_dec_sorta_sum([-2, -1, 0, 1, 2]) == -5\nassert op_dec_sorta_sum([5, 5, 5]) == 12\nassert op_dec_sorta_sum([3, 1, 2]) == 3\nassert op_dec_sorta_sum([10]) == 9\nassert op_dec_sorta_sum([2, 4, 6]) == 9\nassert op_dec_sorta_sum([-7, 12, -7]) == -5"}
{"id": "op_rev_oremptyzero_sum", "entry_point": "op_rev_oremptyzero_sum", "primitives": ["rev", "oremptyzero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then return their sum.", "solution": "def op_rev_oremptyzero_sum(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_rev_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_rev_oremptyzero_sum([]) == 0\nassert op_rev_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_rev_oremptyzero_sum([5, 5, 5]) == 15\nassert op_rev_oremptyzero_sum([3, 1, 2]) == 6\nassert op_rev_oremptyzero_sum([10]) == 10\nassert op_rev_oremptyzero_sum([2, 4, 6]) == 12\nassert op_rev_oremptyzero_sum([-7, 12, -7]) == -2"}
{"id": "op_negate_pos_evens", "entry_point": "op_negate_pos_evens", "primitives": ["negate", "pos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then keep the even numbers.", "solution": "def op_negate_pos_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_pos_evens([1, 2, 3, 4]) == []\nassert op_negate_pos_evens([]) == []\nassert op_negate_pos_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_negate_pos_evens([5, 5, 5]) == []\nassert op_negate_pos_evens([3, 1, 2]) == []\nassert op_negate_pos_evens([10]) == []\nassert op_negate_pos_evens([2, 4, 6]) == []\nassert op_negate_pos_evens([-7, 12, -7]) == []"}
{"id": "op_sortd_square_evens", "entry_point": "op_sortd_square_evens", "primitives": ["sortd", "square", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then keep the even numbers.", "solution": "def op_sortd_square_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_square_evens([1, 2, 3, 4]) == [16, 4]\nassert op_sortd_square_evens([]) == []\nassert op_sortd_square_evens([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_sortd_square_evens([5, 5, 5]) == []\nassert op_sortd_square_evens([3, 1, 2]) == [4]\nassert op_sortd_square_evens([10]) == [100]\nassert op_sortd_square_evens([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_trimends_pos_square", "entry_point": "op_trimends_pos_square", "primitives": ["trimends", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then square each.", "solution": "def op_trimends_pos_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_pos_square([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_pos_square([]) == []\nassert op_trimends_pos_square([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_pos_square([5, 5, 5]) == [25]\nassert op_trimends_pos_square([3, 1, 2]) == [1]\nassert op_trimends_pos_square([10]) == []\nassert op_trimends_pos_square([2, 4, 6]) == [16]\nassert op_trimends_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_uniq_add10_odds", "entry_point": "op_uniq_add10_odds", "primitives": ["uniq", "add10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then keep the odd numbers.", "solution": "def op_uniq_add10_odds(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_uniq_add10_odds([1, 2, 3, 4]) == [11, 13]\nassert op_uniq_add10_odds([]) == []\nassert op_uniq_add10_odds([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_uniq_add10_odds([5, 5, 5]) == [15]\nassert op_uniq_add10_odds([3, 1, 2]) == [13, 11]\nassert op_uniq_add10_odds([10]) == []\nassert op_uniq_add10_odds([2, 4, 6]) == []\nassert op_uniq_add10_odds([-7, 12, -7]) == [3]"}
{"id": "op_evens_last3_sorta", "entry_point": "op_evens_last3_sorta", "primitives": ["evens", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then sort ascending.", "solution": "def op_evens_last3_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_evens_last3_sorta([1, 2, 3, 4]) == [2, 4]\nassert op_evens_last3_sorta([]) == []\nassert op_evens_last3_sorta([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_last3_sorta([5, 5, 5]) == []\nassert op_evens_last3_sorta([3, 1, 2]) == [2]\nassert op_evens_last3_sorta([10]) == [10]\nassert op_evens_last3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_evens_last3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_upper_lower_anyempty", "entry_point": "op_upper_lower_anyempty", "primitives": ["upper", "lower", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then lowercase each string, then return whether any string is empty.", "solution": "def op_upper_lower_anyempty(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_upper_lower_anyempty(['Hello', 'world']) == False\nassert op_upper_lower_anyempty([]) == False\nassert op_upper_lower_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_upper_lower_anyempty(['one', 'one', 'Two']) == False\nassert op_upper_lower_anyempty(['x']) == False\nassert op_upper_lower_anyempty(['abc', 'de', '']) == True"}
{"id": "op_beforezero_double_prod", "entry_point": "op_beforezero_double_prod", "primitives": ["beforezero", "double", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then return their product.", "solution": "def op_beforezero_double_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_double_prod([1, 2, 3, 4]) == 384\nassert op_beforezero_double_prod([]) == 1\nassert op_beforezero_double_prod([-2, -1, 0, 1, 2]) == 8\nassert op_beforezero_double_prod([5, 5, 5]) == 1000\nassert op_beforezero_double_prod([3, 1, 2]) == 48\nassert op_beforezero_double_prod([10]) == 20\nassert op_beforezero_double_prod([2, 4, 6]) == 384\nassert op_beforezero_double_prod([-7, 12, -7]) == 4704"}
{"id": "op_odds_inc_dropzeros", "entry_point": "op_odds_inc_dropzeros", "primitives": ["odds", "inc", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then drop the zeros.", "solution": "def op_odds_inc_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_inc_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_odds_inc_dropzeros([]) == []\nassert op_odds_inc_dropzeros([-2, -1, 0, 1, 2]) == [2]\nassert op_odds_inc_dropzeros([5, 5, 5]) == [6, 6, 6]\nassert op_odds_inc_dropzeros([3, 1, 2]) == [4, 2]\nassert op_odds_inc_dropzeros([10]) == []\nassert op_odds_inc_dropzeros([2, 4, 6]) == []\nassert op_odds_inc_dropzeros([-7, 12, -7]) == [-6, -6]"}
{"id": "op_uniq_last3_padto3", "entry_point": "op_uniq_last3_padto3", "primitives": ["uniq", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_uniq_last3_padto3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_uniq_last3_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_last3_padto3([]) == [0, 0, 0]\nassert op_uniq_last3_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_last3_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_uniq_last3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_last3_padto3([10]) == [10, 0, 0]\nassert op_uniq_last3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_last3_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_last3_pos_double", "entry_point": "op_last3_pos_double", "primitives": ["last3", "pos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers, then double each.", "solution": "def op_last3_pos_double(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_last3_pos_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_pos_double([]) == []\nassert op_last3_pos_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_last3_pos_double([5, 5, 5]) == [10, 10, 10]\nassert op_last3_pos_double([3, 1, 2]) == [6, 2, 4]\nassert op_last3_pos_double([10]) == [20]\nassert op_last3_pos_double([2, 4, 6]) == [4, 8, 12]\nassert op_last3_pos_double([-7, 12, -7]) == [24]"}
{"id": "op_gt5_evens_div3", "entry_point": "op_gt5_evens_div3", "primitives": ["gt5", "evens", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then keep multiples of three.", "solution": "def op_gt5_evens_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_gt5_evens_div3([1, 2, 3, 4]) == []\nassert op_gt5_evens_div3([]) == []\nassert op_gt5_evens_div3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens_div3([5, 5, 5]) == []\nassert op_gt5_evens_div3([3, 1, 2]) == []\nassert op_gt5_evens_div3([10]) == []\nassert op_gt5_evens_div3([2, 4, 6]) == [6]\nassert op_gt5_evens_div3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_dec_double", "entry_point": "op_gt5_dec_double", "primitives": ["gt5", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then double each.", "solution": "def op_gt5_dec_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_gt5_dec_double([1, 2, 3, 4]) == []\nassert op_gt5_dec_double([]) == []\nassert op_gt5_dec_double([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dec_double([5, 5, 5]) == []\nassert op_gt5_dec_double([3, 1, 2]) == []\nassert op_gt5_dec_double([10]) == [18]\nassert op_gt5_dec_double([2, 4, 6]) == [10]\nassert op_gt5_dec_double([-7, 12, -7]) == [22]"}
{"id": "op_last3_negate_evens", "entry_point": "op_last3_negate_evens", "primitives": ["last3", "negate", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then keep the even numbers.", "solution": "def op_last3_negate_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_negate_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_last3_negate_evens([]) == []\nassert op_last3_negate_evens([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_last3_negate_evens([5, 5, 5]) == []\nassert op_last3_negate_evens([3, 1, 2]) == [-2]\nassert op_last3_negate_evens([10]) == [-10]\nassert op_last3_negate_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_negate_evens([-7, 12, -7]) == [-12]"}
{"id": "op_oremptyzero_padto3_uniq", "entry_point": "op_oremptyzero_padto3_uniq", "primitives": ["oremptyzero", "padto3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_padto3_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_padto3_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_padto3_uniq([]) == [0]\nassert op_oremptyzero_padto3_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_padto3_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_padto3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_padto3_uniq([10]) == [10, 0]\nassert op_oremptyzero_padto3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_padto3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_uniq_sortd_rev", "entry_point": "op_uniq_sortd_rev", "primitives": ["uniq", "sortd", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then reverse the order.", "solution": "def op_uniq_sortd_rev(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return r", "tests": "assert op_uniq_sortd_rev([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sortd_rev([]) == []\nassert op_uniq_sortd_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_sortd_rev([5, 5, 5]) == [5]\nassert op_uniq_sortd_rev([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sortd_rev([10]) == [10]\nassert op_uniq_sortd_rev([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sortd_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_add10_dropzeros_takewhilepos", "entry_point": "op_add10_dropzeros_takewhilepos", "primitives": ["add10", "dropzeros", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then take values while they are positive.", "solution": "def op_add10_dropzeros_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_add10_dropzeros_takewhilepos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros_takewhilepos([]) == []\nassert op_add10_dropzeros_takewhilepos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros_takewhilepos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros_takewhilepos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropzeros_takewhilepos([10]) == [20]\nassert op_add10_dropzeros_takewhilepos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros_takewhilepos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_nonempty_lower_prefixup", "entry_point": "op_nonempty_lower_prefixup", "primitives": ["nonempty", "lower", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then lowercase each string, then prefix each with a hash.", "solution": "def op_nonempty_lower_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.lower() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_nonempty_lower_prefixup(['Hello', 'world']) == ['#hello', '#world']\nassert op_nonempty_lower_prefixup([]) == []\nassert op_nonempty_lower_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ', '#bc', '#bc']\nassert op_nonempty_lower_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#two']\nassert op_nonempty_lower_prefixup(['x']) == ['#x']\nassert op_nonempty_lower_prefixup(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_pos_sorta_prod", "entry_point": "op_pos_sorta_prod", "primitives": ["pos", "sorta", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort ascending, then return their product.", "solution": "def op_pos_sorta_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return __import__('math').prod(r)", "tests": "assert op_pos_sorta_prod([1, 2, 3, 4]) == 24\nassert op_pos_sorta_prod([]) == 1\nassert op_pos_sorta_prod([-2, -1, 0, 1, 2]) == 2\nassert op_pos_sorta_prod([5, 5, 5]) == 125\nassert op_pos_sorta_prod([3, 1, 2]) == 6\nassert op_pos_sorta_prod([10]) == 10\nassert op_pos_sorta_prod([2, 4, 6]) == 48\nassert op_pos_sorta_prod([-7, 12, -7]) == 12"}
{"id": "op_sorta_pos_sum", "entry_point": "op_sorta_pos_sum", "primitives": ["sorta", "pos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers, then return their sum.", "solution": "def op_sorta_pos_sum(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return sum(r)", "tests": "assert op_sorta_pos_sum([1, 2, 3, 4]) == 10\nassert op_sorta_pos_sum([]) == 0\nassert op_sorta_pos_sum([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_pos_sum([5, 5, 5]) == 15\nassert op_sorta_pos_sum([3, 1, 2]) == 6\nassert op_sorta_pos_sum([10]) == 10\nassert op_sorta_pos_sum([2, 4, 6]) == 12\nassert op_sorta_pos_sum([-7, 12, -7]) == 12"}
{"id": "op_absval_odds_negate", "entry_point": "op_absval_odds_negate", "primitives": ["absval", "odds", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers, then negate each.", "solution": "def op_absval_odds_negate(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_absval_odds_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_absval_odds_negate([]) == []\nassert op_absval_odds_negate([-2, -1, 0, 1, 2]) == [-1, -1]\nassert op_absval_odds_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_absval_odds_negate([3, 1, 2]) == [-3, -1]\nassert op_absval_odds_negate([10]) == []\nassert op_absval_odds_negate([2, 4, 6]) == []\nassert op_absval_odds_negate([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_trimends_sorta", "entry_point": "op_pos_trimends_sorta", "primitives": ["pos", "trimends", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then sort ascending.", "solution": "def op_pos_trimends_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = sorted(r)\n    return r", "tests": "assert op_pos_trimends_sorta([1, 2, 3, 4]) == [2, 3]\nassert op_pos_trimends_sorta([]) == []\nassert op_pos_trimends_sorta([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_sorta([5, 5, 5]) == [5]\nassert op_pos_trimends_sorta([3, 1, 2]) == [1]\nassert op_pos_trimends_sorta([10]) == []\nassert op_pos_trimends_sorta([2, 4, 6]) == [4]\nassert op_pos_trimends_sorta([-7, 12, -7]) == []"}
{"id": "op_uniq_pos_beforezero", "entry_point": "op_uniq_pos_beforezero", "primitives": ["uniq", "pos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then keep everything before the first zero.", "solution": "def op_uniq_pos_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_pos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_pos_beforezero([]) == []\nassert op_uniq_pos_beforezero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_pos_beforezero([5, 5, 5]) == [5]\nassert op_uniq_pos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_pos_beforezero([10]) == [10]\nassert op_uniq_pos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_pos_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_negate_sortabs", "entry_point": "op_takewhilepos_negate_sortabs", "primitives": ["takewhilepos", "negate", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then sort by absolute value.", "solution": "def op_takewhilepos_negate_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_negate_sortabs([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_negate_sortabs([]) == []\nassert op_takewhilepos_negate_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_sortabs([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_negate_sortabs([3, 1, 2]) == [-1, -2, -3]\nassert op_takewhilepos_negate_sortabs([10]) == [-10]\nassert op_takewhilepos_negate_sortabs([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_negate_sortabs([-7, 12, -7]) == []"}
{"id": "op_clamp10_pos_first3", "entry_point": "op_clamp10_pos_first3", "primitives": ["clamp10", "pos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the positive numbers, then keep only the first three.", "solution": "def op_clamp10_pos_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_pos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_pos_first3([]) == []\nassert op_clamp10_pos_first3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_pos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_pos_first3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_pos_first3([10]) == [10]\nassert op_clamp10_pos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_pos_first3([-7, 12, -7]) == [10]"}
{"id": "op_last3_evens_len", "entry_point": "op_last3_evens_len", "primitives": ["last3", "evens", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers, then return how many remain.", "solution": "def op_last3_evens_len(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_last3_evens_len([1, 2, 3, 4]) == 2\nassert op_last3_evens_len([]) == 0\nassert op_last3_evens_len([-2, -1, 0, 1, 2]) == 2\nassert op_last3_evens_len([5, 5, 5]) == 0\nassert op_last3_evens_len([3, 1, 2]) == 1\nassert op_last3_evens_len([10]) == 1\nassert op_last3_evens_len([2, 4, 6]) == 3\nassert op_last3_evens_len([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_dropzeros_firsteven", "entry_point": "op_oremptyzero_dropzeros_firsteven", "primitives": ["oremptyzero", "dropzeros", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then return the first even value (0 if none).", "solution": "def op_oremptyzero_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_dropzeros_firsteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_dropzeros_firsteven([]) == 0\nassert op_oremptyzero_dropzeros_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_dropzeros_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_dropzeros_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_dropzeros_firsteven([10]) == 10\nassert op_oremptyzero_dropzeros_firsteven([2, 4, 6]) == 2\nassert op_oremptyzero_dropzeros_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sorta_negate_anyeven", "entry_point": "op_sorta_negate_anyeven", "primitives": ["sorta", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then return whether any value is even.", "solution": "def op_sorta_negate_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_negate_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_negate_anyeven([]) == False\nassert op_sorta_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_negate_anyeven([5, 5, 5]) == False\nassert op_sorta_negate_anyeven([3, 1, 2]) == True\nassert op_sorta_negate_anyeven([10]) == True\nassert op_sorta_negate_anyeven([2, 4, 6]) == True\nassert op_sorta_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_takewhilepos_beforezero", "entry_point": "op_uniq_takewhilepos_beforezero", "primitives": ["uniq", "takewhilepos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_uniq_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_takewhilepos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_takewhilepos_beforezero([]) == []\nassert op_uniq_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos_beforezero([5, 5, 5]) == [5]\nassert op_uniq_takewhilepos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_takewhilepos_beforezero([10]) == [10]\nassert op_uniq_takewhilepos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_takewhilepos_beforezero([-7, 12, -7]) == []"}
{"id": "op_beforezero_double_sortabs", "entry_point": "op_beforezero_double_sortabs", "primitives": ["beforezero", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then sort by absolute value.", "solution": "def op_beforezero_double_sortabs(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_beforezero_double_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_beforezero_double_sortabs([]) == []\nassert op_beforezero_double_sortabs([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_beforezero_double_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_double_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_beforezero_double_sortabs([10]) == [20]\nassert op_beforezero_double_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_double_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_uniq_last3_takewhilepos", "entry_point": "op_uniq_last3_takewhilepos", "primitives": ["uniq", "last3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three, then take values while they are positive.", "solution": "def op_uniq_last3_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_last3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_last3_takewhilepos([]) == []\nassert op_uniq_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_last3_takewhilepos([5, 5, 5]) == [5]\nassert op_uniq_last3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_last3_takewhilepos([10]) == [10]\nassert op_uniq_last3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_last3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_div3_pos_takewhilepos", "entry_point": "op_div3_pos_takewhilepos", "primitives": ["div3", "pos", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then take values while they are positive.", "solution": "def op_div3_pos_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_pos_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_div3_pos_takewhilepos([]) == []\nassert op_div3_pos_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_pos_takewhilepos([5, 5, 5]) == []\nassert op_div3_pos_takewhilepos([3, 1, 2]) == [3]\nassert op_div3_pos_takewhilepos([10]) == []\nassert op_div3_pos_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_pos_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_firstchar_prefixup", "entry_point": "op_uniqs_firstchar_prefixup", "primitives": ["uniqs", "firstchar", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then keep the first character of each (dropping empties), then prefix each with a hash.", "solution": "def op_uniqs_firstchar_prefixup(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_uniqs_firstchar_prefixup(['Hello', 'world']) == ['#H', '#w']\nassert op_uniqs_firstchar_prefixup([]) == []\nassert op_uniqs_firstchar_prefixup(['  a ', '', 'BC', 'bc']) == ['# ', '#B', '#b']\nassert op_uniqs_firstchar_prefixup(['one', 'one', 'Two']) == ['#o', '#T']\nassert op_uniqs_firstchar_prefixup(['x']) == ['#x']\nassert op_uniqs_firstchar_prefixup(['abc', 'de', '']) == ['#a', '#d']"}
{"id": "op_padto3_square_div3", "entry_point": "op_padto3_square_div3", "primitives": ["padto3", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then keep multiples of three.", "solution": "def op_padto3_square_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_square_div3([1, 2, 3, 4]) == [9]\nassert op_padto3_square_div3([]) == [0, 0, 0]\nassert op_padto3_square_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_square_div3([5, 5, 5]) == []\nassert op_padto3_square_div3([3, 1, 2]) == [9]\nassert op_padto3_square_div3([10]) == [0, 0]\nassert op_padto3_square_div3([2, 4, 6]) == [36]\nassert op_padto3_square_div3([-7, 12, -7]) == [144]"}
{"id": "op_dropzeros_beforezero_issorted", "entry_point": "op_dropzeros_beforezero_issorted", "primitives": ["dropzeros", "beforezero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_beforezero_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r == sorted(r)", "tests": "assert op_dropzeros_beforezero_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_beforezero_issorted([]) == True\nassert op_dropzeros_beforezero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_beforezero_issorted([5, 5, 5]) == True\nassert op_dropzeros_beforezero_issorted([3, 1, 2]) == False\nassert op_dropzeros_beforezero_issorted([10]) == True\nassert op_dropzeros_beforezero_issorted([2, 4, 6]) == True\nassert op_dropzeros_beforezero_issorted([-7, 12, -7]) == False"}
{"id": "op_div3_takewhilepos_trimends", "entry_point": "op_div3_takewhilepos_trimends", "primitives": ["div3", "takewhilepos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then drop the first and last elements.", "solution": "def op_div3_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_takewhilepos_trimends([1, 2, 3, 4]) == []\nassert op_div3_takewhilepos_trimends([]) == []\nassert op_div3_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_trimends([5, 5, 5]) == []\nassert op_div3_takewhilepos_trimends([3, 1, 2]) == []\nassert op_div3_takewhilepos_trimends([10]) == []\nassert op_div3_takewhilepos_trimends([2, 4, 6]) == []\nassert op_div3_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_pos_inc_rev", "entry_point": "op_pos_inc_rev", "primitives": ["pos", "inc", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then reverse the order.", "solution": "def op_pos_inc_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_inc_rev([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_pos_inc_rev([]) == []\nassert op_pos_inc_rev([-2, -1, 0, 1, 2]) == [3, 2]\nassert op_pos_inc_rev([5, 5, 5]) == [6, 6, 6]\nassert op_pos_inc_rev([3, 1, 2]) == [3, 2, 4]\nassert op_pos_inc_rev([10]) == [11]\nassert op_pos_inc_rev([2, 4, 6]) == [7, 5, 3]\nassert op_pos_inc_rev([-7, 12, -7]) == [13]"}
{"id": "op_pos_first3_double", "entry_point": "op_pos_first3_double", "primitives": ["pos", "first3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then double each.", "solution": "def op_pos_first3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_first3_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_pos_first3_double([]) == []\nassert op_pos_first3_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_first3_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_first3_double([3, 1, 2]) == [6, 2, 4]\nassert op_pos_first3_double([10]) == [20]\nassert op_pos_first3_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_first3_double([-7, 12, -7]) == [24]"}
{"id": "op_gt5_sortabs_beforezero", "entry_point": "op_gt5_sortabs_beforezero", "primitives": ["gt5", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_gt5_sortabs_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_gt5_sortabs_beforezero([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_beforezero([]) == []\nassert op_gt5_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_beforezero([5, 5, 5]) == []\nassert op_gt5_sortabs_beforezero([3, 1, 2]) == []\nassert op_gt5_sortabs_beforezero([10]) == [10]\nassert op_gt5_sortabs_beforezero([2, 4, 6]) == [6]\nassert op_gt5_sortabs_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_upper_nonempty_counts", "entry_point": "op_upper_nonempty_counts", "primitives": ["upper", "nonempty", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop empty strings, then return how many strings remain.", "solution": "def op_upper_nonempty_counts(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    return len(r)", "tests": "assert op_upper_nonempty_counts(['Hello', 'world']) == 2\nassert op_upper_nonempty_counts([]) == 0\nassert op_upper_nonempty_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_upper_nonempty_counts(['one', 'one', 'Two']) == 3\nassert op_upper_nonempty_counts(['x']) == 1\nassert op_upper_nonempty_counts(['abc', 'de', '']) == 2"}
{"id": "op_padto3_dropzeros_gt5", "entry_point": "op_padto3_dropzeros_gt5", "primitives": ["padto3", "dropzeros", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros, then keep values greater than five.", "solution": "def op_padto3_dropzeros_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_padto3_dropzeros_gt5([]) == []\nassert op_padto3_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_dropzeros_gt5([5, 5, 5]) == []\nassert op_padto3_dropzeros_gt5([3, 1, 2]) == []\nassert op_padto3_dropzeros_gt5([10]) == [10]\nassert op_padto3_dropzeros_gt5([2, 4, 6]) == [6]\nassert op_padto3_dropzeros_gt5([-7, 12, -7]) == [12]"}
{"id": "op_odds_pos_sorta", "entry_point": "op_odds_pos_sorta", "primitives": ["odds", "pos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then sort ascending.", "solution": "def op_odds_pos_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_odds_pos_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_odds_pos_sorta([]) == []\nassert op_odds_pos_sorta([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_odds_pos_sorta([3, 1, 2]) == [1, 3]\nassert op_odds_pos_sorta([10]) == []\nassert op_odds_pos_sorta([2, 4, 6]) == []\nassert op_odds_pos_sorta([-7, 12, -7]) == []"}
{"id": "op_first3_takewhilepos_min", "entry_point": "op_first3_takewhilepos_min", "primitives": ["first3", "takewhilepos", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_first3_takewhilepos_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_first3_takewhilepos_min([1, 2, 3, 4]) == 1\nassert op_first3_takewhilepos_min([]) == 0\nassert op_first3_takewhilepos_min([-2, -1, 0, 1, 2]) == 0\nassert op_first3_takewhilepos_min([5, 5, 5]) == 5\nassert op_first3_takewhilepos_min([3, 1, 2]) == 1\nassert op_first3_takewhilepos_min([10]) == 10\nassert op_first3_takewhilepos_min([2, 4, 6]) == 2\nassert op_first3_takewhilepos_min([-7, 12, -7]) == 0"}
{"id": "op_first3_gt5_min", "entry_point": "op_first3_gt5_min", "primitives": ["first3", "gt5", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_first3_gt5_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_first3_gt5_min([1, 2, 3, 4]) == 0\nassert op_first3_gt5_min([]) == 0\nassert op_first3_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_first3_gt5_min([5, 5, 5]) == 0\nassert op_first3_gt5_min([3, 1, 2]) == 0\nassert op_first3_gt5_min([10]) == 10\nassert op_first3_gt5_min([2, 4, 6]) == 6\nassert op_first3_gt5_min([-7, 12, -7]) == 12"}
{"id": "op_sortabs_double_sortd", "entry_point": "op_sortabs_double_sortd", "primitives": ["sortabs", "double", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then sort descending.", "solution": "def op_sortabs_double_sortd(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortabs_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortabs_double_sortd([]) == []\nassert op_sortabs_double_sortd([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_sortabs_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_sortabs_double_sortd([10]) == [20]\nassert op_sortabs_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_sortabs_double_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_ages_sortd_dec", "entry_point": "op_ages_sortd_dec", "primitives": ["ages", "sortd", "dec"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then subtract one from each.", "solution": "def op_ages_sortd_dec(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_ages_sortd_dec([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11]\nassert op_ages_sortd_dec([]) == []\nassert op_ages_sortd_dec([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [64, 17, 16]\nassert op_ages_sortd_dec([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_rev_gt5_allpos", "entry_point": "op_rev_gt5_allpos", "primitives": ["rev", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five, then return whether all values are positive.", "solution": "def op_rev_gt5_allpos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_rev_gt5_allpos([1, 2, 3, 4]) == True\nassert op_rev_gt5_allpos([]) == True\nassert op_rev_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_rev_gt5_allpos([5, 5, 5]) == True\nassert op_rev_gt5_allpos([3, 1, 2]) == True\nassert op_rev_gt5_allpos([10]) == True\nassert op_rev_gt5_allpos([2, 4, 6]) == True\nassert op_rev_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_dropfirst_pos_haszero", "entry_point": "op_dropfirst_pos_haszero", "primitives": ["dropfirst", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_dropfirst_pos_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_dropfirst_pos_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_pos_haszero([]) == False\nassert op_dropfirst_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_pos_haszero([5, 5, 5]) == False\nassert op_dropfirst_pos_haszero([3, 1, 2]) == False\nassert op_dropfirst_pos_haszero([10]) == False\nassert op_dropfirst_pos_haszero([2, 4, 6]) == False\nassert op_dropfirst_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_beforezero_sum", "entry_point": "op_gt5_beforezero_sum", "primitives": ["gt5", "beforezero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then return their sum.", "solution": "def op_gt5_beforezero_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(r)", "tests": "assert op_gt5_beforezero_sum([1, 2, 3, 4]) == 0\nassert op_gt5_beforezero_sum([]) == 0\nassert op_gt5_beforezero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_beforezero_sum([5, 5, 5]) == 0\nassert op_gt5_beforezero_sum([3, 1, 2]) == 0\nassert op_gt5_beforezero_sum([10]) == 10\nassert op_gt5_beforezero_sum([2, 4, 6]) == 6\nassert op_gt5_beforezero_sum([-7, 12, -7]) == 12"}
{"id": "op_square_dropwhileneg_len", "entry_point": "op_square_dropwhileneg_len", "primitives": ["square", "dropwhileneg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then return how many remain.", "solution": "def op_square_dropwhileneg_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r)", "tests": "assert op_square_dropwhileneg_len([1, 2, 3, 4]) == 4\nassert op_square_dropwhileneg_len([]) == 0\nassert op_square_dropwhileneg_len([-2, -1, 0, 1, 2]) == 5\nassert op_square_dropwhileneg_len([5, 5, 5]) == 3\nassert op_square_dropwhileneg_len([3, 1, 2]) == 3\nassert op_square_dropwhileneg_len([10]) == 1\nassert op_square_dropwhileneg_len([2, 4, 6]) == 3\nassert op_square_dropwhileneg_len([-7, 12, -7]) == 3"}
{"id": "op_sorta_uniq_evens", "entry_point": "op_sorta_uniq_evens", "primitives": ["sorta", "uniq", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_sorta_uniq_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_uniq_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_uniq_evens([]) == []\nassert op_sorta_uniq_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_sorta_uniq_evens([5, 5, 5]) == []\nassert op_sorta_uniq_evens([3, 1, 2]) == [2]\nassert op_sorta_uniq_evens([10]) == [10]\nassert op_sorta_uniq_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_uniq_evens([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_takewhilepos_absval", "entry_point": "op_dropwhileneg_takewhilepos_absval", "primitives": ["dropwhileneg", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive, then take the absolute value of each.", "solution": "def op_dropwhileneg_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_takewhilepos_absval([]) == []\nassert op_dropwhileneg_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_takewhilepos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_takewhilepos_absval([10]) == [10]\nassert op_dropwhileneg_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_takewhilepos_absval([-7, 12, -7]) == [12]"}
{"id": "op_trimends_sortd_issorted", "entry_point": "op_trimends_sortd_issorted", "primitives": ["trimends", "sortd", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_trimends_sortd_issorted(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_trimends_sortd_issorted([1, 2, 3, 4]) == False\nassert op_trimends_sortd_issorted([]) == True\nassert op_trimends_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_trimends_sortd_issorted([5, 5, 5]) == True\nassert op_trimends_sortd_issorted([3, 1, 2]) == True\nassert op_trimends_sortd_issorted([10]) == True\nassert op_trimends_sortd_issorted([2, 4, 6]) == True\nassert op_trimends_sortd_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_pos_div3", "entry_point": "op_padto3_pos_div3", "primitives": ["padto3", "pos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then keep multiples of three.", "solution": "def op_padto3_pos_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_pos_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_pos_div3([]) == []\nassert op_padto3_pos_div3([-2, -1, 0, 1, 2]) == []\nassert op_padto3_pos_div3([5, 5, 5]) == []\nassert op_padto3_pos_div3([3, 1, 2]) == [3]\nassert op_padto3_pos_div3([10]) == []\nassert op_padto3_pos_div3([2, 4, 6]) == [6]\nassert op_padto3_pos_div3([-7, 12, -7]) == [12]"}
{"id": "op_trimends_add10_div3", "entry_point": "op_trimends_add10_div3", "primitives": ["trimends", "add10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then keep multiples of three.", "solution": "def op_trimends_add10_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_add10_div3([1, 2, 3, 4]) == [12]\nassert op_trimends_add10_div3([]) == []\nassert op_trimends_add10_div3([-2, -1, 0, 1, 2]) == [9]\nassert op_trimends_add10_div3([5, 5, 5]) == [15]\nassert op_trimends_add10_div3([3, 1, 2]) == []\nassert op_trimends_add10_div3([10]) == []\nassert op_trimends_add10_div3([2, 4, 6]) == []\nassert op_trimends_add10_div3([-7, 12, -7]) == []"}
{"id": "op_gt5_sortd_sorta", "entry_point": "op_gt5_sortd_sorta", "primitives": ["gt5", "sortd", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then sort ascending.", "solution": "def op_gt5_sortd_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_sortd_sorta([1, 2, 3, 4]) == []\nassert op_gt5_sortd_sorta([]) == []\nassert op_gt5_sortd_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd_sorta([5, 5, 5]) == []\nassert op_gt5_sortd_sorta([3, 1, 2]) == []\nassert op_gt5_sortd_sorta([10]) == [10]\nassert op_gt5_sortd_sorta([2, 4, 6]) == [6]\nassert op_gt5_sortd_sorta([-7, 12, -7]) == [12]"}
{"id": "op_square_neg_odds", "entry_point": "op_square_neg_odds", "primitives": ["square", "neg", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_square_neg_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_neg_odds([1, 2, 3, 4]) == []\nassert op_square_neg_odds([]) == []\nassert op_square_neg_odds([-2, -1, 0, 1, 2]) == []\nassert op_square_neg_odds([5, 5, 5]) == []\nassert op_square_neg_odds([3, 1, 2]) == []\nassert op_square_neg_odds([10]) == []\nassert op_square_neg_odds([2, 4, 6]) == []\nassert op_square_neg_odds([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_inc_gt5", "entry_point": "op_oremptyzero_inc_gt5", "primitives": ["oremptyzero", "inc", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each, then keep values greater than five.", "solution": "def op_oremptyzero_inc_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_inc_gt5([1, 2, 3, 4]) == []\nassert op_oremptyzero_inc_gt5([]) == []\nassert op_oremptyzero_inc_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_inc_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_oremptyzero_inc_gt5([3, 1, 2]) == []\nassert op_oremptyzero_inc_gt5([10]) == [11]\nassert op_oremptyzero_inc_gt5([2, 4, 6]) == [7]\nassert op_oremptyzero_inc_gt5([-7, 12, -7]) == [13]"}
{"id": "op_clamp10_double_allpos", "entry_point": "op_clamp10_double_allpos", "primitives": ["clamp10", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then return whether all values are positive.", "solution": "def op_clamp10_double_allpos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_clamp10_double_allpos([1, 2, 3, 4]) == True\nassert op_clamp10_double_allpos([]) == True\nassert op_clamp10_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_clamp10_double_allpos([5, 5, 5]) == True\nassert op_clamp10_double_allpos([3, 1, 2]) == True\nassert op_clamp10_double_allpos([10]) == True\nassert op_clamp10_double_allpos([2, 4, 6]) == True\nassert op_clamp10_double_allpos([-7, 12, -7]) == False"}
{"id": "op_pos_rev_add10", "entry_point": "op_pos_rev_add10", "primitives": ["pos", "rev", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then add ten to each.", "solution": "def op_pos_rev_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_rev_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_pos_rev_add10([]) == []\nassert op_pos_rev_add10([-2, -1, 0, 1, 2]) == [12, 11]\nassert op_pos_rev_add10([5, 5, 5]) == [15, 15, 15]\nassert op_pos_rev_add10([3, 1, 2]) == [12, 11, 13]\nassert op_pos_rev_add10([10]) == [20]\nassert op_pos_rev_add10([2, 4, 6]) == [16, 14, 12]\nassert op_pos_rev_add10([-7, 12, -7]) == [22]"}
{"id": "op_sortabs_inc_issorted", "entry_point": "op_sortabs_inc_issorted", "primitives": ["sortabs", "inc", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then return whether the list is sorted ascending.", "solution": "def op_sortabs_inc_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_sortabs_inc_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_inc_issorted([]) == True\nassert op_sortabs_inc_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_inc_issorted([5, 5, 5]) == True\nassert op_sortabs_inc_issorted([3, 1, 2]) == True\nassert op_sortabs_inc_issorted([10]) == True\nassert op_sortabs_inc_issorted([2, 4, 6]) == True\nassert op_sortabs_inc_issorted([-7, 12, -7]) == True"}
{"id": "op_clamp10_inc_neg", "entry_point": "op_clamp10_inc_neg", "primitives": ["clamp10", "inc", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then keep the negative numbers.", "solution": "def op_clamp10_inc_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_inc_neg([1, 2, 3, 4]) == []\nassert op_clamp10_inc_neg([]) == []\nassert op_clamp10_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_clamp10_inc_neg([5, 5, 5]) == []\nassert op_clamp10_inc_neg([3, 1, 2]) == []\nassert op_clamp10_inc_neg([10]) == []\nassert op_clamp10_inc_neg([2, 4, 6]) == []\nassert op_clamp10_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_padto3_trimends_rev", "entry_point": "op_padto3_trimends_rev", "primitives": ["padto3", "trimends", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then reverse the order.", "solution": "def op_padto3_trimends_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_padto3_trimends_rev([]) == [0]\nassert op_padto3_trimends_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_padto3_trimends_rev([5, 5, 5]) == [5]\nassert op_padto3_trimends_rev([3, 1, 2]) == [1]\nassert op_padto3_trimends_rev([10]) == [0]\nassert op_padto3_trimends_rev([2, 4, 6]) == [4]\nassert op_padto3_trimends_rev([-7, 12, -7]) == [12]"}
{"id": "op_inc_clamp10_dec", "entry_point": "op_inc_clamp10_dec", "primitives": ["inc", "clamp10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then subtract one from each.", "solution": "def op_inc_clamp10_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_clamp10_dec([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_clamp10_dec([]) == []\nassert op_inc_clamp10_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_clamp10_dec([5, 5, 5]) == [5, 5, 5]\nassert op_inc_clamp10_dec([3, 1, 2]) == [3, 1, 2]\nassert op_inc_clamp10_dec([10]) == [9]\nassert op_inc_clamp10_dec([2, 4, 6]) == [2, 4, 6]\nassert op_inc_clamp10_dec([-7, 12, -7]) == [-7, 9, -7]"}
{"id": "op_sortd_odds_issorted", "entry_point": "op_sortd_odds_issorted", "primitives": ["sortd", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_sortd_odds_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_sortd_odds_issorted([1, 2, 3, 4]) == False\nassert op_sortd_odds_issorted([]) == True\nassert op_sortd_odds_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortd_odds_issorted([5, 5, 5]) == True\nassert op_sortd_odds_issorted([3, 1, 2]) == False\nassert op_sortd_odds_issorted([10]) == True\nassert op_sortd_odds_issorted([2, 4, 6]) == True\nassert op_sortd_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_negate_last3_alldistinct", "entry_point": "op_negate_last3_alldistinct", "primitives": ["negate", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then return whether all values are distinct.", "solution": "def op_negate_last3_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_negate_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_last3_alldistinct([]) == True\nassert op_negate_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_last3_alldistinct([5, 5, 5]) == False\nassert op_negate_last3_alldistinct([3, 1, 2]) == True\nassert op_negate_last3_alldistinct([10]) == True\nassert op_negate_last3_alldistinct([2, 4, 6]) == True\nassert op_negate_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sortd_dropzeros_dec", "entry_point": "op_sortd_dropzeros_dec", "primitives": ["sortd", "dropzeros", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then subtract one from each.", "solution": "def op_sortd_dropzeros_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_dropzeros_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortd_dropzeros_dec([]) == []\nassert op_sortd_dropzeros_dec([-2, -1, 0, 1, 2]) == [1, 0, -2, -3]\nassert op_sortd_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_dropzeros_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_dropzeros_dec([10]) == [9]\nassert op_sortd_dropzeros_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_dropzeros_dec([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_last3_neg_uniq", "entry_point": "op_last3_neg_uniq", "primitives": ["last3", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_last3_neg_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_neg_uniq([1, 2, 3, 4]) == []\nassert op_last3_neg_uniq([]) == []\nassert op_last3_neg_uniq([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_uniq([5, 5, 5]) == []\nassert op_last3_neg_uniq([3, 1, 2]) == []\nassert op_last3_neg_uniq([10]) == []\nassert op_last3_neg_uniq([2, 4, 6]) == []\nassert op_last3_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_sortalpha_uniqs_maxlen", "entry_point": "op_sortalpha_uniqs_maxlen", "primitives": ["sortalpha", "uniqs", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then return the length of the longest string (0 if none).", "solution": "def op_sortalpha_uniqs_maxlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortalpha_uniqs_maxlen(['Hello', 'world']) == 5\nassert op_sortalpha_uniqs_maxlen([]) == 0\nassert op_sortalpha_uniqs_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_uniqs_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortalpha_uniqs_maxlen(['x']) == 1\nassert op_sortalpha_uniqs_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_negate_neg_min", "entry_point": "op_negate_neg_min", "primitives": ["negate", "neg", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_negate_neg_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_negate_neg_min([1, 2, 3, 4]) == -4\nassert op_negate_neg_min([]) == 0\nassert op_negate_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_negate_neg_min([5, 5, 5]) == -5\nassert op_negate_neg_min([3, 1, 2]) == -3\nassert op_negate_neg_min([10]) == -10\nassert op_negate_neg_min([2, 4, 6]) == -6\nassert op_negate_neg_min([-7, 12, -7]) == -12"}
{"id": "op_div3_absval_anyeven", "entry_point": "op_div3_absval_anyeven", "primitives": ["div3", "absval", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each, then return whether any value is even.", "solution": "def op_div3_absval_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_absval_anyeven([1, 2, 3, 4]) == False\nassert op_div3_absval_anyeven([]) == False\nassert op_div3_absval_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_div3_absval_anyeven([5, 5, 5]) == False\nassert op_div3_absval_anyeven([3, 1, 2]) == False\nassert op_div3_absval_anyeven([10]) == False\nassert op_div3_absval_anyeven([2, 4, 6]) == True\nassert op_div3_absval_anyeven([-7, 12, -7]) == True"}
{"id": "op_ages_last3_sortabs", "entry_point": "op_ages_last3_sortabs", "primitives": ["ages", "last3", "sortabs"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then sort by absolute value.", "solution": "def op_ages_last3_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_last3_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_last3_sortabs([]) == []\nassert op_ages_last3_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_last3_sortabs([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_evens_add10_pos", "entry_point": "op_evens_add10_pos", "primitives": ["evens", "add10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then keep the positive numbers.", "solution": "def op_evens_add10_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_evens_add10_pos([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10_pos([]) == []\nassert op_evens_add10_pos([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10_pos([5, 5, 5]) == []\nassert op_evens_add10_pos([3, 1, 2]) == [12]\nassert op_evens_add10_pos([10]) == [20]\nassert op_evens_add10_pos([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10_pos([-7, 12, -7]) == [22]"}
{"id": "op_dropwhileneg_double_dec", "entry_point": "op_dropwhileneg_double_dec", "primitives": ["dropwhileneg", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then subtract one from each.", "solution": "def op_dropwhileneg_double_dec(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_double_dec([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_dropwhileneg_double_dec([]) == []\nassert op_dropwhileneg_double_dec([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_dropwhileneg_double_dec([5, 5, 5]) == [9, 9, 9]\nassert op_dropwhileneg_double_dec([3, 1, 2]) == [5, 1, 3]\nassert op_dropwhileneg_double_dec([10]) == [19]\nassert op_dropwhileneg_double_dec([2, 4, 6]) == [3, 7, 11]\nassert op_dropwhileneg_double_dec([-7, 12, -7]) == [23, -15]"}
{"id": "op_padto3_trimends_first3", "entry_point": "op_padto3_trimends_first3", "primitives": ["padto3", "trimends", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then keep only the first three.", "solution": "def op_padto3_trimends_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_trimends_first3([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_trimends_first3([]) == [0]\nassert op_padto3_trimends_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_trimends_first3([5, 5, 5]) == [5]\nassert op_padto3_trimends_first3([3, 1, 2]) == [1]\nassert op_padto3_trimends_first3([10]) == [0]\nassert op_padto3_trimends_first3([2, 4, 6]) == [4]\nassert op_padto3_trimends_first3([-7, 12, -7]) == [12]"}
{"id": "op_square_double_rev", "entry_point": "op_square_double_rev", "primitives": ["square", "double", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then reverse the order.", "solution": "def op_square_double_rev(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_square_double_rev([1, 2, 3, 4]) == [32, 18, 8, 2]\nassert op_square_double_rev([]) == []\nassert op_square_double_rev([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_square_double_rev([5, 5, 5]) == [50, 50, 50]\nassert op_square_double_rev([3, 1, 2]) == [8, 2, 18]\nassert op_square_double_rev([10]) == [200]\nassert op_square_double_rev([2, 4, 6]) == [72, 32, 8]\nassert op_square_double_rev([-7, 12, -7]) == [98, 288, 98]"}
{"id": "op_first3_dropzeros_double", "entry_point": "op_first3_dropzeros_double", "primitives": ["first3", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then double each.", "solution": "def op_first3_dropzeros_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_dropzeros_double([]) == []\nassert op_first3_dropzeros_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_first3_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_first3_dropzeros_double([10]) == [20]\nassert op_first3_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_first3_dropzeros_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dec_evens_sum", "entry_point": "op_dec_evens_sum", "primitives": ["dec", "evens", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then return their sum.", "solution": "def op_dec_evens_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_dec_evens_sum([1, 2, 3, 4]) == 2\nassert op_dec_evens_sum([]) == 0\nassert op_dec_evens_sum([-2, -1, 0, 1, 2]) == -2\nassert op_dec_evens_sum([5, 5, 5]) == 12\nassert op_dec_evens_sum([3, 1, 2]) == 2\nassert op_dec_evens_sum([10]) == 0\nassert op_dec_evens_sum([2, 4, 6]) == 0\nassert op_dec_evens_sum([-7, 12, -7]) == -16"}
{"id": "op_gt5_sortd_absval", "entry_point": "op_gt5_sortd_absval", "primitives": ["gt5", "sortd", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then take the absolute value of each.", "solution": "def op_gt5_sortd_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_sortd_absval([1, 2, 3, 4]) == []\nassert op_gt5_sortd_absval([]) == []\nassert op_gt5_sortd_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd_absval([5, 5, 5]) == []\nassert op_gt5_sortd_absval([3, 1, 2]) == []\nassert op_gt5_sortd_absval([10]) == [10]\nassert op_gt5_sortd_absval([2, 4, 6]) == [6]\nassert op_gt5_sortd_absval([-7, 12, -7]) == [12]"}
{"id": "op_sorta_sortd_haszero", "entry_point": "op_sorta_sortd_haszero", "primitives": ["sorta", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then return whether the list contains a zero.", "solution": "def op_sorta_sortd_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_sorta_sortd_haszero([1, 2, 3, 4]) == False\nassert op_sorta_sortd_haszero([]) == False\nassert op_sorta_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_sortd_haszero([5, 5, 5]) == False\nassert op_sorta_sortd_haszero([3, 1, 2]) == False\nassert op_sorta_sortd_haszero([10]) == False\nassert op_sorta_sortd_haszero([2, 4, 6]) == False\nassert op_sorta_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_dropfirst_padto3", "entry_point": "op_takewhilepos_dropfirst_padto3", "primitives": ["takewhilepos", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_takewhilepos_dropfirst_padto3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_takewhilepos_dropfirst_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_dropfirst_padto3([]) == [0, 0, 0]\nassert op_takewhilepos_dropfirst_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_dropfirst_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_takewhilepos_dropfirst_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_takewhilepos_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_takewhilepos_dropfirst_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_takewhilepos_dropfirst_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_double_beforezero_sortabs", "entry_point": "op_double_beforezero_sortabs", "primitives": ["double", "beforezero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero, then sort by absolute value.", "solution": "def op_double_beforezero_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_beforezero_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_beforezero_sortabs([]) == []\nassert op_double_beforezero_sortabs([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_double_beforezero_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_double_beforezero_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_double_beforezero_sortabs([10]) == [20]\nassert op_double_beforezero_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_double_beforezero_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_oremptyzero_uniq_issorted", "entry_point": "op_oremptyzero_uniq_issorted", "primitives": ["oremptyzero", "uniq", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_uniq_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_oremptyzero_uniq_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_uniq_issorted([]) == True\nassert op_oremptyzero_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_uniq_issorted([5, 5, 5]) == True\nassert op_oremptyzero_uniq_issorted([3, 1, 2]) == False\nassert op_oremptyzero_uniq_issorted([10]) == True\nassert op_oremptyzero_uniq_issorted([2, 4, 6]) == True\nassert op_oremptyzero_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_first3_absval_min", "entry_point": "op_first3_absval_min", "primitives": ["first3", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_first3_absval_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_first3_absval_min([1, 2, 3, 4]) == 1\nassert op_first3_absval_min([]) == 0\nassert op_first3_absval_min([-2, -1, 0, 1, 2]) == 0\nassert op_first3_absval_min([5, 5, 5]) == 5\nassert op_first3_absval_min([3, 1, 2]) == 1\nassert op_first3_absval_min([10]) == 10\nassert op_first3_absval_min([2, 4, 6]) == 2\nassert op_first3_absval_min([-7, 12, -7]) == 7"}
{"id": "op_sortabs_neg_haszero", "entry_point": "op_sortabs_neg_haszero", "primitives": ["sortabs", "neg", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then return whether the list contains a zero.", "solution": "def op_sortabs_neg_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return 0 in r", "tests": "assert op_sortabs_neg_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_neg_haszero([]) == False\nassert op_sortabs_neg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_neg_haszero([5, 5, 5]) == False\nassert op_sortabs_neg_haszero([3, 1, 2]) == False\nassert op_sortabs_neg_haszero([10]) == False\nassert op_sortabs_neg_haszero([2, 4, 6]) == False\nassert op_sortabs_neg_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_sortd_first3", "entry_point": "op_odds_sortd_first3", "primitives": ["odds", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort descending, then keep only the first three.", "solution": "def op_odds_sortd_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_odds_sortd_first3([1, 2, 3, 4]) == [3, 1]\nassert op_odds_sortd_first3([]) == []\nassert op_odds_sortd_first3([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_sortd_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortd_first3([3, 1, 2]) == [3, 1]\nassert op_odds_sortd_first3([10]) == []\nassert op_odds_sortd_first3([2, 4, 6]) == []\nassert op_odds_sortd_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_clamp10_rev_neg", "entry_point": "op_clamp10_rev_neg", "primitives": ["clamp10", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then keep the negative numbers.", "solution": "def op_clamp10_rev_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_rev_neg([1, 2, 3, 4]) == []\nassert op_clamp10_rev_neg([]) == []\nassert op_clamp10_rev_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_clamp10_rev_neg([5, 5, 5]) == []\nassert op_clamp10_rev_neg([3, 1, 2]) == []\nassert op_clamp10_rev_neg([10]) == []\nassert op_clamp10_rev_neg([2, 4, 6]) == []\nassert op_clamp10_rev_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_absval_negate", "entry_point": "op_sortabs_absval_negate", "primitives": ["sortabs", "absval", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then negate each.", "solution": "def op_sortabs_absval_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_absval_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sortabs_absval_negate([]) == []\nassert op_sortabs_absval_negate([-2, -1, 0, 1, 2]) == [0, -1, -1, -2, -2]\nassert op_sortabs_absval_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_absval_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_absval_negate([10]) == [-10]\nassert op_sortabs_absval_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_absval_negate([-7, 12, -7]) == [-7, -7, -12]"}
{"id": "op_add10_absval_dropwhileneg", "entry_point": "op_add10_absval_dropwhileneg", "primitives": ["add10", "absval", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then drop the leading negative values.", "solution": "def op_add10_absval_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_absval_dropwhileneg([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_absval_dropwhileneg([]) == []\nassert op_add10_absval_dropwhileneg([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_absval_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_absval_dropwhileneg([3, 1, 2]) == [13, 11, 12]\nassert op_add10_absval_dropwhileneg([10]) == [20]\nassert op_add10_absval_dropwhileneg([2, 4, 6]) == [12, 14, 16]\nassert op_add10_absval_dropwhileneg([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_clamp10_square_takewhilepos", "entry_point": "op_clamp10_square_takewhilepos", "primitives": ["clamp10", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then take values while they are positive.", "solution": "def op_clamp10_square_takewhilepos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_clamp10_square_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_square_takewhilepos([]) == []\nassert op_clamp10_square_takewhilepos([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_clamp10_square_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square_takewhilepos([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_square_takewhilepos([10]) == [100]\nassert op_clamp10_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_square_takewhilepos([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_sortd_takewhilepos_pos", "entry_point": "op_sortd_takewhilepos_pos", "primitives": ["sortd", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then keep the positive numbers.", "solution": "def op_sortd_takewhilepos_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_takewhilepos_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_takewhilepos_pos([]) == []\nassert op_sortd_takewhilepos_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_takewhilepos_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_takewhilepos_pos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_takewhilepos_pos([10]) == [10]\nassert op_sortd_takewhilepos_pos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_takewhilepos_pos([-7, 12, -7]) == [12]"}
{"id": "op_neg_sortabs_sum", "entry_point": "op_neg_sortabs_sum", "primitives": ["neg", "sortabs", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then return their sum.", "solution": "def op_neg_sortabs_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return sum(r)", "tests": "assert op_neg_sortabs_sum([1, 2, 3, 4]) == 0\nassert op_neg_sortabs_sum([]) == 0\nassert op_neg_sortabs_sum([-2, -1, 0, 1, 2]) == -3\nassert op_neg_sortabs_sum([5, 5, 5]) == 0\nassert op_neg_sortabs_sum([3, 1, 2]) == 0\nassert op_neg_sortabs_sum([10]) == 0\nassert op_neg_sortabs_sum([2, 4, 6]) == 0\nassert op_neg_sortabs_sum([-7, 12, -7]) == -14"}
{"id": "op_sortd_evens_first3", "entry_point": "op_sortd_evens_first3", "primitives": ["sortd", "evens", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then keep only the first three.", "solution": "def op_sortd_evens_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_sortd_evens_first3([1, 2, 3, 4]) == [4, 2]\nassert op_sortd_evens_first3([]) == []\nassert op_sortd_evens_first3([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_sortd_evens_first3([5, 5, 5]) == []\nassert op_sortd_evens_first3([3, 1, 2]) == [2]\nassert op_sortd_evens_first3([10]) == [10]\nassert op_sortd_evens_first3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_evens_first3([-7, 12, -7]) == [12]"}
{"id": "op_rev_beforezero_dropzeros", "entry_point": "op_rev_beforezero_dropzeros", "primitives": ["rev", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then drop the zeros.", "solution": "def op_rev_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_beforezero_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_dropzeros([]) == []\nassert op_rev_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_dropzeros([10]) == [10]\nassert op_rev_beforezero_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_ages_uniq_dropwhileneg", "entry_point": "op_ages_uniq_dropwhileneg", "primitives": ["ages", "uniq", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_ages_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_uniq_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_uniq_dropwhileneg([]) == []\nassert op_ages_uniq_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_uniq_dropwhileneg([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortalpha_firstchar_prefixup", "entry_point": "op_sortalpha_firstchar_prefixup", "primitives": ["sortalpha", "firstchar", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then keep the first character of each (dropping empties), then prefix each with a hash.", "solution": "def op_sortalpha_firstchar_prefixup(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_sortalpha_firstchar_prefixup(['Hello', 'world']) == ['#H', '#w']\nassert op_sortalpha_firstchar_prefixup([]) == []\nassert op_sortalpha_firstchar_prefixup(['  a ', '', 'BC', 'bc']) == ['# ', '#B', '#b']\nassert op_sortalpha_firstchar_prefixup(['one', 'one', 'Two']) == ['#T', '#o', '#o']\nassert op_sortalpha_firstchar_prefixup(['x']) == ['#x']\nassert op_sortalpha_firstchar_prefixup(['abc', 'de', '']) == ['#a', '#d']"}
{"id": "op_odds_pos_issorted", "entry_point": "op_odds_pos_issorted", "primitives": ["odds", "pos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_odds_pos_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_odds_pos_issorted([1, 2, 3, 4]) == True\nassert op_odds_pos_issorted([]) == True\nassert op_odds_pos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_pos_issorted([5, 5, 5]) == True\nassert op_odds_pos_issorted([3, 1, 2]) == False\nassert op_odds_pos_issorted([10]) == True\nassert op_odds_pos_issorted([2, 4, 6]) == True\nassert op_odds_pos_issorted([-7, 12, -7]) == True"}
{"id": "op_inc_rev_square", "entry_point": "op_inc_rev_square", "primitives": ["inc", "rev", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then square each.", "solution": "def op_inc_rev_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_rev_square([1, 2, 3, 4]) == [25, 16, 9, 4]\nassert op_inc_rev_square([]) == []\nassert op_inc_rev_square([-2, -1, 0, 1, 2]) == [9, 4, 1, 0, 1]\nassert op_inc_rev_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_rev_square([3, 1, 2]) == [9, 4, 16]\nassert op_inc_rev_square([10]) == [121]\nassert op_inc_rev_square([2, 4, 6]) == [49, 25, 9]\nassert op_inc_rev_square([-7, 12, -7]) == [36, 169, 36]"}
{"id": "op_takewhilepos_odds_min", "entry_point": "op_takewhilepos_odds_min", "primitives": ["takewhilepos", "odds", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_odds_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_odds_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_odds_min([]) == 0\nassert op_takewhilepos_odds_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_odds_min([5, 5, 5]) == 5\nassert op_takewhilepos_odds_min([3, 1, 2]) == 1\nassert op_takewhilepos_odds_min([10]) == 0\nassert op_takewhilepos_odds_min([2, 4, 6]) == 0\nassert op_takewhilepos_odds_min([-7, 12, -7]) == 0"}
{"id": "op_clamp10_odds_beforezero", "entry_point": "op_clamp10_odds_beforezero", "primitives": ["clamp10", "odds", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then keep everything before the first zero.", "solution": "def op_clamp10_odds_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_odds_beforezero([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_odds_beforezero([]) == []\nassert op_clamp10_odds_beforezero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_odds_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_odds_beforezero([3, 1, 2]) == [3, 1]\nassert op_clamp10_odds_beforezero([10]) == []\nassert op_clamp10_odds_beforezero([2, 4, 6]) == []\nassert op_clamp10_odds_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_oremptyzero_issorted", "entry_point": "op_last3_oremptyzero_issorted", "primitives": ["last3", "oremptyzero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return whether the list is sorted ascending.", "solution": "def op_last3_oremptyzero_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return r == sorted(r)", "tests": "assert op_last3_oremptyzero_issorted([1, 2, 3, 4]) == True\nassert op_last3_oremptyzero_issorted([]) == True\nassert op_last3_oremptyzero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_oremptyzero_issorted([5, 5, 5]) == True\nassert op_last3_oremptyzero_issorted([3, 1, 2]) == False\nassert op_last3_oremptyzero_issorted([10]) == True\nassert op_last3_oremptyzero_issorted([2, 4, 6]) == True\nassert op_last3_oremptyzero_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_oremptyzero_haszero", "entry_point": "op_dropzeros_oremptyzero_haszero", "primitives": ["dropzeros", "oremptyzero", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_dropzeros_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_dropzeros_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_oremptyzero_haszero([]) == True\nassert op_dropzeros_oremptyzero_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_oremptyzero_haszero([5, 5, 5]) == False\nassert op_dropzeros_oremptyzero_haszero([3, 1, 2]) == False\nassert op_dropzeros_oremptyzero_haszero([10]) == False\nassert op_dropzeros_oremptyzero_haszero([2, 4, 6]) == False\nassert op_dropzeros_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_dropfirst_add10", "entry_point": "op_takewhilepos_dropfirst_add10", "primitives": ["takewhilepos", "dropfirst", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element, then add ten to each.", "solution": "def op_takewhilepos_dropfirst_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_dropfirst_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_takewhilepos_dropfirst_add10([]) == []\nassert op_takewhilepos_dropfirst_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropfirst_add10([5, 5, 5]) == [15, 15]\nassert op_takewhilepos_dropfirst_add10([3, 1, 2]) == [11, 12]\nassert op_takewhilepos_dropfirst_add10([10]) == []\nassert op_takewhilepos_dropfirst_add10([2, 4, 6]) == [14, 16]\nassert op_takewhilepos_dropfirst_add10([-7, 12, -7]) == []"}
{"id": "op_sorta_padto3_counteven", "entry_point": "op_sorta_padto3_counteven", "primitives": ["sorta", "padto3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_sorta_padto3_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_padto3_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_padto3_counteven([]) == 3\nassert op_sorta_padto3_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_padto3_counteven([5, 5, 5]) == 0\nassert op_sorta_padto3_counteven([3, 1, 2]) == 1\nassert op_sorta_padto3_counteven([10]) == 3\nassert op_sorta_padto3_counteven([2, 4, 6]) == 3\nassert op_sorta_padto3_counteven([-7, 12, -7]) == 1"}
{"id": "op_inc_gt5_dropfirst", "entry_point": "op_inc_gt5_dropfirst", "primitives": ["inc", "gt5", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then drop the first element.", "solution": "def op_inc_gt5_dropfirst(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_inc_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_inc_gt5_dropfirst([]) == []\nassert op_inc_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5_dropfirst([5, 5, 5]) == [6, 6]\nassert op_inc_gt5_dropfirst([3, 1, 2]) == []\nassert op_inc_gt5_dropfirst([10]) == []\nassert op_inc_gt5_dropfirst([2, 4, 6]) == []\nassert op_inc_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_last3_takewhilepos_trimends", "entry_point": "op_last3_takewhilepos_trimends", "primitives": ["last3", "takewhilepos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then drop the first and last elements.", "solution": "def op_last3_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_takewhilepos_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_takewhilepos_trimends([]) == []\nassert op_last3_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos_trimends([5, 5, 5]) == [5]\nassert op_last3_takewhilepos_trimends([3, 1, 2]) == [1]\nassert op_last3_takewhilepos_trimends([10]) == []\nassert op_last3_takewhilepos_trimends([2, 4, 6]) == [4]\nassert op_last3_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_clamp10_beforezero_absval", "entry_point": "op_clamp10_beforezero_absval", "primitives": ["clamp10", "beforezero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_clamp10_beforezero_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_beforezero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_beforezero_absval([]) == []\nassert op_clamp10_beforezero_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_beforezero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_beforezero_absval([10]) == [10]\nassert op_clamp10_beforezero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_beforezero_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_rev_beforezero_padto3", "entry_point": "op_rev_beforezero_padto3", "primitives": ["rev", "beforezero", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then pad with zeros to at least three elements.", "solution": "def op_rev_beforezero_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_beforezero_padto3([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_padto3([]) == [0, 0, 0]\nassert op_rev_beforezero_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_beforezero_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_padto3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_padto3([10]) == [10, 0, 0]\nassert op_rev_beforezero_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sortabs_neg_clamp10", "entry_point": "op_sortabs_neg_clamp10", "primitives": ["sortabs", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then cap each value at 10.", "solution": "def op_sortabs_neg_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_neg_clamp10([1, 2, 3, 4]) == []\nassert op_sortabs_neg_clamp10([]) == []\nassert op_sortabs_neg_clamp10([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_neg_clamp10([5, 5, 5]) == []\nassert op_sortabs_neg_clamp10([3, 1, 2]) == []\nassert op_sortabs_neg_clamp10([10]) == []\nassert op_sortabs_neg_clamp10([2, 4, 6]) == []\nassert op_sortabs_neg_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_add10_sorta", "entry_point": "op_beforezero_add10_sorta", "primitives": ["beforezero", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then sort ascending.", "solution": "def op_beforezero_add10_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_add10_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_beforezero_add10_sorta([]) == []\nassert op_beforezero_add10_sorta([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_beforezero_add10_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_add10_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_beforezero_add10_sorta([10]) == [20]\nassert op_beforezero_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_beforezero_add10_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_dropwhileneg_pos_allpos", "entry_point": "op_dropwhileneg_pos_allpos", "primitives": ["dropwhileneg", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_dropwhileneg_pos_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_pos_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_pos_allpos([]) == True\nassert op_dropwhileneg_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_pos_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_pos_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_pos_allpos([10]) == True\nassert op_dropwhileneg_pos_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_odds_dec_gt5", "entry_point": "op_odds_dec_gt5", "primitives": ["odds", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each, then keep values greater than five.", "solution": "def op_odds_dec_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_dec_gt5([1, 2, 3, 4]) == []\nassert op_odds_dec_gt5([]) == []\nassert op_odds_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_dec_gt5([5, 5, 5]) == []\nassert op_odds_dec_gt5([3, 1, 2]) == []\nassert op_odds_dec_gt5([10]) == []\nassert op_odds_dec_gt5([2, 4, 6]) == []\nassert op_odds_dec_gt5([-7, 12, -7]) == []"}
{"id": "op_gt5_div3_len", "entry_point": "op_gt5_div3_len", "primitives": ["gt5", "div3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then return how many remain.", "solution": "def op_gt5_div3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_gt5_div3_len([1, 2, 3, 4]) == 0\nassert op_gt5_div3_len([]) == 0\nassert op_gt5_div3_len([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_div3_len([5, 5, 5]) == 0\nassert op_gt5_div3_len([3, 1, 2]) == 0\nassert op_gt5_div3_len([10]) == 0\nassert op_gt5_div3_len([2, 4, 6]) == 1\nassert op_gt5_div3_len([-7, 12, -7]) == 1"}
{"id": "op_rev_clamp10_sortd", "entry_point": "op_rev_clamp10_sortd", "primitives": ["rev", "clamp10", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then sort descending.", "solution": "def op_rev_clamp10_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_clamp10_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_clamp10_sortd([]) == []\nassert op_rev_clamp10_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_clamp10_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_rev_clamp10_sortd([10]) == [10]\nassert op_rev_clamp10_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_rev_clamp10_sortd([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_dropwhileneg_negate_odds", "entry_point": "op_dropwhileneg_negate_odds", "primitives": ["dropwhileneg", "negate", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then keep the odd numbers.", "solution": "def op_dropwhileneg_negate_odds(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropwhileneg_negate_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_dropwhileneg_negate_odds([]) == []\nassert op_dropwhileneg_negate_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropwhileneg_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_dropwhileneg_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_dropwhileneg_negate_odds([10]) == []\nassert op_dropwhileneg_negate_odds([2, 4, 6]) == []\nassert op_dropwhileneg_negate_odds([-7, 12, -7]) == [7]"}
{"id": "op_dropzeros_trimends_evens", "entry_point": "op_dropzeros_trimends_evens", "primitives": ["dropzeros", "trimends", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first and last elements, then keep the even numbers.", "solution": "def op_dropzeros_trimends_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropzeros_trimends_evens([1, 2, 3, 4]) == [2]\nassert op_dropzeros_trimends_evens([]) == []\nassert op_dropzeros_trimends_evens([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_trimends_evens([5, 5, 5]) == []\nassert op_dropzeros_trimends_evens([3, 1, 2]) == []\nassert op_dropzeros_trimends_evens([10]) == []\nassert op_dropzeros_trimends_evens([2, 4, 6]) == [4]\nassert op_dropzeros_trimends_evens([-7, 12, -7]) == [12]"}
{"id": "op_last3_pos_square", "entry_point": "op_last3_pos_square", "primitives": ["last3", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers, then square each.", "solution": "def op_last3_pos_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_pos_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_pos_square([]) == []\nassert op_last3_pos_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_last3_pos_square([5, 5, 5]) == [25, 25, 25]\nassert op_last3_pos_square([3, 1, 2]) == [9, 1, 4]\nassert op_last3_pos_square([10]) == [100]\nassert op_last3_pos_square([2, 4, 6]) == [4, 16, 36]\nassert op_last3_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_trimends_absval_uniq", "entry_point": "op_trimends_absval_uniq", "primitives": ["trimends", "absval", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_trimends_absval_uniq(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_trimends_absval_uniq([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_absval_uniq([]) == []\nassert op_trimends_absval_uniq([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_trimends_absval_uniq([5, 5, 5]) == [5]\nassert op_trimends_absval_uniq([3, 1, 2]) == [1]\nassert op_trimends_absval_uniq([10]) == []\nassert op_trimends_absval_uniq([2, 4, 6]) == [4]\nassert op_trimends_absval_uniq([-7, 12, -7]) == [12]"}
{"id": "op_evens_sortd_len", "entry_point": "op_evens_sortd_len", "primitives": ["evens", "sortd", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then return how many remain.", "solution": "def op_evens_sortd_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return len(r)", "tests": "assert op_evens_sortd_len([1, 2, 3, 4]) == 2\nassert op_evens_sortd_len([]) == 0\nassert op_evens_sortd_len([-2, -1, 0, 1, 2]) == 3\nassert op_evens_sortd_len([5, 5, 5]) == 0\nassert op_evens_sortd_len([3, 1, 2]) == 1\nassert op_evens_sortd_len([10]) == 1\nassert op_evens_sortd_len([2, 4, 6]) == 3\nassert op_evens_sortd_len([-7, 12, -7]) == 1"}
{"id": "op_sortd_rev_firsteven", "entry_point": "op_sortd_rev_firsteven", "primitives": ["sortd", "rev", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then reverse the order, then return the first even value (0 if none).", "solution": "def op_sortd_rev_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortd_rev_firsteven([1, 2, 3, 4]) == 2\nassert op_sortd_rev_firsteven([]) == 0\nassert op_sortd_rev_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sortd_rev_firsteven([5, 5, 5]) == 0\nassert op_sortd_rev_firsteven([3, 1, 2]) == 2\nassert op_sortd_rev_firsteven([10]) == 10\nassert op_sortd_rev_firsteven([2, 4, 6]) == 2\nassert op_sortd_rev_firsteven([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_first3_odds", "entry_point": "op_takewhilepos_first3_odds", "primitives": ["takewhilepos", "first3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then keep the odd numbers.", "solution": "def op_takewhilepos_first3_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_first3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_takewhilepos_first3_odds([]) == []\nassert op_takewhilepos_first3_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3_odds([3, 1, 2]) == [3, 1]\nassert op_takewhilepos_first3_odds([10]) == []\nassert op_takewhilepos_first3_odds([2, 4, 6]) == []\nassert op_takewhilepos_first3_odds([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dropwhileneg_allpos", "entry_point": "op_takewhilepos_dropwhileneg_allpos", "primitives": ["takewhilepos", "dropwhileneg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then return whether all values are positive.", "solution": "def op_takewhilepos_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_dropwhileneg_allpos([1, 2, 3, 4]) == True\nassert op_takewhilepos_dropwhileneg_allpos([]) == True\nassert op_takewhilepos_dropwhileneg_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_dropwhileneg_allpos([5, 5, 5]) == True\nassert op_takewhilepos_dropwhileneg_allpos([3, 1, 2]) == True\nassert op_takewhilepos_dropwhileneg_allpos([10]) == True\nassert op_takewhilepos_dropwhileneg_allpos([2, 4, 6]) == True\nassert op_takewhilepos_dropwhileneg_allpos([-7, 12, -7]) == True"}
{"id": "op_dropfirst_add10_rev", "entry_point": "op_dropfirst_add10_rev", "primitives": ["dropfirst", "add10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then reverse the order.", "solution": "def op_dropfirst_add10_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_add10_rev([1, 2, 3, 4]) == [14, 13, 12]\nassert op_dropfirst_add10_rev([]) == []\nassert op_dropfirst_add10_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9]\nassert op_dropfirst_add10_rev([5, 5, 5]) == [15, 15]\nassert op_dropfirst_add10_rev([3, 1, 2]) == [12, 11]\nassert op_dropfirst_add10_rev([10]) == []\nassert op_dropfirst_add10_rev([2, 4, 6]) == [16, 14]\nassert op_dropfirst_add10_rev([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropzeros_rev_sortd", "entry_point": "op_dropzeros_rev_sortd", "primitives": ["dropzeros", "rev", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then sort descending.", "solution": "def op_dropzeros_rev_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_rev_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_rev_sortd([]) == []\nassert op_dropzeros_rev_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_rev_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_rev_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_rev_sortd([10]) == [10]\nassert op_dropzeros_rev_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_rev_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_dropfirst_gt5_odds", "entry_point": "op_dropfirst_gt5_odds", "primitives": ["dropfirst", "gt5", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep values greater than five, then keep the odd numbers.", "solution": "def op_dropfirst_gt5_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_gt5_odds([1, 2, 3, 4]) == []\nassert op_dropfirst_gt5_odds([]) == []\nassert op_dropfirst_gt5_odds([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_gt5_odds([5, 5, 5]) == []\nassert op_dropfirst_gt5_odds([3, 1, 2]) == []\nassert op_dropfirst_gt5_odds([10]) == []\nassert op_dropfirst_gt5_odds([2, 4, 6]) == []\nassert op_dropfirst_gt5_odds([-7, 12, -7]) == []"}
{"id": "op_first3_sorta_counteven", "entry_point": "op_first3_sorta_counteven", "primitives": ["first3", "sorta", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then return how many values are even.", "solution": "def op_first3_sorta_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_sorta_counteven([1, 2, 3, 4]) == 1\nassert op_first3_sorta_counteven([]) == 0\nassert op_first3_sorta_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_sorta_counteven([5, 5, 5]) == 0\nassert op_first3_sorta_counteven([3, 1, 2]) == 1\nassert op_first3_sorta_counteven([10]) == 1\nassert op_first3_sorta_counteven([2, 4, 6]) == 3\nassert op_first3_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_last3_gt5", "entry_point": "op_clamp10_last3_gt5", "primitives": ["clamp10", "last3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three, then keep values greater than five.", "solution": "def op_clamp10_last3_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_last3_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_last3_gt5([]) == []\nassert op_clamp10_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_last3_gt5([5, 5, 5]) == []\nassert op_clamp10_last3_gt5([3, 1, 2]) == []\nassert op_clamp10_last3_gt5([10]) == [10]\nassert op_clamp10_last3_gt5([2, 4, 6]) == [6]\nassert op_clamp10_last3_gt5([-7, 12, -7]) == [10]"}
{"id": "op_rev_negate_padto3", "entry_point": "op_rev_negate_padto3", "primitives": ["rev", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then pad with zeros to at least three elements.", "solution": "def op_rev_negate_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_negate_padto3([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_rev_negate_padto3([]) == [0, 0, 0]\nassert op_rev_negate_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_negate_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_negate_padto3([3, 1, 2]) == [-2, -1, -3]\nassert op_rev_negate_padto3([10]) == [-10, 0, 0]\nassert op_rev_negate_padto3([2, 4, 6]) == [-6, -4, -2]\nassert op_rev_negate_padto3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_clamp10_square_first3", "entry_point": "op_clamp10_square_first3", "primitives": ["clamp10", "square", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then keep only the first three.", "solution": "def op_clamp10_square_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_square_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_clamp10_square_first3([]) == []\nassert op_clamp10_square_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_clamp10_square_first3([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square_first3([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_square_first3([10]) == [100]\nassert op_clamp10_square_first3([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_square_first3([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_dropzeros_double_prod", "entry_point": "op_dropzeros_double_prod", "primitives": ["dropzeros", "double", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then return their product.", "solution": "def op_dropzeros_double_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_dropzeros_double_prod([1, 2, 3, 4]) == 384\nassert op_dropzeros_double_prod([]) == 1\nassert op_dropzeros_double_prod([-2, -1, 0, 1, 2]) == 64\nassert op_dropzeros_double_prod([5, 5, 5]) == 1000\nassert op_dropzeros_double_prod([3, 1, 2]) == 48\nassert op_dropzeros_double_prod([10]) == 20\nassert op_dropzeros_double_prod([2, 4, 6]) == 384\nassert op_dropzeros_double_prod([-7, 12, -7]) == 4704"}
{"id": "op_div3_negate_sorta", "entry_point": "op_div3_negate_sorta", "primitives": ["div3", "negate", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then sort ascending.", "solution": "def op_div3_negate_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_negate_sorta([1, 2, 3, 4]) == [-3]\nassert op_div3_negate_sorta([]) == []\nassert op_div3_negate_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_negate_sorta([5, 5, 5]) == []\nassert op_div3_negate_sorta([3, 1, 2]) == [-3]\nassert op_div3_negate_sorta([10]) == []\nassert op_div3_negate_sorta([2, 4, 6]) == [-6]\nassert op_div3_negate_sorta([-7, 12, -7]) == [-12]"}
{"id": "op_absval_first3_takewhilepos", "entry_point": "op_absval_first3_takewhilepos", "primitives": ["absval", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then take values while they are positive.", "solution": "def op_absval_first3_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_first3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_first3_takewhilepos([]) == []\nassert op_absval_first3_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_absval_first3_takewhilepos([10]) == [10]\nassert op_absval_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_first3_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_padto3_oremptyzero_evens", "entry_point": "op_padto3_oremptyzero_evens", "primitives": ["padto3", "oremptyzero", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_padto3_oremptyzero_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_oremptyzero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_oremptyzero_evens([]) == [0, 0, 0]\nassert op_padto3_oremptyzero_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_padto3_oremptyzero_evens([5, 5, 5]) == []\nassert op_padto3_oremptyzero_evens([3, 1, 2]) == [2]\nassert op_padto3_oremptyzero_evens([10]) == [10, 0, 0]\nassert op_padto3_oremptyzero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_oremptyzero_evens([-7, 12, -7]) == [12]"}
{"id": "op_div3_sortd_min", "entry_point": "op_div3_sortd_min", "primitives": ["div3", "sortd", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending, then return the minimum (0 if empty).", "solution": "def op_div3_sortd_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_div3_sortd_min([1, 2, 3, 4]) == 3\nassert op_div3_sortd_min([]) == 0\nassert op_div3_sortd_min([-2, -1, 0, 1, 2]) == 0\nassert op_div3_sortd_min([5, 5, 5]) == 0\nassert op_div3_sortd_min([3, 1, 2]) == 3\nassert op_div3_sortd_min([10]) == 0\nassert op_div3_sortd_min([2, 4, 6]) == 6\nassert op_div3_sortd_min([-7, 12, -7]) == 12"}
{"id": "op_pos_add10_dropfirst", "entry_point": "op_pos_add10_dropfirst", "primitives": ["pos", "add10", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add ten to each, then drop the first element.", "solution": "def op_pos_add10_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_pos_add10_dropfirst([1, 2, 3, 4]) == [12, 13, 14]\nassert op_pos_add10_dropfirst([]) == []\nassert op_pos_add10_dropfirst([-2, -1, 0, 1, 2]) == [12]\nassert op_pos_add10_dropfirst([5, 5, 5]) == [15, 15]\nassert op_pos_add10_dropfirst([3, 1, 2]) == [11, 12]\nassert op_pos_add10_dropfirst([10]) == []\nassert op_pos_add10_dropfirst([2, 4, 6]) == [14, 16]\nassert op_pos_add10_dropfirst([-7, 12, -7]) == []"}
{"id": "op_prefixup_strip_firstchar", "entry_point": "op_prefixup_strip_firstchar", "primitives": ["prefixup", "strip", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then trim whitespace from each, then keep the first character of each (dropping empties).", "solution": "def op_prefixup_strip_firstchar(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_prefixup_strip_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_prefixup_strip_firstchar([]) == []\nassert op_prefixup_strip_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_prefixup_strip_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_prefixup_strip_firstchar(['x']) == ['#']\nassert op_prefixup_strip_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_double_last3_takewhilepos", "entry_point": "op_double_last3_takewhilepos", "primitives": ["double", "last3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three, then take values while they are positive.", "solution": "def op_double_last3_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_last3_takewhilepos([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_last3_takewhilepos([]) == []\nassert op_double_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_last3_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_double_last3_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_last3_takewhilepos([10]) == [20]\nassert op_double_last3_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_last3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropzeros_last3_alldistinct", "entry_point": "op_dropzeros_last3_alldistinct", "primitives": ["dropzeros", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then return whether all values are distinct.", "solution": "def op_dropzeros_last3_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_dropzeros_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_dropzeros_last3_alldistinct([]) == True\nassert op_dropzeros_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_last3_alldistinct([5, 5, 5]) == False\nassert op_dropzeros_last3_alldistinct([3, 1, 2]) == True\nassert op_dropzeros_last3_alldistinct([10]) == True\nassert op_dropzeros_last3_alldistinct([2, 4, 6]) == True\nassert op_dropzeros_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_oremptyzero_negate", "entry_point": "op_last3_oremptyzero_negate", "primitives": ["last3", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then negate each.", "solution": "def op_last3_oremptyzero_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_oremptyzero_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_oremptyzero_negate([]) == [0]\nassert op_last3_oremptyzero_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_oremptyzero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_oremptyzero_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_last3_oremptyzero_negate([10]) == [-10]\nassert op_last3_oremptyzero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_oremptyzero_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_trimends_odds_div3", "entry_point": "op_trimends_odds_div3", "primitives": ["trimends", "odds", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the odd numbers, then keep multiples of three.", "solution": "def op_trimends_odds_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_odds_div3([1, 2, 3, 4]) == [3]\nassert op_trimends_odds_div3([]) == []\nassert op_trimends_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_trimends_odds_div3([5, 5, 5]) == []\nassert op_trimends_odds_div3([3, 1, 2]) == []\nassert op_trimends_odds_div3([10]) == []\nassert op_trimends_odds_div3([2, 4, 6]) == []\nassert op_trimends_odds_div3([-7, 12, -7]) == []"}
{"id": "op_rev_trimends_negate", "entry_point": "op_rev_trimends_negate", "primitives": ["rev", "trimends", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then negate each.", "solution": "def op_rev_trimends_negate(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_rev_trimends_negate([1, 2, 3, 4]) == [-3, -2]\nassert op_rev_trimends_negate([]) == []\nassert op_rev_trimends_negate([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_rev_trimends_negate([5, 5, 5]) == [-5]\nassert op_rev_trimends_negate([3, 1, 2]) == [-1]\nassert op_rev_trimends_negate([10]) == []\nassert op_rev_trimends_negate([2, 4, 6]) == [-4]\nassert op_rev_trimends_negate([-7, 12, -7]) == [-12]"}
{"id": "op_odds_evens_double", "entry_point": "op_odds_evens_double", "primitives": ["odds", "evens", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then double each.", "solution": "def op_odds_evens_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_evens_double([1, 2, 3, 4]) == []\nassert op_odds_evens_double([]) == []\nassert op_odds_evens_double([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_double([5, 5, 5]) == []\nassert op_odds_evens_double([3, 1, 2]) == []\nassert op_odds_evens_double([10]) == []\nassert op_odds_evens_double([2, 4, 6]) == []\nassert op_odds_evens_double([-7, 12, -7]) == []"}
{"id": "op_dec_last3_padto3", "entry_point": "op_dec_last3_padto3", "primitives": ["dec", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_dec_last3_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_last3_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_last3_padto3([]) == [0, 0, 0]\nassert op_dec_last3_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_dec_last3_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_last3_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_last3_padto3([10]) == [9, 0, 0]\nassert op_dec_last3_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_last3_padto3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_div3_inc_trimends", "entry_point": "op_div3_inc_trimends", "primitives": ["div3", "inc", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then drop the first and last elements.", "solution": "def op_div3_inc_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_inc_trimends([1, 2, 3, 4]) == []\nassert op_div3_inc_trimends([]) == []\nassert op_div3_inc_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_inc_trimends([5, 5, 5]) == []\nassert op_div3_inc_trimends([3, 1, 2]) == []\nassert op_div3_inc_trimends([10]) == []\nassert op_div3_inc_trimends([2, 4, 6]) == []\nassert op_div3_inc_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_dec_square", "entry_point": "op_add10_dec_square", "primitives": ["add10", "dec", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then square each.", "solution": "def op_add10_dec_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_dec_square([1, 2, 3, 4]) == [100, 121, 144, 169]\nassert op_add10_dec_square([]) == []\nassert op_add10_dec_square([-2, -1, 0, 1, 2]) == [49, 64, 81, 100, 121]\nassert op_add10_dec_square([5, 5, 5]) == [196, 196, 196]\nassert op_add10_dec_square([3, 1, 2]) == [144, 100, 121]\nassert op_add10_dec_square([10]) == [361]\nassert op_add10_dec_square([2, 4, 6]) == [121, 169, 225]\nassert op_add10_dec_square([-7, 12, -7]) == [4, 441, 4]"}
{"id": "op_evens_pos_allpos", "entry_point": "op_evens_pos_allpos", "primitives": ["evens", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_evens_pos_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_pos_allpos([1, 2, 3, 4]) == True\nassert op_evens_pos_allpos([]) == True\nassert op_evens_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_evens_pos_allpos([5, 5, 5]) == True\nassert op_evens_pos_allpos([3, 1, 2]) == True\nassert op_evens_pos_allpos([10]) == True\nassert op_evens_pos_allpos([2, 4, 6]) == True\nassert op_evens_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_dropzeros_gt5", "entry_point": "op_oremptyzero_dropzeros_gt5", "primitives": ["oremptyzero", "dropzeros", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then keep values greater than five.", "solution": "def op_oremptyzero_dropzeros_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_oremptyzero_dropzeros_gt5([]) == []\nassert op_oremptyzero_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_dropzeros_gt5([5, 5, 5]) == []\nassert op_oremptyzero_dropzeros_gt5([3, 1, 2]) == []\nassert op_oremptyzero_dropzeros_gt5([10]) == [10]\nassert op_oremptyzero_dropzeros_gt5([2, 4, 6]) == [6]\nassert op_oremptyzero_dropzeros_gt5([-7, 12, -7]) == [12]"}
{"id": "op_gt5_dropfirst_len", "entry_point": "op_gt5_dropfirst_len", "primitives": ["gt5", "dropfirst", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then return how many remain.", "solution": "def op_gt5_dropfirst_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return len(r)", "tests": "assert op_gt5_dropfirst_len([1, 2, 3, 4]) == 0\nassert op_gt5_dropfirst_len([]) == 0\nassert op_gt5_dropfirst_len([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_dropfirst_len([5, 5, 5]) == 0\nassert op_gt5_dropfirst_len([3, 1, 2]) == 0\nassert op_gt5_dropfirst_len([10]) == 0\nassert op_gt5_dropfirst_len([2, 4, 6]) == 0\nassert op_gt5_dropfirst_len([-7, 12, -7]) == 0"}
{"id": "op_trimends_pos_allpos", "entry_point": "op_trimends_pos_allpos", "primitives": ["trimends", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_trimends_pos_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_pos_allpos([1, 2, 3, 4]) == True\nassert op_trimends_pos_allpos([]) == True\nassert op_trimends_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_trimends_pos_allpos([5, 5, 5]) == True\nassert op_trimends_pos_allpos([3, 1, 2]) == True\nassert op_trimends_pos_allpos([10]) == True\nassert op_trimends_pos_allpos([2, 4, 6]) == True\nassert op_trimends_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_rev_double_pos", "entry_point": "op_rev_double_pos", "primitives": ["rev", "double", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then keep the positive numbers.", "solution": "def op_rev_double_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_double_pos([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_pos([]) == []\nassert op_rev_double_pos([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_rev_double_pos([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_pos([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_pos([10]) == [20]\nassert op_rev_double_pos([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_square_first3_add10", "entry_point": "op_square_first3_add10", "primitives": ["square", "first3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then add ten to each.", "solution": "def op_square_first3_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_first3_add10([1, 2, 3, 4]) == [11, 14, 19]\nassert op_square_first3_add10([]) == []\nassert op_square_first3_add10([-2, -1, 0, 1, 2]) == [14, 11, 10]\nassert op_square_first3_add10([5, 5, 5]) == [35, 35, 35]\nassert op_square_first3_add10([3, 1, 2]) == [19, 11, 14]\nassert op_square_first3_add10([10]) == [110]\nassert op_square_first3_add10([2, 4, 6]) == [14, 26, 46]\nassert op_square_first3_add10([-7, 12, -7]) == [59, 154, 59]"}
{"id": "op_odds_pos_div3", "entry_point": "op_odds_pos_div3", "primitives": ["odds", "pos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then keep multiples of three.", "solution": "def op_odds_pos_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_pos_div3([1, 2, 3, 4]) == [3]\nassert op_odds_pos_div3([]) == []\nassert op_odds_pos_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_pos_div3([5, 5, 5]) == []\nassert op_odds_pos_div3([3, 1, 2]) == [3]\nassert op_odds_pos_div3([10]) == []\nassert op_odds_pos_div3([2, 4, 6]) == []\nassert op_odds_pos_div3([-7, 12, -7]) == []"}
{"id": "op_inc_clamp10_trimends", "entry_point": "op_inc_clamp10_trimends", "primitives": ["inc", "clamp10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then drop the first and last elements.", "solution": "def op_inc_clamp10_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_clamp10_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_inc_clamp10_trimends([]) == []\nassert op_inc_clamp10_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_clamp10_trimends([5, 5, 5]) == [6]\nassert op_inc_clamp10_trimends([3, 1, 2]) == [2]\nassert op_inc_clamp10_trimends([10]) == []\nassert op_inc_clamp10_trimends([2, 4, 6]) == [5]\nassert op_inc_clamp10_trimends([-7, 12, -7]) == [10]"}
{"id": "op_square_takewhilepos_pos", "entry_point": "op_square_takewhilepos_pos", "primitives": ["square", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then keep the positive numbers.", "solution": "def op_square_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_takewhilepos_pos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos_pos([]) == []\nassert op_square_takewhilepos_pos([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_takewhilepos_pos([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_pos([3, 1, 2]) == [9, 1, 4]\nassert op_square_takewhilepos_pos([10]) == [100]\nassert op_square_takewhilepos_pos([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_pos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_last3_beforezero_prod", "entry_point": "op_last3_beforezero_prod", "primitives": ["last3", "beforezero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then return their product.", "solution": "def op_last3_beforezero_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_last3_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_last3_beforezero_prod([]) == 1\nassert op_last3_beforezero_prod([-2, -1, 0, 1, 2]) == 1\nassert op_last3_beforezero_prod([5, 5, 5]) == 125\nassert op_last3_beforezero_prod([3, 1, 2]) == 6\nassert op_last3_beforezero_prod([10]) == 10\nassert op_last3_beforezero_prod([2, 4, 6]) == 48\nassert op_last3_beforezero_prod([-7, 12, -7]) == 588"}
{"id": "op_odds_negate_beforezero", "entry_point": "op_odds_negate_beforezero", "primitives": ["odds", "negate", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each, then keep everything before the first zero.", "solution": "def op_odds_negate_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_odds_negate_beforezero([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_negate_beforezero([]) == []\nassert op_odds_negate_beforezero([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_negate_beforezero([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_negate_beforezero([3, 1, 2]) == [-3, -1]\nassert op_odds_negate_beforezero([10]) == []\nassert op_odds_negate_beforezero([2, 4, 6]) == []\nassert op_odds_negate_beforezero([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_evens_last3", "entry_point": "op_ages_evens_last3", "primitives": ["ages", "evens", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then keep only the last three.", "solution": "def op_ages_evens_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_evens_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_evens_last3([]) == []\nassert op_ages_evens_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens_last3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_clamp10_neg_padto3", "entry_point": "op_clamp10_neg_padto3", "primitives": ["clamp10", "neg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_clamp10_neg_padto3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_clamp10_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_clamp10_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([10]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_clamp10_neg_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_clamp10_sortabs_firsteven", "entry_point": "op_clamp10_sortabs_firsteven", "primitives": ["clamp10", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_clamp10_sortabs_firsteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_clamp10_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_clamp10_sortabs_firsteven([]) == 0\nassert op_clamp10_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_sortabs_firsteven([5, 5, 5]) == 0\nassert op_clamp10_sortabs_firsteven([3, 1, 2]) == 2\nassert op_clamp10_sortabs_firsteven([10]) == 10\nassert op_clamp10_sortabs_firsteven([2, 4, 6]) == 2\nassert op_clamp10_sortabs_firsteven([-7, 12, -7]) == 10"}
{"id": "op_negate_sorta_len", "entry_point": "op_negate_sorta_len", "primitives": ["negate", "sorta", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then return how many remain.", "solution": "def op_negate_sorta_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    return len(r)", "tests": "assert op_negate_sorta_len([1, 2, 3, 4]) == 4\nassert op_negate_sorta_len([]) == 0\nassert op_negate_sorta_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_sorta_len([5, 5, 5]) == 3\nassert op_negate_sorta_len([3, 1, 2]) == 3\nassert op_negate_sorta_len([10]) == 1\nassert op_negate_sorta_len([2, 4, 6]) == 3\nassert op_negate_sorta_len([-7, 12, -7]) == 3"}
{"id": "op_pos_uniq_sortabs", "entry_point": "op_pos_uniq_sortabs", "primitives": ["pos", "uniq", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then sort by absolute value.", "solution": "def op_pos_uniq_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_pos_uniq_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_uniq_sortabs([]) == []\nassert op_pos_uniq_sortabs([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_uniq_sortabs([5, 5, 5]) == [5]\nassert op_pos_uniq_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_pos_uniq_sortabs([10]) == [10]\nassert op_pos_uniq_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_pos_uniq_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_div3_odds_negate", "entry_point": "op_div3_odds_negate", "primitives": ["div3", "odds", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then negate each.", "solution": "def op_div3_odds_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_div3_odds_negate([1, 2, 3, 4]) == [-3]\nassert op_div3_odds_negate([]) == []\nassert op_div3_odds_negate([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_negate([5, 5, 5]) == []\nassert op_div3_odds_negate([3, 1, 2]) == [-3]\nassert op_div3_odds_negate([10]) == []\nassert op_div3_odds_negate([2, 4, 6]) == []\nassert op_div3_odds_negate([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_trimends_odds", "entry_point": "op_takewhilepos_trimends_odds", "primitives": ["takewhilepos", "trimends", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then keep the odd numbers.", "solution": "def op_takewhilepos_trimends_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_trimends_odds([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_trimends_odds([]) == []\nassert op_takewhilepos_trimends_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_trimends_odds([5, 5, 5]) == [5]\nassert op_takewhilepos_trimends_odds([3, 1, 2]) == [1]\nassert op_takewhilepos_trimends_odds([10]) == []\nassert op_takewhilepos_trimends_odds([2, 4, 6]) == []\nassert op_takewhilepos_trimends_odds([-7, 12, -7]) == []"}
{"id": "op_pos_absval_add10", "entry_point": "op_pos_absval_add10", "primitives": ["pos", "absval", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then add ten to each.", "solution": "def op_pos_absval_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_absval_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_absval_add10([]) == []\nassert op_pos_absval_add10([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_absval_add10([5, 5, 5]) == [15, 15, 15]\nassert op_pos_absval_add10([3, 1, 2]) == [13, 11, 12]\nassert op_pos_absval_add10([10]) == [20]\nassert op_pos_absval_add10([2, 4, 6]) == [12, 14, 16]\nassert op_pos_absval_add10([-7, 12, -7]) == [22]"}
{"id": "op_rev_square_dec", "entry_point": "op_rev_square_dec", "primitives": ["rev", "square", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then subtract one from each.", "solution": "def op_rev_square_dec(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_rev_square_dec([1, 2, 3, 4]) == [15, 8, 3, 0]\nassert op_rev_square_dec([]) == []\nassert op_rev_square_dec([-2, -1, 0, 1, 2]) == [3, 0, -1, 0, 3]\nassert op_rev_square_dec([5, 5, 5]) == [24, 24, 24]\nassert op_rev_square_dec([3, 1, 2]) == [3, 0, 8]\nassert op_rev_square_dec([10]) == [99]\nassert op_rev_square_dec([2, 4, 6]) == [35, 15, 3]\nassert op_rev_square_dec([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_prefixup_sortlen_firstchar", "entry_point": "op_prefixup_sortlen_firstchar", "primitives": ["prefixup", "sortlen", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort by length, shortest first, then keep the first character of each (dropping empties).", "solution": "def op_prefixup_sortlen_firstchar(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_prefixup_sortlen_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_prefixup_sortlen_firstchar([]) == []\nassert op_prefixup_sortlen_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_prefixup_sortlen_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_prefixup_sortlen_firstchar(['x']) == ['#']\nassert op_prefixup_sortlen_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_upper_firstchar_sortlen", "entry_point": "op_upper_firstchar_sortlen", "primitives": ["upper", "firstchar", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then keep the first character of each (dropping empties), then sort by length, shortest first.", "solution": "def op_upper_firstchar_sortlen(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s[0] for s in r if s]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_upper_firstchar_sortlen(['Hello', 'world']) == ['H', 'W']\nassert op_upper_firstchar_sortlen([]) == []\nassert op_upper_firstchar_sortlen(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'B']\nassert op_upper_firstchar_sortlen(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_upper_firstchar_sortlen(['x']) == ['X']\nassert op_upper_firstchar_sortlen(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_add10_dropwhileneg_dec", "entry_point": "op_add10_dropwhileneg_dec", "primitives": ["add10", "dropwhileneg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then subtract one from each.", "solution": "def op_add10_dropwhileneg_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_dropwhileneg_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_dropwhileneg_dec([]) == []\nassert op_add10_dropwhileneg_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_dropwhileneg_dec([5, 5, 5]) == [14, 14, 14]\nassert op_add10_dropwhileneg_dec([3, 1, 2]) == [12, 10, 11]\nassert op_add10_dropwhileneg_dec([10]) == [19]\nassert op_add10_dropwhileneg_dec([2, 4, 6]) == [11, 13, 15]\nassert op_add10_dropwhileneg_dec([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_square_oremptyzero_trimends", "entry_point": "op_square_oremptyzero_trimends", "primitives": ["square", "oremptyzero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_square_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_square_oremptyzero_trimends([1, 2, 3, 4]) == [4, 9]\nassert op_square_oremptyzero_trimends([]) == []\nassert op_square_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_square_oremptyzero_trimends([5, 5, 5]) == [25]\nassert op_square_oremptyzero_trimends([3, 1, 2]) == [1]\nassert op_square_oremptyzero_trimends([10]) == []\nassert op_square_oremptyzero_trimends([2, 4, 6]) == [16]\nassert op_square_oremptyzero_trimends([-7, 12, -7]) == [144]"}
{"id": "op_sorta_padto3_haszero", "entry_point": "op_sorta_padto3_haszero", "primitives": ["sorta", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_sorta_padto3_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_sorta_padto3_haszero([1, 2, 3, 4]) == False\nassert op_sorta_padto3_haszero([]) == True\nassert op_sorta_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_padto3_haszero([5, 5, 5]) == False\nassert op_sorta_padto3_haszero([3, 1, 2]) == False\nassert op_sorta_padto3_haszero([10]) == True\nassert op_sorta_padto3_haszero([2, 4, 6]) == False\nassert op_sorta_padto3_haszero([-7, 12, -7]) == False"}
{"id": "op_double_sortabs_absval", "entry_point": "op_double_sortabs_absval", "primitives": ["double", "sortabs", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then take the absolute value of each.", "solution": "def op_double_sortabs_absval(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_double_sortabs_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_sortabs_absval([]) == []\nassert op_double_sortabs_absval([-2, -1, 0, 1, 2]) == [0, 2, 2, 4, 4]\nassert op_double_sortabs_absval([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortabs_absval([3, 1, 2]) == [2, 4, 6]\nassert op_double_sortabs_absval([10]) == [20]\nassert op_double_sortabs_absval([2, 4, 6]) == [4, 8, 12]\nassert op_double_sortabs_absval([-7, 12, -7]) == [14, 14, 24]"}
{"id": "op_rev_padto3_takewhilepos", "entry_point": "op_rev_padto3_takewhilepos", "primitives": ["rev", "padto3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_rev_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_padto3_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_padto3_takewhilepos([]) == []\nassert op_rev_padto3_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_padto3_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_padto3_takewhilepos([10]) == [10]\nassert op_rev_padto3_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_padto3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_gt5_pos_trimends", "entry_point": "op_gt5_pos_trimends", "primitives": ["gt5", "pos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_gt5_pos_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_pos_trimends([1, 2, 3, 4]) == []\nassert op_gt5_pos_trimends([]) == []\nassert op_gt5_pos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_trimends([5, 5, 5]) == []\nassert op_gt5_pos_trimends([3, 1, 2]) == []\nassert op_gt5_pos_trimends([10]) == []\nassert op_gt5_pos_trimends([2, 4, 6]) == []\nassert op_gt5_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_double_absval_takewhilepos", "entry_point": "op_double_absval_takewhilepos", "primitives": ["double", "absval", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then take values while they are positive.", "solution": "def op_double_absval_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_absval_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_absval_takewhilepos([]) == []\nassert op_double_absval_takewhilepos([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_double_absval_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_double_absval_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_absval_takewhilepos([10]) == [20]\nassert op_double_absval_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_absval_takewhilepos([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_add10_dropwhileneg_evens", "entry_point": "op_add10_dropwhileneg_evens", "primitives": ["add10", "dropwhileneg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then keep the even numbers.", "solution": "def op_add10_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_dropwhileneg_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_dropwhileneg_evens([]) == []\nassert op_add10_dropwhileneg_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_dropwhileneg_evens([5, 5, 5]) == []\nassert op_add10_dropwhileneg_evens([3, 1, 2]) == [12]\nassert op_add10_dropwhileneg_evens([10]) == [20]\nassert op_add10_dropwhileneg_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropwhileneg_evens([-7, 12, -7]) == [22]"}
{"id": "op_rev_add10_prod", "entry_point": "op_rev_add10_prod", "primitives": ["rev", "add10", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then return their product.", "solution": "def op_rev_add10_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_rev_add10_prod([1, 2, 3, 4]) == 24024\nassert op_rev_add10_prod([]) == 1\nassert op_rev_add10_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_rev_add10_prod([5, 5, 5]) == 3375\nassert op_rev_add10_prod([3, 1, 2]) == 1716\nassert op_rev_add10_prod([10]) == 20\nassert op_rev_add10_prod([2, 4, 6]) == 2688\nassert op_rev_add10_prod([-7, 12, -7]) == 198"}
{"id": "op_square_last3_dropzeros", "entry_point": "op_square_last3_dropzeros", "primitives": ["square", "last3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then drop the zeros.", "solution": "def op_square_last3_dropzeros(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_square_last3_dropzeros([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_last3_dropzeros([]) == []\nassert op_square_last3_dropzeros([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_square_last3_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_square_last3_dropzeros([3, 1, 2]) == [9, 1, 4]\nassert op_square_last3_dropzeros([10]) == [100]\nassert op_square_last3_dropzeros([2, 4, 6]) == [4, 16, 36]\nassert op_square_last3_dropzeros([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_last3_padto3_haszero", "entry_point": "op_last3_padto3_haszero", "primitives": ["last3", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_last3_padto3_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_last3_padto3_haszero([1, 2, 3, 4]) == False\nassert op_last3_padto3_haszero([]) == True\nassert op_last3_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_last3_padto3_haszero([5, 5, 5]) == False\nassert op_last3_padto3_haszero([3, 1, 2]) == False\nassert op_last3_padto3_haszero([10]) == True\nassert op_last3_padto3_haszero([2, 4, 6]) == False\nassert op_last3_padto3_haszero([-7, 12, -7]) == False"}
{"id": "op_dropzeros_double_sorta", "entry_point": "op_dropzeros_double_sorta", "primitives": ["dropzeros", "double", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then sort ascending.", "solution": "def op_dropzeros_double_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_double_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double_sorta([]) == []\nassert op_dropzeros_double_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_dropzeros_double_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_dropzeros_double_sorta([10]) == [20]\nassert op_dropzeros_double_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_double_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_rev_div3_clamp10", "entry_point": "op_rev_div3_clamp10", "primitives": ["rev", "div3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then cap each value at 10.", "solution": "def op_rev_div3_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_rev_div3_clamp10([]) == []\nassert op_rev_div3_clamp10([-2, -1, 0, 1, 2]) == [0]\nassert op_rev_div3_clamp10([5, 5, 5]) == []\nassert op_rev_div3_clamp10([3, 1, 2]) == [3]\nassert op_rev_div3_clamp10([10]) == []\nassert op_rev_div3_clamp10([2, 4, 6]) == [6]\nassert op_rev_div3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_ages_uniq_max", "entry_point": "op_ages_uniq_max", "primitives": ["ages", "uniq", "max"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_ages_uniq_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_ages_uniq_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_uniq_max([]) == 0\nassert op_ages_uniq_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_uniq_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_odds_pos_last3", "entry_point": "op_odds_pos_last3", "primitives": ["odds", "pos", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then keep only the last three.", "solution": "def op_odds_pos_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_odds_pos_last3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_pos_last3([]) == []\nassert op_odds_pos_last3([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_pos_last3([3, 1, 2]) == [3, 1]\nassert op_odds_pos_last3([10]) == []\nassert op_odds_pos_last3([2, 4, 6]) == []\nassert op_odds_pos_last3([-7, 12, -7]) == []"}
{"id": "op_padto3_pos_sorta", "entry_point": "op_padto3_pos_sorta", "primitives": ["padto3", "pos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then sort ascending.", "solution": "def op_padto3_pos_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_pos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_pos_sorta([]) == []\nassert op_padto3_pos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_pos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_pos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_pos_sorta([10]) == [10]\nassert op_padto3_pos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_pos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_uniq_issorted", "entry_point": "op_takewhilepos_uniq_issorted", "primitives": ["takewhilepos", "uniq", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_takewhilepos_uniq_issorted(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_takewhilepos_uniq_issorted([1, 2, 3, 4]) == True\nassert op_takewhilepos_uniq_issorted([]) == True\nassert op_takewhilepos_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_uniq_issorted([5, 5, 5]) == True\nassert op_takewhilepos_uniq_issorted([3, 1, 2]) == False\nassert op_takewhilepos_uniq_issorted([10]) == True\nassert op_takewhilepos_uniq_issorted([2, 4, 6]) == True\nassert op_takewhilepos_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_square_double", "entry_point": "op_uniq_square_double", "primitives": ["uniq", "square", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then double each.", "solution": "def op_uniq_square_double(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_uniq_square_double([1, 2, 3, 4]) == [2, 8, 18, 32]\nassert op_uniq_square_double([]) == []\nassert op_uniq_square_double([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_uniq_square_double([5, 5, 5]) == [50]\nassert op_uniq_square_double([3, 1, 2]) == [18, 2, 8]\nassert op_uniq_square_double([10]) == [200]\nassert op_uniq_square_double([2, 4, 6]) == [8, 32, 72]\nassert op_uniq_square_double([-7, 12, -7]) == [98, 288]"}
{"id": "op_sortabs_dropwhileneg_trimends", "entry_point": "op_sortabs_dropwhileneg_trimends", "primitives": ["sortabs", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_sortabs_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortabs_dropwhileneg_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sortabs_dropwhileneg_trimends([]) == []\nassert op_sortabs_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [-1, 1, -2]\nassert op_sortabs_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_sortabs_dropwhileneg_trimends([3, 1, 2]) == [2]\nassert op_sortabs_dropwhileneg_trimends([10]) == []\nassert op_sortabs_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_sortabs_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_beforezero_padto3_dec", "entry_point": "op_beforezero_padto3_dec", "primitives": ["beforezero", "padto3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then subtract one from each.", "solution": "def op_beforezero_padto3_dec(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_beforezero_padto3_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_beforezero_padto3_dec([]) == [-1, -1, -1]\nassert op_beforezero_padto3_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_beforezero_padto3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_padto3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_beforezero_padto3_dec([10]) == [9, -1, -1]\nassert op_beforezero_padto3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_padto3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_takewhilepos_pos_min", "entry_point": "op_takewhilepos_pos_min", "primitives": ["takewhilepos", "pos", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_pos_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_pos_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_pos_min([]) == 0\nassert op_takewhilepos_pos_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_pos_min([5, 5, 5]) == 5\nassert op_takewhilepos_pos_min([3, 1, 2]) == 1\nassert op_takewhilepos_pos_min([10]) == 10\nassert op_takewhilepos_pos_min([2, 4, 6]) == 2\nassert op_takewhilepos_pos_min([-7, 12, -7]) == 0"}
{"id": "op_beforezero_dropfirst_min", "entry_point": "op_beforezero_dropfirst_min", "primitives": ["beforezero", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_beforezero_dropfirst_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_beforezero_dropfirst_min([1, 2, 3, 4]) == 2\nassert op_beforezero_dropfirst_min([]) == 0\nassert op_beforezero_dropfirst_min([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_dropfirst_min([5, 5, 5]) == 5\nassert op_beforezero_dropfirst_min([3, 1, 2]) == 1\nassert op_beforezero_dropfirst_min([10]) == 0\nassert op_beforezero_dropfirst_min([2, 4, 6]) == 4\nassert op_beforezero_dropfirst_min([-7, 12, -7]) == -7"}
{"id": "op_takewhilepos_dropzeros_min", "entry_point": "op_takewhilepos_dropzeros_min", "primitives": ["takewhilepos", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_dropzeros_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_dropzeros_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_dropzeros_min([]) == 0\nassert op_takewhilepos_dropzeros_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropzeros_min([5, 5, 5]) == 5\nassert op_takewhilepos_dropzeros_min([3, 1, 2]) == 1\nassert op_takewhilepos_dropzeros_min([10]) == 10\nassert op_takewhilepos_dropzeros_min([2, 4, 6]) == 2\nassert op_takewhilepos_dropzeros_min([-7, 12, -7]) == 0"}
{"id": "op_inc_neg_sortabs", "entry_point": "op_inc_neg_sortabs", "primitives": ["inc", "neg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then sort by absolute value.", "solution": "def op_inc_neg_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_neg_sortabs([1, 2, 3, 4]) == []\nassert op_inc_neg_sortabs([]) == []\nassert op_inc_neg_sortabs([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_sortabs([5, 5, 5]) == []\nassert op_inc_neg_sortabs([3, 1, 2]) == []\nassert op_inc_neg_sortabs([10]) == []\nassert op_inc_neg_sortabs([2, 4, 6]) == []\nassert op_inc_neg_sortabs([-7, 12, -7]) == [-6, -6]"}
{"id": "op_odds_dropzeros_counteven", "entry_point": "op_odds_dropzeros_counteven", "primitives": ["odds", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros, then return how many values are even.", "solution": "def op_odds_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_odds_dropzeros_counteven([1, 2, 3, 4]) == 0\nassert op_odds_dropzeros_counteven([]) == 0\nassert op_odds_dropzeros_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_dropzeros_counteven([5, 5, 5]) == 0\nassert op_odds_dropzeros_counteven([3, 1, 2]) == 0\nassert op_odds_dropzeros_counteven([10]) == 0\nassert op_odds_dropzeros_counteven([2, 4, 6]) == 0\nassert op_odds_dropzeros_counteven([-7, 12, -7]) == 0"}
{"id": "op_beforezero_pos_uniq", "entry_point": "op_beforezero_pos_uniq", "primitives": ["beforezero", "pos", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_pos_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_pos_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_pos_uniq([]) == []\nassert op_beforezero_pos_uniq([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_pos_uniq([5, 5, 5]) == [5]\nassert op_beforezero_pos_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_pos_uniq([10]) == [10]\nassert op_beforezero_pos_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_pos_uniq([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_beforezero_firsteven", "entry_point": "op_dropzeros_beforezero_firsteven", "primitives": ["dropzeros", "beforezero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_dropzeros_beforezero_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_beforezero_firsteven([]) == 0\nassert op_dropzeros_beforezero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_beforezero_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_beforezero_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_beforezero_firsteven([10]) == 10\nassert op_dropzeros_beforezero_firsteven([2, 4, 6]) == 2\nassert op_dropzeros_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_inc_clamp10_odds", "entry_point": "op_inc_clamp10_odds", "primitives": ["inc", "clamp10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then keep the odd numbers.", "solution": "def op_inc_clamp10_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_clamp10_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_clamp10_odds([]) == []\nassert op_inc_clamp10_odds([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_inc_clamp10_odds([5, 5, 5]) == []\nassert op_inc_clamp10_odds([3, 1, 2]) == [3]\nassert op_inc_clamp10_odds([10]) == []\nassert op_inc_clamp10_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_clamp10_odds([-7, 12, -7]) == []"}
{"id": "op_clamp10_dropzeros_beforezero", "entry_point": "op_clamp10_dropzeros_beforezero", "primitives": ["clamp10", "dropzeros", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then keep everything before the first zero.", "solution": "def op_clamp10_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_dropzeros_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropzeros_beforezero([]) == []\nassert op_clamp10_dropzeros_beforezero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_clamp10_dropzeros_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropzeros_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropzeros_beforezero([10]) == [10]\nassert op_clamp10_dropzeros_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropzeros_beforezero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_odds_first3_issorted", "entry_point": "op_odds_first3_issorted", "primitives": ["odds", "first3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_odds_first3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_odds_first3_issorted([1, 2, 3, 4]) == True\nassert op_odds_first3_issorted([]) == True\nassert op_odds_first3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_first3_issorted([5, 5, 5]) == True\nassert op_odds_first3_issorted([3, 1, 2]) == False\nassert op_odds_first3_issorted([10]) == True\nassert op_odds_first3_issorted([2, 4, 6]) == True\nassert op_odds_first3_issorted([-7, 12, -7]) == True"}
{"id": "op_first3_last3_dropwhileneg", "entry_point": "op_first3_last3_dropwhileneg", "primitives": ["first3", "last3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then drop the leading negative values.", "solution": "def op_first3_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_last3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_last3_dropwhileneg([]) == []\nassert op_first3_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_last3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_first3_last3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_first3_last3_dropwhileneg([10]) == [10]\nassert op_first3_last3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_first3_last3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_dec_rev_beforezero", "entry_point": "op_dec_rev_beforezero", "primitives": ["dec", "rev", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then keep everything before the first zero.", "solution": "def op_dec_rev_beforezero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dec_rev_beforezero([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dec_rev_beforezero([]) == []\nassert op_dec_rev_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_dec_rev_beforezero([5, 5, 5]) == [4, 4, 4]\nassert op_dec_rev_beforezero([3, 1, 2]) == [1]\nassert op_dec_rev_beforezero([10]) == [9]\nassert op_dec_rev_beforezero([2, 4, 6]) == [5, 3, 1]\nassert op_dec_rev_beforezero([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dec_uniq_issorted", "entry_point": "op_dec_uniq_issorted", "primitives": ["dec", "uniq", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_dec_uniq_issorted(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_dec_uniq_issorted([1, 2, 3, 4]) == True\nassert op_dec_uniq_issorted([]) == True\nassert op_dec_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dec_uniq_issorted([5, 5, 5]) == True\nassert op_dec_uniq_issorted([3, 1, 2]) == False\nassert op_dec_uniq_issorted([10]) == True\nassert op_dec_uniq_issorted([2, 4, 6]) == True\nassert op_dec_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_sorta_padto3", "entry_point": "op_dec_sorta_padto3", "primitives": ["dec", "sorta", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then pad with zeros to at least three elements.", "solution": "def op_dec_sorta_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_sorta_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sorta_padto3([]) == [0, 0, 0]\nassert op_dec_sorta_padto3([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_sorta_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sorta_padto3([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sorta_padto3([10]) == [9, 0, 0]\nassert op_dec_sorta_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sorta_padto3([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_trimends_double_sortabs", "entry_point": "op_trimends_double_sortabs", "primitives": ["trimends", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then sort by absolute value.", "solution": "def op_trimends_double_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_double_sortabs([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_double_sortabs([]) == []\nassert op_trimends_double_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_trimends_double_sortabs([5, 5, 5]) == [10]\nassert op_trimends_double_sortabs([3, 1, 2]) == [2]\nassert op_trimends_double_sortabs([10]) == []\nassert op_trimends_double_sortabs([2, 4, 6]) == [8]\nassert op_trimends_double_sortabs([-7, 12, -7]) == [24]"}
{"id": "op_evens_gt5_double", "entry_point": "op_evens_gt5_double", "primitives": ["evens", "gt5", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then double each.", "solution": "def op_evens_gt5_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_gt5_double([1, 2, 3, 4]) == []\nassert op_evens_gt5_double([]) == []\nassert op_evens_gt5_double([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5_double([5, 5, 5]) == []\nassert op_evens_gt5_double([3, 1, 2]) == []\nassert op_evens_gt5_double([10]) == [20]\nassert op_evens_gt5_double([2, 4, 6]) == [12]\nassert op_evens_gt5_double([-7, 12, -7]) == [24]"}
{"id": "op_odds_square_min", "entry_point": "op_odds_square_min", "primitives": ["odds", "square", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then return the minimum (0 if empty).", "solution": "def op_odds_square_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return min(r) if r else 0", "tests": "assert op_odds_square_min([1, 2, 3, 4]) == 1\nassert op_odds_square_min([]) == 0\nassert op_odds_square_min([-2, -1, 0, 1, 2]) == 1\nassert op_odds_square_min([5, 5, 5]) == 25\nassert op_odds_square_min([3, 1, 2]) == 1\nassert op_odds_square_min([10]) == 0\nassert op_odds_square_min([2, 4, 6]) == 0\nassert op_odds_square_min([-7, 12, -7]) == 49"}
{"id": "op_gt5_pos_firsteven", "entry_point": "op_gt5_pos_firsteven", "primitives": ["gt5", "pos", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then return the first even value (0 if none).", "solution": "def op_gt5_pos_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_pos_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_pos_firsteven([]) == 0\nassert op_gt5_pos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_pos_firsteven([5, 5, 5]) == 0\nassert op_gt5_pos_firsteven([3, 1, 2]) == 0\nassert op_gt5_pos_firsteven([10]) == 10\nassert op_gt5_pos_firsteven([2, 4, 6]) == 6\nassert op_gt5_pos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_dropfirst_beforezero", "entry_point": "op_evens_dropfirst_beforezero", "primitives": ["evens", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then keep everything before the first zero.", "solution": "def op_evens_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_dropfirst_beforezero([1, 2, 3, 4]) == [4]\nassert op_evens_dropfirst_beforezero([]) == []\nassert op_evens_dropfirst_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_evens_dropfirst_beforezero([5, 5, 5]) == []\nassert op_evens_dropfirst_beforezero([3, 1, 2]) == []\nassert op_evens_dropfirst_beforezero([10]) == []\nassert op_evens_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_evens_dropfirst_beforezero([-7, 12, -7]) == []"}
{"id": "op_first3_last3_haszero", "entry_point": "op_first3_last3_haszero", "primitives": ["first3", "last3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then return whether the list contains a zero.", "solution": "def op_first3_last3_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    return 0 in r", "tests": "assert op_first3_last3_haszero([1, 2, 3, 4]) == False\nassert op_first3_last3_haszero([]) == False\nassert op_first3_last3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_first3_last3_haszero([5, 5, 5]) == False\nassert op_first3_last3_haszero([3, 1, 2]) == False\nassert op_first3_last3_haszero([10]) == False\nassert op_first3_last3_haszero([2, 4, 6]) == False\nassert op_first3_last3_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_gt5_max", "entry_point": "op_dropwhileneg_gt5_max", "primitives": ["dropwhileneg", "gt5", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_gt5_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_gt5_max([1, 2, 3, 4]) == 0\nassert op_dropwhileneg_gt5_max([]) == 0\nassert op_dropwhileneg_gt5_max([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_gt5_max([5, 5, 5]) == 0\nassert op_dropwhileneg_gt5_max([3, 1, 2]) == 0\nassert op_dropwhileneg_gt5_max([10]) == 10\nassert op_dropwhileneg_gt5_max([2, 4, 6]) == 6\nassert op_dropwhileneg_gt5_max([-7, 12, -7]) == 12"}
{"id": "op_inc_last3_issorted", "entry_point": "op_inc_last3_issorted", "primitives": ["inc", "last3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_inc_last3_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_inc_last3_issorted([1, 2, 3, 4]) == True\nassert op_inc_last3_issorted([]) == True\nassert op_inc_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_last3_issorted([5, 5, 5]) == True\nassert op_inc_last3_issorted([3, 1, 2]) == False\nassert op_inc_last3_issorted([10]) == True\nassert op_inc_last3_issorted([2, 4, 6]) == True\nassert op_inc_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_sorta_oremptyzero", "entry_point": "op_dropzeros_sorta_oremptyzero", "primitives": ["dropzeros", "sorta", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then if empty, use a single zero.", "solution": "def op_dropzeros_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sorta_oremptyzero([]) == [0]\nassert op_dropzeros_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sorta_oremptyzero([10]) == [10]\nassert op_dropzeros_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortd_negate_padto3", "entry_point": "op_sortd_negate_padto3", "primitives": ["sortd", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then negate each, then pad with zeros to at least three elements.", "solution": "def op_sortd_negate_padto3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortd_negate_padto3([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sortd_negate_padto3([]) == [0, 0, 0]\nassert op_sortd_negate_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_negate_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_sortd_negate_padto3([3, 1, 2]) == [-3, -2, -1]\nassert op_sortd_negate_padto3([10]) == [-10, 0, 0]\nassert op_sortd_negate_padto3([2, 4, 6]) == [-6, -4, -2]\nassert op_sortd_negate_padto3([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_sortabs_gt5_max", "entry_point": "op_sortabs_gt5_max", "primitives": ["sortabs", "gt5", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then return the maximum (0 if empty).", "solution": "def op_sortabs_gt5_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return max(r) if r else 0", "tests": "assert op_sortabs_gt5_max([1, 2, 3, 4]) == 0\nassert op_sortabs_gt5_max([]) == 0\nassert op_sortabs_gt5_max([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_gt5_max([5, 5, 5]) == 0\nassert op_sortabs_gt5_max([3, 1, 2]) == 0\nassert op_sortabs_gt5_max([10]) == 10\nassert op_sortabs_gt5_max([2, 4, 6]) == 6\nassert op_sortabs_gt5_max([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_inc_sorta", "entry_point": "op_dropwhileneg_inc_sorta", "primitives": ["dropwhileneg", "inc", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then sort ascending.", "solution": "def op_dropwhileneg_inc_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_inc_sorta([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropwhileneg_inc_sorta([]) == []\nassert op_dropwhileneg_inc_sorta([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_inc_sorta([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_inc_sorta([3, 1, 2]) == [2, 3, 4]\nassert op_dropwhileneg_inc_sorta([10]) == [11]\nassert op_dropwhileneg_inc_sorta([2, 4, 6]) == [3, 5, 7]\nassert op_dropwhileneg_inc_sorta([-7, 12, -7]) == [-6, 13]"}
{"id": "op_takewhilepos_neg_prod", "entry_point": "op_takewhilepos_neg_prod", "primitives": ["takewhilepos", "neg", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then return their product.", "solution": "def op_takewhilepos_neg_prod(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_takewhilepos_neg_prod([1, 2, 3, 4]) == 1\nassert op_takewhilepos_neg_prod([]) == 1\nassert op_takewhilepos_neg_prod([-2, -1, 0, 1, 2]) == 1\nassert op_takewhilepos_neg_prod([5, 5, 5]) == 1\nassert op_takewhilepos_neg_prod([3, 1, 2]) == 1\nassert op_takewhilepos_neg_prod([10]) == 1\nassert op_takewhilepos_neg_prod([2, 4, 6]) == 1\nassert op_takewhilepos_neg_prod([-7, 12, -7]) == 1"}
{"id": "op_sortd_clamp10_negate", "entry_point": "op_sortd_clamp10_negate", "primitives": ["sortd", "clamp10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10, then negate each.", "solution": "def op_sortd_clamp10_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_clamp10_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sortd_clamp10_negate([]) == []\nassert op_sortd_clamp10_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_clamp10_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortd_clamp10_negate([3, 1, 2]) == [-3, -2, -1]\nassert op_sortd_clamp10_negate([10]) == [-10]\nassert op_sortd_clamp10_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_sortd_clamp10_negate([-7, 12, -7]) == [-10, 7, 7]"}
{"id": "op_takewhilepos_gt5_trimends", "entry_point": "op_takewhilepos_gt5_trimends", "primitives": ["takewhilepos", "gt5", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then drop the first and last elements.", "solution": "def op_takewhilepos_gt5_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_gt5_trimends([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_trimends([]) == []\nassert op_takewhilepos_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_trimends([5, 5, 5]) == []\nassert op_takewhilepos_gt5_trimends([3, 1, 2]) == []\nassert op_takewhilepos_gt5_trimends([10]) == []\nassert op_takewhilepos_gt5_trimends([2, 4, 6]) == []\nassert op_takewhilepos_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_square_sortd_trimends", "entry_point": "op_square_sortd_trimends", "primitives": ["square", "sortd", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then drop the first and last elements.", "solution": "def op_square_sortd_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_square_sortd_trimends([1, 2, 3, 4]) == [9, 4]\nassert op_square_sortd_trimends([]) == []\nassert op_square_sortd_trimends([-2, -1, 0, 1, 2]) == [4, 1, 1]\nassert op_square_sortd_trimends([5, 5, 5]) == [25]\nassert op_square_sortd_trimends([3, 1, 2]) == [4]\nassert op_square_sortd_trimends([10]) == []\nassert op_square_sortd_trimends([2, 4, 6]) == [16]\nassert op_square_sortd_trimends([-7, 12, -7]) == [49]"}
{"id": "op_dropzeros_div3_negate", "entry_point": "op_dropzeros_div3_negate", "primitives": ["dropzeros", "div3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then negate each.", "solution": "def op_dropzeros_div3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropzeros_div3_negate([1, 2, 3, 4]) == [-3]\nassert op_dropzeros_div3_negate([]) == []\nassert op_dropzeros_div3_negate([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_negate([5, 5, 5]) == []\nassert op_dropzeros_div3_negate([3, 1, 2]) == [-3]\nassert op_dropzeros_div3_negate([10]) == []\nassert op_dropzeros_div3_negate([2, 4, 6]) == [-6]\nassert op_dropzeros_div3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_first3_negate_sortd", "entry_point": "op_first3_negate_sortd", "primitives": ["first3", "negate", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then negate each, then sort descending.", "solution": "def op_first3_negate_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_negate_sortd([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_first3_negate_sortd([]) == []\nassert op_first3_negate_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_first3_negate_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_first3_negate_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_first3_negate_sortd([10]) == [-10]\nassert op_first3_negate_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_first3_negate_sortd([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_gt5_dropfirst_negate", "entry_point": "op_gt5_dropfirst_negate", "primitives": ["gt5", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then negate each.", "solution": "def op_gt5_dropfirst_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_dropfirst_negate([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_negate([]) == []\nassert op_gt5_dropfirst_negate([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_negate([5, 5, 5]) == []\nassert op_gt5_dropfirst_negate([3, 1, 2]) == []\nassert op_gt5_dropfirst_negate([10]) == []\nassert op_gt5_dropfirst_negate([2, 4, 6]) == []\nassert op_gt5_dropfirst_negate([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_evens_gt5", "entry_point": "op_dropwhileneg_evens_gt5", "primitives": ["dropwhileneg", "evens", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then keep values greater than five.", "solution": "def op_dropwhileneg_evens_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_evens_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_evens_gt5([]) == []\nassert op_dropwhileneg_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_evens_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_evens_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_evens_gt5([10]) == [10]\nassert op_dropwhileneg_evens_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_evens_gt5([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_clamp10_absval", "entry_point": "op_oremptyzero_clamp10_absval", "primitives": ["oremptyzero", "clamp10", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then take the absolute value of each.", "solution": "def op_oremptyzero_clamp10_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_clamp10_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_clamp10_absval([]) == [0]\nassert op_oremptyzero_clamp10_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_oremptyzero_clamp10_absval([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_clamp10_absval([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_clamp10_absval([10]) == [10]\nassert op_oremptyzero_clamp10_absval([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_clamp10_pos_haszero", "entry_point": "op_clamp10_pos_haszero", "primitives": ["clamp10", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_clamp10_pos_haszero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_clamp10_pos_haszero([1, 2, 3, 4]) == False\nassert op_clamp10_pos_haszero([]) == False\nassert op_clamp10_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_clamp10_pos_haszero([5, 5, 5]) == False\nassert op_clamp10_pos_haszero([3, 1, 2]) == False\nassert op_clamp10_pos_haszero([10]) == False\nassert op_clamp10_pos_haszero([2, 4, 6]) == False\nassert op_clamp10_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_takewhilepos_sorta", "entry_point": "op_div3_takewhilepos_sorta", "primitives": ["div3", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then sort ascending.", "solution": "def op_div3_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_takewhilepos_sorta([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos_sorta([]) == []\nassert op_div3_takewhilepos_sorta([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_sorta([5, 5, 5]) == []\nassert op_div3_takewhilepos_sorta([3, 1, 2]) == [3]\nassert op_div3_takewhilepos_sorta([10]) == []\nassert op_div3_takewhilepos_sorta([2, 4, 6]) == [6]\nassert op_div3_takewhilepos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_gt5_trimends_absval", "entry_point": "op_gt5_trimends_absval", "primitives": ["gt5", "trimends", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_gt5_trimends_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_trimends_absval([1, 2, 3, 4]) == []\nassert op_gt5_trimends_absval([]) == []\nassert op_gt5_trimends_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_absval([5, 5, 5]) == []\nassert op_gt5_trimends_absval([3, 1, 2]) == []\nassert op_gt5_trimends_absval([10]) == []\nassert op_gt5_trimends_absval([2, 4, 6]) == []\nassert op_gt5_trimends_absval([-7, 12, -7]) == []"}
{"id": "op_pos_sortd_double", "entry_point": "op_pos_sortd_double", "primitives": ["pos", "sortd", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then double each.", "solution": "def op_pos_sortd_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_sortd_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_pos_sortd_double([]) == []\nassert op_pos_sortd_double([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_pos_sortd_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_sortd_double([3, 1, 2]) == [6, 4, 2]\nassert op_pos_sortd_double([10]) == [20]\nassert op_pos_sortd_double([2, 4, 6]) == [12, 8, 4]\nassert op_pos_sortd_double([-7, 12, -7]) == [24]"}
{"id": "op_absval_pos_allpos", "entry_point": "op_absval_pos_allpos", "primitives": ["absval", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_absval_pos_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_pos_allpos([1, 2, 3, 4]) == True\nassert op_absval_pos_allpos([]) == True\nassert op_absval_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_absval_pos_allpos([5, 5, 5]) == True\nassert op_absval_pos_allpos([3, 1, 2]) == True\nassert op_absval_pos_allpos([10]) == True\nassert op_absval_pos_allpos([2, 4, 6]) == True\nassert op_absval_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_dropwhileneg_absval", "entry_point": "op_dec_dropwhileneg_absval", "primitives": ["dec", "dropwhileneg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then take the absolute value of each.", "solution": "def op_dec_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_dropwhileneg_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_dropwhileneg_absval([]) == []\nassert op_dec_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dec_dropwhileneg_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropwhileneg_absval([3, 1, 2]) == [2, 0, 1]\nassert op_dec_dropwhileneg_absval([10]) == [9]\nassert op_dec_dropwhileneg_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropwhileneg_absval([-7, 12, -7]) == [11, 8]"}
{"id": "op_neg_first3_prod", "entry_point": "op_neg_first3_prod", "primitives": ["neg", "first3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three, then return their product.", "solution": "def op_neg_first3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_neg_first3_prod([1, 2, 3, 4]) == 1\nassert op_neg_first3_prod([]) == 1\nassert op_neg_first3_prod([-2, -1, 0, 1, 2]) == 2\nassert op_neg_first3_prod([5, 5, 5]) == 1\nassert op_neg_first3_prod([3, 1, 2]) == 1\nassert op_neg_first3_prod([10]) == 1\nassert op_neg_first3_prod([2, 4, 6]) == 1\nassert op_neg_first3_prod([-7, 12, -7]) == 49"}
{"id": "op_odds_absval_min", "entry_point": "op_odds_absval_min", "primitives": ["odds", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_odds_absval_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_odds_absval_min([1, 2, 3, 4]) == 1\nassert op_odds_absval_min([]) == 0\nassert op_odds_absval_min([-2, -1, 0, 1, 2]) == 1\nassert op_odds_absval_min([5, 5, 5]) == 5\nassert op_odds_absval_min([3, 1, 2]) == 1\nassert op_odds_absval_min([10]) == 0\nassert op_odds_absval_min([2, 4, 6]) == 0\nassert op_odds_absval_min([-7, 12, -7]) == 7"}
{"id": "op_add10_beforezero_counteven", "entry_point": "op_add10_beforezero_counteven", "primitives": ["add10", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero, then return how many values are even.", "solution": "def op_add10_beforezero_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_beforezero_counteven([1, 2, 3, 4]) == 2\nassert op_add10_beforezero_counteven([]) == 0\nassert op_add10_beforezero_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_beforezero_counteven([5, 5, 5]) == 0\nassert op_add10_beforezero_counteven([3, 1, 2]) == 1\nassert op_add10_beforezero_counteven([10]) == 1\nassert op_add10_beforezero_counteven([2, 4, 6]) == 3\nassert op_add10_beforezero_counteven([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_negate_last3", "entry_point": "op_oremptyzero_negate_last3", "primitives": ["oremptyzero", "negate", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then keep only the last three.", "solution": "def op_oremptyzero_negate_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_oremptyzero_negate_last3([]) == [0]\nassert op_oremptyzero_negate_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_oremptyzero_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_oremptyzero_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_oremptyzero_negate_last3([10]) == [-10]\nassert op_oremptyzero_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_oremptyzero_negate_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_clamp10_sortd_len", "entry_point": "op_clamp10_sortd_len", "primitives": ["clamp10", "sortd", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then return how many remain.", "solution": "def op_clamp10_sortd_len(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return len(r)", "tests": "assert op_clamp10_sortd_len([1, 2, 3, 4]) == 4\nassert op_clamp10_sortd_len([]) == 0\nassert op_clamp10_sortd_len([-2, -1, 0, 1, 2]) == 5\nassert op_clamp10_sortd_len([5, 5, 5]) == 3\nassert op_clamp10_sortd_len([3, 1, 2]) == 3\nassert op_clamp10_sortd_len([10]) == 1\nassert op_clamp10_sortd_len([2, 4, 6]) == 3\nassert op_clamp10_sortd_len([-7, 12, -7]) == 3"}
{"id": "op_absval_sortd_haszero", "entry_point": "op_absval_sortd_haszero", "primitives": ["absval", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then return whether the list contains a zero.", "solution": "def op_absval_sortd_haszero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_absval_sortd_haszero([1, 2, 3, 4]) == False\nassert op_absval_sortd_haszero([]) == False\nassert op_absval_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_absval_sortd_haszero([5, 5, 5]) == False\nassert op_absval_sortd_haszero([3, 1, 2]) == False\nassert op_absval_sortd_haszero([10]) == False\nassert op_absval_sortd_haszero([2, 4, 6]) == False\nassert op_absval_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_evens_takewhilepos_clamp10", "entry_point": "op_evens_takewhilepos_clamp10", "primitives": ["evens", "takewhilepos", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then cap each value at 10.", "solution": "def op_evens_takewhilepos_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_takewhilepos_clamp10([1, 2, 3, 4]) == [2, 4]\nassert op_evens_takewhilepos_clamp10([]) == []\nassert op_evens_takewhilepos_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_clamp10([5, 5, 5]) == []\nassert op_evens_takewhilepos_clamp10([3, 1, 2]) == [2]\nassert op_evens_takewhilepos_clamp10([10]) == [10]\nassert op_evens_takewhilepos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_evens_takewhilepos_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_beforezero_inc_prod", "entry_point": "op_beforezero_inc_prod", "primitives": ["beforezero", "inc", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then return their product.", "solution": "def op_beforezero_inc_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_inc_prod([1, 2, 3, 4]) == 120\nassert op_beforezero_inc_prod([]) == 1\nassert op_beforezero_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_inc_prod([5, 5, 5]) == 216\nassert op_beforezero_inc_prod([3, 1, 2]) == 24\nassert op_beforezero_inc_prod([10]) == 11\nassert op_beforezero_inc_prod([2, 4, 6]) == 105\nassert op_beforezero_inc_prod([-7, 12, -7]) == 468"}
{"id": "op_sortalpha_uniqs_anyempty", "entry_point": "op_sortalpha_uniqs_anyempty", "primitives": ["sortalpha", "uniqs", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_sortalpha_uniqs_anyempty(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_sortalpha_uniqs_anyempty(['Hello', 'world']) == False\nassert op_sortalpha_uniqs_anyempty([]) == False\nassert op_sortalpha_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_sortalpha_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_sortalpha_uniqs_anyempty(['x']) == False\nassert op_sortalpha_uniqs_anyempty(['abc', 'de', '']) == True"}
{"id": "op_absval_rev_takewhilepos", "entry_point": "op_absval_rev_takewhilepos", "primitives": ["absval", "rev", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then take values while they are positive.", "solution": "def op_absval_rev_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_rev_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_rev_takewhilepos([]) == []\nassert op_absval_rev_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_rev_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_rev_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_absval_rev_takewhilepos([10]) == [10]\nassert op_absval_rev_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_absval_rev_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_oremptyzero_rev_odds", "entry_point": "op_oremptyzero_rev_odds", "primitives": ["oremptyzero", "rev", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then keep the odd numbers.", "solution": "def op_oremptyzero_rev_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_rev_odds([1, 2, 3, 4]) == [3, 1]\nassert op_oremptyzero_rev_odds([]) == []\nassert op_oremptyzero_rev_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_oremptyzero_rev_odds([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_rev_odds([3, 1, 2]) == [1, 3]\nassert op_oremptyzero_rev_odds([10]) == []\nassert op_oremptyzero_rev_odds([2, 4, 6]) == []\nassert op_oremptyzero_rev_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_inc_sortabs", "entry_point": "op_evens_inc_sortabs", "primitives": ["evens", "inc", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then sort by absolute value.", "solution": "def op_evens_inc_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_inc_sortabs([1, 2, 3, 4]) == [3, 5]\nassert op_evens_inc_sortabs([]) == []\nassert op_evens_inc_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_evens_inc_sortabs([5, 5, 5]) == []\nassert op_evens_inc_sortabs([3, 1, 2]) == [3]\nassert op_evens_inc_sortabs([10]) == [11]\nassert op_evens_inc_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_evens_inc_sortabs([-7, 12, -7]) == [13]"}
{"id": "op_ages_double_padto3", "entry_point": "op_ages_double_padto3", "primitives": ["ages", "double", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then double each, then pad with zeros to at least three elements.", "solution": "def op_ages_double_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_double_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [72, 24, 0]\nassert op_ages_double_padto3([]) == [0, 0, 0]\nassert op_ages_double_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [36, 130, 34]\nassert op_ages_double_padto3([{'name': 'Fi', 'age': 41}]) == [82, 0, 0]"}
{"id": "op_absval_trimends_uniq", "entry_point": "op_absval_trimends_uniq", "primitives": ["absval", "trimends", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_absval_trimends_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_trimends_uniq([1, 2, 3, 4]) == [2, 3]\nassert op_absval_trimends_uniq([]) == []\nassert op_absval_trimends_uniq([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_absval_trimends_uniq([5, 5, 5]) == [5]\nassert op_absval_trimends_uniq([3, 1, 2]) == [1]\nassert op_absval_trimends_uniq([10]) == []\nassert op_absval_trimends_uniq([2, 4, 6]) == [4]\nassert op_absval_trimends_uniq([-7, 12, -7]) == [12]"}
{"id": "op_gt5_sortd_double", "entry_point": "op_gt5_sortd_double", "primitives": ["gt5", "sortd", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then double each.", "solution": "def op_gt5_sortd_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_gt5_sortd_double([1, 2, 3, 4]) == []\nassert op_gt5_sortd_double([]) == []\nassert op_gt5_sortd_double([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd_double([5, 5, 5]) == []\nassert op_gt5_sortd_double([3, 1, 2]) == []\nassert op_gt5_sortd_double([10]) == [20]\nassert op_gt5_sortd_double([2, 4, 6]) == [12]\nassert op_gt5_sortd_double([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_beforezero_gt5", "entry_point": "op_takewhilepos_beforezero_gt5", "primitives": ["takewhilepos", "beforezero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_takewhilepos_beforezero_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_beforezero_gt5([]) == []\nassert op_takewhilepos_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_gt5([5, 5, 5]) == []\nassert op_takewhilepos_beforezero_gt5([3, 1, 2]) == []\nassert op_takewhilepos_beforezero_gt5([10]) == [10]\nassert op_takewhilepos_beforezero_gt5([2, 4, 6]) == [6]\nassert op_takewhilepos_beforezero_gt5([-7, 12, -7]) == []"}
{"id": "op_beforezero_square_counteven", "entry_point": "op_beforezero_square_counteven", "primitives": ["beforezero", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then square each, then return how many values are even.", "solution": "def op_beforezero_square_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_square_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_square_counteven([]) == 0\nassert op_beforezero_square_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_square_counteven([5, 5, 5]) == 0\nassert op_beforezero_square_counteven([3, 1, 2]) == 1\nassert op_beforezero_square_counteven([10]) == 1\nassert op_beforezero_square_counteven([2, 4, 6]) == 3\nassert op_beforezero_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_neg_rev", "entry_point": "op_dropfirst_neg_rev", "primitives": ["dropfirst", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then reverse the order.", "solution": "def op_dropfirst_neg_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_neg_rev([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_rev([]) == []\nassert op_dropfirst_neg_rev([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg_rev([5, 5, 5]) == []\nassert op_dropfirst_neg_rev([3, 1, 2]) == []\nassert op_dropfirst_neg_rev([10]) == []\nassert op_dropfirst_neg_rev([2, 4, 6]) == []\nassert op_dropfirst_neg_rev([-7, 12, -7]) == [-7]"}
{"id": "op_strip_uniqs_longest", "entry_point": "op_strip_uniqs_longest", "primitives": ["strip", "uniqs", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first, then return the longest string (empty if none).", "solution": "def op_strip_uniqs_longest(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    return max(r, key=len) if r else ''", "tests": "assert op_strip_uniqs_longest(['Hello', 'world']) == 'Hello'\nassert op_strip_uniqs_longest([]) == ''\nassert op_strip_uniqs_longest(['  a ', '', 'BC', 'bc']) == 'BC'\nassert op_strip_uniqs_longest(['one', 'one', 'Two']) == 'one'\nassert op_strip_uniqs_longest(['x']) == 'x'\nassert op_strip_uniqs_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_last3_evens_sorta", "entry_point": "op_last3_evens_sorta", "primitives": ["last3", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers, then sort ascending.", "solution": "def op_last3_evens_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_evens_sorta([1, 2, 3, 4]) == [2, 4]\nassert op_last3_evens_sorta([]) == []\nassert op_last3_evens_sorta([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_last3_evens_sorta([5, 5, 5]) == []\nassert op_last3_evens_sorta([3, 1, 2]) == [2]\nassert op_last3_evens_sorta([10]) == [10]\nassert op_last3_evens_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_evens_sorta([-7, 12, -7]) == [12]"}
{"id": "op_neg_absval_min", "entry_point": "op_neg_absval_min", "primitives": ["neg", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_neg_absval_min(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_neg_absval_min([1, 2, 3, 4]) == 0\nassert op_neg_absval_min([]) == 0\nassert op_neg_absval_min([-2, -1, 0, 1, 2]) == 1\nassert op_neg_absval_min([5, 5, 5]) == 0\nassert op_neg_absval_min([3, 1, 2]) == 0\nassert op_neg_absval_min([10]) == 0\nassert op_neg_absval_min([2, 4, 6]) == 0\nassert op_neg_absval_min([-7, 12, -7]) == 7"}
{"id": "op_double_absval_odds", "entry_point": "op_double_absval_odds", "primitives": ["double", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_double_absval_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_absval_odds([1, 2, 3, 4]) == []\nassert op_double_absval_odds([]) == []\nassert op_double_absval_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_absval_odds([5, 5, 5]) == []\nassert op_double_absval_odds([3, 1, 2]) == []\nassert op_double_absval_odds([10]) == []\nassert op_double_absval_odds([2, 4, 6]) == []\nassert op_double_absval_odds([-7, 12, -7]) == []"}
{"id": "op_trimends_padto3_absval", "entry_point": "op_trimends_padto3_absval", "primitives": ["trimends", "padto3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_trimends_padto3_absval(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_trimends_padto3_absval([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_padto3_absval([]) == [0, 0, 0]\nassert op_trimends_padto3_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_padto3_absval([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_padto3_absval([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_padto3_absval([10]) == [0, 0, 0]\nassert op_trimends_padto3_absval([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_padto3_absval([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_ages_dec_dropzeros", "entry_point": "op_ages_dec_dropzeros", "primitives": ["ages", "dec", "dropzeros"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then drop the zeros.", "solution": "def op_ages_dec_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_dec_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11]\nassert op_ages_dec_dropzeros([]) == []\nassert op_ages_dec_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 64, 16]\nassert op_ages_dec_dropzeros([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_sortage_ages_dropwhileneg", "entry_point": "op_sortage_ages_dropwhileneg", "primitives": ["sortage", "ages", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then drop the leading negative values.", "solution": "def op_sortage_ages_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortage_ages_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_sortage_ages_dropwhileneg([]) == []\nassert op_sortage_ages_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_sortage_ages_dropwhileneg([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_first3_sortd_inc", "entry_point": "op_first3_sortd_inc", "primitives": ["first3", "sortd", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then add one to each.", "solution": "def op_first3_sortd_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_sortd_inc([1, 2, 3, 4]) == [4, 3, 2]\nassert op_first3_sortd_inc([]) == []\nassert op_first3_sortd_inc([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_first3_sortd_inc([5, 5, 5]) == [6, 6, 6]\nassert op_first3_sortd_inc([3, 1, 2]) == [4, 3, 2]\nassert op_first3_sortd_inc([10]) == [11]\nassert op_first3_sortd_inc([2, 4, 6]) == [7, 5, 3]\nassert op_first3_sortd_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_neg_sortd_negate", "entry_point": "op_neg_sortd_negate", "primitives": ["neg", "sortd", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending, then negate each.", "solution": "def op_neg_sortd_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_sortd_negate([1, 2, 3, 4]) == []\nassert op_neg_sortd_negate([]) == []\nassert op_neg_sortd_negate([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_neg_sortd_negate([5, 5, 5]) == []\nassert op_neg_sortd_negate([3, 1, 2]) == []\nassert op_neg_sortd_negate([10]) == []\nassert op_neg_sortd_negate([2, 4, 6]) == []\nassert op_neg_sortd_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_trimends_double_first3", "entry_point": "op_trimends_double_first3", "primitives": ["trimends", "double", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then keep only the first three.", "solution": "def op_trimends_double_first3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_trimends_double_first3([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_double_first3([]) == []\nassert op_trimends_double_first3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_trimends_double_first3([5, 5, 5]) == [10]\nassert op_trimends_double_first3([3, 1, 2]) == [2]\nassert op_trimends_double_first3([10]) == []\nassert op_trimends_double_first3([2, 4, 6]) == [8]\nassert op_trimends_double_first3([-7, 12, -7]) == [24]"}
{"id": "op_trimends_negate_add10", "entry_point": "op_trimends_negate_add10", "primitives": ["trimends", "negate", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then add ten to each.", "solution": "def op_trimends_negate_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_negate_add10([1, 2, 3, 4]) == [8, 7]\nassert op_trimends_negate_add10([]) == []\nassert op_trimends_negate_add10([-2, -1, 0, 1, 2]) == [11, 10, 9]\nassert op_trimends_negate_add10([5, 5, 5]) == [5]\nassert op_trimends_negate_add10([3, 1, 2]) == [9]\nassert op_trimends_negate_add10([10]) == []\nassert op_trimends_negate_add10([2, 4, 6]) == [6]\nassert op_trimends_negate_add10([-7, 12, -7]) == [-2]"}
{"id": "op_evens_gt5_oremptyzero", "entry_point": "op_evens_gt5_oremptyzero", "primitives": ["evens", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_evens_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_evens_gt5_oremptyzero([]) == [0]\nassert op_evens_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_evens_gt5_oremptyzero([10]) == [10]\nassert op_evens_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_evens_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_clamp10_sorta", "entry_point": "op_oremptyzero_clamp10_sorta", "primitives": ["oremptyzero", "clamp10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then sort ascending.", "solution": "def op_oremptyzero_clamp10_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_clamp10_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_clamp10_sorta([]) == [0]\nassert op_oremptyzero_clamp10_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_clamp10_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_clamp10_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_clamp10_sorta([10]) == [10]\nassert op_oremptyzero_clamp10_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10_sorta([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_rev_takewhilepos_first3", "entry_point": "op_rev_takewhilepos_first3", "primitives": ["rev", "takewhilepos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take values while they are positive, then keep only the first three.", "solution": "def op_rev_takewhilepos_first3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_rev_takewhilepos_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_takewhilepos_first3([]) == []\nassert op_rev_takewhilepos_first3([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_takewhilepos_first3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_takewhilepos_first3([10]) == [10]\nassert op_rev_takewhilepos_first3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_uniq_oremptyzero_inc", "entry_point": "op_uniq_oremptyzero_inc", "primitives": ["uniq", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then add one to each.", "solution": "def op_uniq_oremptyzero_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_uniq_oremptyzero_inc([]) == [1]\nassert op_uniq_oremptyzero_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_uniq_oremptyzero_inc([5, 5, 5]) == [6]\nassert op_uniq_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_uniq_oremptyzero_inc([10]) == [11]\nassert op_uniq_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_uniq_oremptyzero_inc([-7, 12, -7]) == [-6, 13]"}
{"id": "op_dec_sorta_evens", "entry_point": "op_dec_sorta_evens", "primitives": ["dec", "sorta", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then keep the even numbers.", "solution": "def op_dec_sorta_evens(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dec_sorta_evens([1, 2, 3, 4]) == [0, 2]\nassert op_dec_sorta_evens([]) == []\nassert op_dec_sorta_evens([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_dec_sorta_evens([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sorta_evens([3, 1, 2]) == [0, 2]\nassert op_dec_sorta_evens([10]) == []\nassert op_dec_sorta_evens([2, 4, 6]) == []\nassert op_dec_sorta_evens([-7, 12, -7]) == [-8, -8]"}
{"id": "op_sortd_takewhilepos_oremptyzero", "entry_point": "op_sortd_takewhilepos_oremptyzero", "primitives": ["sortd", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_sortd_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_takewhilepos_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_takewhilepos_oremptyzero([]) == [0]\nassert op_sortd_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_takewhilepos_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_takewhilepos_oremptyzero([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_takewhilepos_oremptyzero([10]) == [10]\nassert op_sortd_takewhilepos_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_takewhilepos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_dec_negate", "entry_point": "op_dropfirst_dec_negate", "primitives": ["dropfirst", "dec", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then negate each.", "solution": "def op_dropfirst_dec_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_dec_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_dropfirst_dec_negate([]) == []\nassert op_dropfirst_dec_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_dec_negate([5, 5, 5]) == [-4, -4]\nassert op_dropfirst_dec_negate([3, 1, 2]) == [0, -1]\nassert op_dropfirst_dec_negate([10]) == []\nassert op_dropfirst_dec_negate([2, 4, 6]) == [-3, -5]\nassert op_dropfirst_dec_negate([-7, 12, -7]) == [-11, 8]"}
{"id": "op_sortd_sorta_rev", "entry_point": "op_sortd_sorta_rev", "primitives": ["sortd", "sorta", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then reverse the order.", "solution": "def op_sortd_sorta_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_sorta_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_sorta_rev([]) == []\nassert op_sortd_sorta_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortd_sorta_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sorta_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_sorta_rev([10]) == [10]\nassert op_sortd_sorta_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_sorta_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_uniq_add10_firsteven", "entry_point": "op_uniq_add10_firsteven", "primitives": ["uniq", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then return the first even value (0 if none).", "solution": "def op_uniq_add10_firsteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_uniq_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_uniq_add10_firsteven([]) == 0\nassert op_uniq_add10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_uniq_add10_firsteven([5, 5, 5]) == 0\nassert op_uniq_add10_firsteven([3, 1, 2]) == 12\nassert op_uniq_add10_firsteven([10]) == 20\nassert op_uniq_add10_firsteven([2, 4, 6]) == 12\nassert op_uniq_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_names_nonempty_maxlen", "entry_point": "op_names_nonempty_maxlen", "primitives": ["names", "nonempty", "maxlen"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop empty strings, then return the length of the longest string (0 if none).", "solution": "def op_names_nonempty_maxlen(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if s]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_names_nonempty_maxlen([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 3\nassert op_names_nonempty_maxlen([]) == 0\nassert op_names_nonempty_maxlen([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_names_nonempty_maxlen([{'name': 'Fi', 'age': 41}]) == 2"}
{"id": "op_last3_dropzeros_allpos", "entry_point": "op_last3_dropzeros_allpos", "primitives": ["last3", "dropzeros", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then return whether all values are positive.", "solution": "def op_last3_dropzeros_allpos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_last3_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_last3_dropzeros_allpos([]) == True\nassert op_last3_dropzeros_allpos([-2, -1, 0, 1, 2]) == True\nassert op_last3_dropzeros_allpos([5, 5, 5]) == True\nassert op_last3_dropzeros_allpos([3, 1, 2]) == True\nassert op_last3_dropzeros_allpos([10]) == True\nassert op_last3_dropzeros_allpos([2, 4, 6]) == True\nassert op_last3_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_evens_uniq_odds", "entry_point": "op_evens_uniq_odds", "primitives": ["evens", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_evens_uniq_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_uniq_odds([1, 2, 3, 4]) == []\nassert op_evens_uniq_odds([]) == []\nassert op_evens_uniq_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_uniq_odds([5, 5, 5]) == []\nassert op_evens_uniq_odds([3, 1, 2]) == []\nassert op_evens_uniq_odds([10]) == []\nassert op_evens_uniq_odds([2, 4, 6]) == []\nassert op_evens_uniq_odds([-7, 12, -7]) == []"}
{"id": "op_sortlen_strip_counts", "entry_point": "op_sortlen_strip_counts", "primitives": ["sortlen", "strip", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then trim whitespace from each, then return how many strings remain.", "solution": "def op_sortlen_strip_counts(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return len(r)", "tests": "assert op_sortlen_strip_counts(['Hello', 'world']) == 2\nassert op_sortlen_strip_counts([]) == 0\nassert op_sortlen_strip_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortlen_strip_counts(['one', 'one', 'Two']) == 3\nassert op_sortlen_strip_counts(['x']) == 1\nassert op_sortlen_strip_counts(['abc', 'de', '']) == 3"}
{"id": "op_inc_clamp10_double", "entry_point": "op_inc_clamp10_double", "primitives": ["inc", "clamp10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then double each.", "solution": "def op_inc_clamp10_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_clamp10_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_clamp10_double([]) == []\nassert op_inc_clamp10_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4, 6]\nassert op_inc_clamp10_double([5, 5, 5]) == [12, 12, 12]\nassert op_inc_clamp10_double([3, 1, 2]) == [8, 4, 6]\nassert op_inc_clamp10_double([10]) == [20]\nassert op_inc_clamp10_double([2, 4, 6]) == [6, 10, 14]\nassert op_inc_clamp10_double([-7, 12, -7]) == [-12, 20, -12]"}
{"id": "op_dropwhileneg_trimends_prod", "entry_point": "op_dropwhileneg_trimends_prod", "primitives": ["dropwhileneg", "trimends", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then return their product.", "solution": "def op_dropwhileneg_trimends_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_trimends_prod([1, 2, 3, 4]) == 6\nassert op_dropwhileneg_trimends_prod([]) == 1\nassert op_dropwhileneg_trimends_prod([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_trimends_prod([5, 5, 5]) == 5\nassert op_dropwhileneg_trimends_prod([3, 1, 2]) == 1\nassert op_dropwhileneg_trimends_prod([10]) == 1\nassert op_dropwhileneg_trimends_prod([2, 4, 6]) == 4\nassert op_dropwhileneg_trimends_prod([-7, 12, -7]) == 1"}
{"id": "op_negate_inc_max", "entry_point": "op_negate_inc_max", "primitives": ["negate", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then return the maximum (0 if empty).", "solution": "def op_negate_inc_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_negate_inc_max([1, 2, 3, 4]) == 0\nassert op_negate_inc_max([]) == 0\nassert op_negate_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_negate_inc_max([5, 5, 5]) == -4\nassert op_negate_inc_max([3, 1, 2]) == 0\nassert op_negate_inc_max([10]) == -9\nassert op_negate_inc_max([2, 4, 6]) == -1\nassert op_negate_inc_max([-7, 12, -7]) == 8"}
{"id": "op_neg_padto3_sortabs", "entry_point": "op_neg_padto3_sortabs", "primitives": ["neg", "padto3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_neg_padto3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_padto3_sortabs([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_neg_padto3_sortabs([5, 5, 5]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([3, 1, 2]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([10]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([2, 4, 6]) == [0, 0, 0]\nassert op_neg_padto3_sortabs([-7, 12, -7]) == [0, -7, -7]"}
{"id": "op_padto3_sorta_trimends", "entry_point": "op_padto3_sorta_trimends", "primitives": ["padto3", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then drop the first and last elements.", "solution": "def op_padto3_sorta_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_sorta_trimends([]) == [0]\nassert op_padto3_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_sorta_trimends([5, 5, 5]) == [5]\nassert op_padto3_sorta_trimends([3, 1, 2]) == [2]\nassert op_padto3_sorta_trimends([10]) == [0]\nassert op_padto3_sorta_trimends([2, 4, 6]) == [4]\nassert op_padto3_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_uniq_rev_min", "entry_point": "op_uniq_rev_min", "primitives": ["uniq", "rev", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_uniq_rev_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_uniq_rev_min([1, 2, 3, 4]) == 1\nassert op_uniq_rev_min([]) == 0\nassert op_uniq_rev_min([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_rev_min([5, 5, 5]) == 5\nassert op_uniq_rev_min([3, 1, 2]) == 1\nassert op_uniq_rev_min([10]) == 10\nassert op_uniq_rev_min([2, 4, 6]) == 2\nassert op_uniq_rev_min([-7, 12, -7]) == -7"}
{"id": "op_gt5_dropfirst_padto3", "entry_point": "op_gt5_dropfirst_padto3", "primitives": ["gt5", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_gt5_dropfirst_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_gt5_dropfirst_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_gt5_dropfirst_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_odds_dropwhileneg_evens", "entry_point": "op_odds_dropwhileneg_evens", "primitives": ["odds", "dropwhileneg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values, then keep the even numbers.", "solution": "def op_odds_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_odds_dropwhileneg_evens([1, 2, 3, 4]) == []\nassert op_odds_dropwhileneg_evens([]) == []\nassert op_odds_dropwhileneg_evens([-2, -1, 0, 1, 2]) == []\nassert op_odds_dropwhileneg_evens([5, 5, 5]) == []\nassert op_odds_dropwhileneg_evens([3, 1, 2]) == []\nassert op_odds_dropwhileneg_evens([10]) == []\nassert op_odds_dropwhileneg_evens([2, 4, 6]) == []\nassert op_odds_dropwhileneg_evens([-7, 12, -7]) == []"}
{"id": "op_absval_trimends_issorted", "entry_point": "op_absval_trimends_issorted", "primitives": ["absval", "trimends", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_absval_trimends_issorted(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_absval_trimends_issorted([1, 2, 3, 4]) == True\nassert op_absval_trimends_issorted([]) == True\nassert op_absval_trimends_issorted([-2, -1, 0, 1, 2]) == False\nassert op_absval_trimends_issorted([5, 5, 5]) == True\nassert op_absval_trimends_issorted([3, 1, 2]) == True\nassert op_absval_trimends_issorted([10]) == True\nassert op_absval_trimends_issorted([2, 4, 6]) == True\nassert op_absval_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_first3_pos_dropfirst", "entry_point": "op_first3_pos_dropfirst", "primitives": ["first3", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then drop the first element.", "solution": "def op_first3_pos_dropfirst(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_first3_pos_dropfirst([1, 2, 3, 4]) == [2, 3]\nassert op_first3_pos_dropfirst([]) == []\nassert op_first3_pos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_first3_pos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_first3_pos_dropfirst([10]) == []\nassert op_first3_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_first3_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_ages_oremptyzero_len", "entry_point": "op_ages_oremptyzero_len", "primitives": ["ages", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then return how many remain.", "solution": "def op_ages_oremptyzero_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_ages_oremptyzero_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_oremptyzero_len([]) == 1\nassert op_ages_oremptyzero_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_oremptyzero_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_rev_dropfirst_padto3", "entry_point": "op_rev_dropfirst_padto3", "primitives": ["rev", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_rev_dropfirst_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_dropfirst_padto3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dropfirst_padto3([]) == [0, 0, 0]\nassert op_rev_dropfirst_padto3([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_rev_dropfirst_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_rev_dropfirst_padto3([3, 1, 2]) == [1, 3, 0]\nassert op_rev_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_rev_dropfirst_padto3([2, 4, 6]) == [4, 2, 0]\nassert op_rev_dropfirst_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_dropzeros_odds_sortd", "entry_point": "op_dropzeros_odds_sortd", "primitives": ["dropzeros", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then sort descending.", "solution": "def op_dropzeros_odds_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_dropzeros_odds_sortd([]) == []\nassert op_dropzeros_odds_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_dropzeros_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_dropzeros_odds_sortd([10]) == []\nassert op_dropzeros_odds_sortd([2, 4, 6]) == []\nassert op_dropzeros_odds_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_upper_prefixup_maxlen", "entry_point": "op_upper_prefixup_maxlen", "primitives": ["upper", "prefixup", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then prefix each with a hash, then return the length of the longest string (0 if none).", "solution": "def op_upper_prefixup_maxlen(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = ['#' + s for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_upper_prefixup_maxlen(['Hello', 'world']) == 6\nassert op_upper_prefixup_maxlen([]) == 0\nassert op_upper_prefixup_maxlen(['  a ', '', 'BC', 'bc']) == 5\nassert op_upper_prefixup_maxlen(['one', 'one', 'Two']) == 4\nassert op_upper_prefixup_maxlen(['x']) == 2\nassert op_upper_prefixup_maxlen(['abc', 'de', '']) == 4"}
{"id": "op_evens_odds_clamp10", "entry_point": "op_evens_odds_clamp10", "primitives": ["evens", "odds", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then cap each value at 10.", "solution": "def op_evens_odds_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_odds_clamp10([1, 2, 3, 4]) == []\nassert op_evens_odds_clamp10([]) == []\nassert op_evens_odds_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_clamp10([5, 5, 5]) == []\nassert op_evens_odds_clamp10([3, 1, 2]) == []\nassert op_evens_odds_clamp10([10]) == []\nassert op_evens_odds_clamp10([2, 4, 6]) == []\nassert op_evens_odds_clamp10([-7, 12, -7]) == []"}
{"id": "op_sortd_dec_negate", "entry_point": "op_sortd_dec_negate", "primitives": ["sortd", "dec", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each, then negate each.", "solution": "def op_sortd_dec_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_dec_negate([1, 2, 3, 4]) == [-3, -2, -1, 0]\nassert op_sortd_dec_negate([]) == []\nassert op_sortd_dec_negate([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_sortd_dec_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_sortd_dec_negate([3, 1, 2]) == [-2, -1, 0]\nassert op_sortd_dec_negate([10]) == [-9]\nassert op_sortd_dec_negate([2, 4, 6]) == [-5, -3, -1]\nassert op_sortd_dec_negate([-7, 12, -7]) == [-11, 8, 8]"}
{"id": "op_double_uniq_evens", "entry_point": "op_double_uniq_evens", "primitives": ["double", "uniq", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_double_uniq_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_uniq_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_uniq_evens([]) == []\nassert op_double_uniq_evens([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_uniq_evens([5, 5, 5]) == [10]\nassert op_double_uniq_evens([3, 1, 2]) == [6, 2, 4]\nassert op_double_uniq_evens([10]) == [20]\nassert op_double_uniq_evens([2, 4, 6]) == [4, 8, 12]\nassert op_double_uniq_evens([-7, 12, -7]) == [-14, 24]"}
{"id": "op_evens_square_sorta", "entry_point": "op_evens_square_sorta", "primitives": ["evens", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then sort ascending.", "solution": "def op_evens_square_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_evens_square_sorta([1, 2, 3, 4]) == [4, 16]\nassert op_evens_square_sorta([]) == []\nassert op_evens_square_sorta([-2, -1, 0, 1, 2]) == [0, 4, 4]\nassert op_evens_square_sorta([5, 5, 5]) == []\nassert op_evens_square_sorta([3, 1, 2]) == [4]\nassert op_evens_square_sorta([10]) == [100]\nassert op_evens_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_evens_square_sorta([-7, 12, -7]) == [144]"}
{"id": "op_trimends_negate_absval", "entry_point": "op_trimends_negate_absval", "primitives": ["trimends", "negate", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then take the absolute value of each.", "solution": "def op_trimends_negate_absval(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_trimends_negate_absval([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_negate_absval([]) == []\nassert op_trimends_negate_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_negate_absval([5, 5, 5]) == [5]\nassert op_trimends_negate_absval([3, 1, 2]) == [1]\nassert op_trimends_negate_absval([10]) == []\nassert op_trimends_negate_absval([2, 4, 6]) == [4]\nassert op_trimends_negate_absval([-7, 12, -7]) == [12]"}
{"id": "op_dec_last3_double", "entry_point": "op_dec_last3_double", "primitives": ["dec", "last3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the last three, then double each.", "solution": "def op_dec_last3_double(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dec_last3_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_dec_last3_double([]) == []\nassert op_dec_last3_double([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_dec_last3_double([5, 5, 5]) == [8, 8, 8]\nassert op_dec_last3_double([3, 1, 2]) == [4, 0, 2]\nassert op_dec_last3_double([10]) == [18]\nassert op_dec_last3_double([2, 4, 6]) == [2, 6, 10]\nassert op_dec_last3_double([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_trimends_takewhilepos_sum", "entry_point": "op_trimends_takewhilepos_sum", "primitives": ["trimends", "takewhilepos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take values while they are positive, then return their sum.", "solution": "def op_trimends_takewhilepos_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_trimends_takewhilepos_sum([1, 2, 3, 4]) == 5\nassert op_trimends_takewhilepos_sum([]) == 0\nassert op_trimends_takewhilepos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_takewhilepos_sum([5, 5, 5]) == 5\nassert op_trimends_takewhilepos_sum([3, 1, 2]) == 1\nassert op_trimends_takewhilepos_sum([10]) == 0\nassert op_trimends_takewhilepos_sum([2, 4, 6]) == 4\nassert op_trimends_takewhilepos_sum([-7, 12, -7]) == 12"}
{"id": "op_gt5_padto3_clamp10", "entry_point": "op_gt5_padto3_clamp10", "primitives": ["gt5", "padto3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then cap each value at 10.", "solution": "def op_gt5_padto3_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_padto3_clamp10([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_padto3_clamp10([]) == [0, 0, 0]\nassert op_gt5_padto3_clamp10([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_clamp10([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_padto3_clamp10([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_clamp10([10]) == [10, 0, 0]\nassert op_gt5_padto3_clamp10([2, 4, 6]) == [6, 0, 0]\nassert op_gt5_padto3_clamp10([-7, 12, -7]) == [10, 0, 0]"}
{"id": "op_evens_square_alldistinct", "entry_point": "op_evens_square_alldistinct", "primitives": ["evens", "square", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then return whether all values are distinct.", "solution": "def op_evens_square_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_evens_square_alldistinct([1, 2, 3, 4]) == True\nassert op_evens_square_alldistinct([]) == True\nassert op_evens_square_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_evens_square_alldistinct([5, 5, 5]) == True\nassert op_evens_square_alldistinct([3, 1, 2]) == True\nassert op_evens_square_alldistinct([10]) == True\nassert op_evens_square_alldistinct([2, 4, 6]) == True\nassert op_evens_square_alldistinct([-7, 12, -7]) == True"}
{"id": "op_square_uniq_inc", "entry_point": "op_square_uniq_inc", "primitives": ["square", "uniq", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_square_uniq_inc(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_square_uniq_inc([1, 2, 3, 4]) == [2, 5, 10, 17]\nassert op_square_uniq_inc([]) == []\nassert op_square_uniq_inc([-2, -1, 0, 1, 2]) == [5, 2, 1]\nassert op_square_uniq_inc([5, 5, 5]) == [26]\nassert op_square_uniq_inc([3, 1, 2]) == [10, 2, 5]\nassert op_square_uniq_inc([10]) == [101]\nassert op_square_uniq_inc([2, 4, 6]) == [5, 17, 37]\nassert op_square_uniq_inc([-7, 12, -7]) == [50, 145]"}
{"id": "op_negate_add10_div3", "entry_point": "op_negate_add10_div3", "primitives": ["negate", "add10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then keep multiples of three.", "solution": "def op_negate_add10_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_add10_div3([1, 2, 3, 4]) == [9, 6]\nassert op_negate_add10_div3([]) == []\nassert op_negate_add10_div3([-2, -1, 0, 1, 2]) == [12, 9]\nassert op_negate_add10_div3([5, 5, 5]) == []\nassert op_negate_add10_div3([3, 1, 2]) == [9]\nassert op_negate_add10_div3([10]) == [0]\nassert op_negate_add10_div3([2, 4, 6]) == [6]\nassert op_negate_add10_div3([-7, 12, -7]) == []"}
{"id": "op_padto3_last3_absval", "entry_point": "op_padto3_last3_absval", "primitives": ["padto3", "last3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then take the absolute value of each.", "solution": "def op_padto3_last3_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_last3_absval([]) == [0, 0, 0]\nassert op_padto3_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_last3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_last3_absval([10]) == [10, 0, 0]\nassert op_padto3_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sorta_trimends_sortd", "entry_point": "op_sorta_trimends_sortd", "primitives": ["sorta", "trimends", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then sort descending.", "solution": "def op_sorta_trimends_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_trimends_sortd([1, 2, 3, 4]) == [3, 2]\nassert op_sorta_trimends_sortd([]) == []\nassert op_sorta_trimends_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sorta_trimends_sortd([5, 5, 5]) == [5]\nassert op_sorta_trimends_sortd([3, 1, 2]) == [2]\nassert op_sorta_trimends_sortd([10]) == []\nassert op_sorta_trimends_sortd([2, 4, 6]) == [4]\nassert op_sorta_trimends_sortd([-7, 12, -7]) == [-7]"}
{"id": "op_div3_clamp10_uniq", "entry_point": "op_div3_clamp10_uniq", "primitives": ["div3", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_div3_clamp10_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_clamp10_uniq([1, 2, 3, 4]) == [3]\nassert op_div3_clamp10_uniq([]) == []\nassert op_div3_clamp10_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_clamp10_uniq([5, 5, 5]) == []\nassert op_div3_clamp10_uniq([3, 1, 2]) == [3]\nassert op_div3_clamp10_uniq([10]) == []\nassert op_div3_clamp10_uniq([2, 4, 6]) == [6]\nassert op_div3_clamp10_uniq([-7, 12, -7]) == [10]"}
{"id": "op_dec_beforezero_dropzeros", "entry_point": "op_dec_beforezero_dropzeros", "primitives": ["dec", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then drop the zeros.", "solution": "def op_dec_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_beforezero_dropzeros([1, 2, 3, 4]) == []\nassert op_dec_beforezero_dropzeros([]) == []\nassert op_dec_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_beforezero_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_beforezero_dropzeros([3, 1, 2]) == [2]\nassert op_dec_beforezero_dropzeros([10]) == [9]\nassert op_dec_beforezero_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_dec_beforezero_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dec_pos_last3", "entry_point": "op_dec_pos_last3", "primitives": ["dec", "pos", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then keep only the last three.", "solution": "def op_dec_pos_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_pos_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_pos_last3([]) == []\nassert op_dec_pos_last3([-2, -1, 0, 1, 2]) == [1]\nassert op_dec_pos_last3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_pos_last3([3, 1, 2]) == [2, 1]\nassert op_dec_pos_last3([10]) == [9]\nassert op_dec_pos_last3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_pos_last3([-7, 12, -7]) == [11]"}
{"id": "op_uniq_div3_alldistinct", "entry_point": "op_uniq_div3_alldistinct", "primitives": ["uniq", "div3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then return whether all values are distinct.", "solution": "def op_uniq_div3_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_uniq_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_div3_alldistinct([]) == True\nassert op_uniq_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_uniq_div3_alldistinct([5, 5, 5]) == True\nassert op_uniq_div3_alldistinct([3, 1, 2]) == True\nassert op_uniq_div3_alldistinct([10]) == True\nassert op_uniq_div3_alldistinct([2, 4, 6]) == True\nassert op_uniq_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_neg_pos_inc", "entry_point": "op_neg_pos_inc", "primitives": ["neg", "pos", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers, then add one to each.", "solution": "def op_neg_pos_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_neg_pos_inc([1, 2, 3, 4]) == []\nassert op_neg_pos_inc([]) == []\nassert op_neg_pos_inc([-2, -1, 0, 1, 2]) == []\nassert op_neg_pos_inc([5, 5, 5]) == []\nassert op_neg_pos_inc([3, 1, 2]) == []\nassert op_neg_pos_inc([10]) == []\nassert op_neg_pos_inc([2, 4, 6]) == []\nassert op_neg_pos_inc([-7, 12, -7]) == []"}
{"id": "op_trimends_uniq_oremptyzero", "entry_point": "op_trimends_uniq_oremptyzero", "primitives": ["trimends", "uniq", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then if empty, use a single zero.", "solution": "def op_trimends_uniq_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_uniq_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_uniq_oremptyzero([]) == [0]\nassert op_trimends_uniq_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_uniq_oremptyzero([5, 5, 5]) == [5]\nassert op_trimends_uniq_oremptyzero([3, 1, 2]) == [1]\nassert op_trimends_uniq_oremptyzero([10]) == [0]\nassert op_trimends_uniq_oremptyzero([2, 4, 6]) == [4]\nassert op_trimends_uniq_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_padto3_dropwhileneg_odds", "entry_point": "op_padto3_dropwhileneg_odds", "primitives": ["padto3", "dropwhileneg", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then keep the odd numbers.", "solution": "def op_padto3_dropwhileneg_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_dropwhileneg_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_dropwhileneg_odds([]) == []\nassert op_padto3_dropwhileneg_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_padto3_dropwhileneg_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_dropwhileneg_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_dropwhileneg_odds([10]) == []\nassert op_padto3_dropwhileneg_odds([2, 4, 6]) == []\nassert op_padto3_dropwhileneg_odds([-7, 12, -7]) == [-7]"}
{"id": "op_neg_beforezero_dropfirst", "entry_point": "op_neg_beforezero_dropfirst", "primitives": ["neg", "beforezero", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then drop the first element.", "solution": "def op_neg_beforezero_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return r", "tests": "assert op_neg_beforezero_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_beforezero_dropfirst([]) == []\nassert op_neg_beforezero_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_beforezero_dropfirst([5, 5, 5]) == []\nassert op_neg_beforezero_dropfirst([3, 1, 2]) == []\nassert op_neg_beforezero_dropfirst([10]) == []\nassert op_neg_beforezero_dropfirst([2, 4, 6]) == []\nassert op_neg_beforezero_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_names_sortlen_prefixup", "entry_point": "op_names_sortlen_prefixup", "primitives": ["names", "sortlen", "prefixup"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort by length, shortest first, then prefix each with a hash.", "solution": "def op_names_sortlen_prefixup(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_names_sortlen_prefixup([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['#Bo', '#Ada']\nassert op_names_sortlen_prefixup([]) == []\nassert op_names_sortlen_prefixup([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['#Cy', '#El', '#Dee']\nassert op_names_sortlen_prefixup([{'name': 'Fi', 'age': 41}]) == ['#Fi']"}
{"id": "op_sortd_sorta_max", "entry_point": "op_sortd_sorta_max", "primitives": ["sortd", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_sortd_sorta_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_sortd_sorta_max([1, 2, 3, 4]) == 4\nassert op_sortd_sorta_max([]) == 0\nassert op_sortd_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_sorta_max([5, 5, 5]) == 5\nassert op_sortd_sorta_max([3, 1, 2]) == 3\nassert op_sortd_sorta_max([10]) == 10\nassert op_sortd_sorta_max([2, 4, 6]) == 6\nassert op_sortd_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_double_odds_haszero", "entry_point": "op_double_odds_haszero", "primitives": ["double", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_double_odds_haszero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_double_odds_haszero([1, 2, 3, 4]) == False\nassert op_double_odds_haszero([]) == False\nassert op_double_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_double_odds_haszero([5, 5, 5]) == False\nassert op_double_odds_haszero([3, 1, 2]) == False\nassert op_double_odds_haszero([10]) == False\nassert op_double_odds_haszero([2, 4, 6]) == False\nassert op_double_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_evens_takewhilepos", "entry_point": "op_div3_evens_takewhilepos", "primitives": ["div3", "evens", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then take values while they are positive.", "solution": "def op_div3_evens_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_evens_takewhilepos([1, 2, 3, 4]) == []\nassert op_div3_evens_takewhilepos([]) == []\nassert op_div3_evens_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_evens_takewhilepos([5, 5, 5]) == []\nassert op_div3_evens_takewhilepos([3, 1, 2]) == []\nassert op_div3_evens_takewhilepos([10]) == []\nassert op_div3_evens_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_inc_last3_rev", "entry_point": "op_inc_last3_rev", "primitives": ["inc", "last3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then reverse the order.", "solution": "def op_inc_last3_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_last3_rev([1, 2, 3, 4]) == [5, 4, 3]\nassert op_inc_last3_rev([]) == []\nassert op_inc_last3_rev([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_inc_last3_rev([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_rev([3, 1, 2]) == [3, 2, 4]\nassert op_inc_last3_rev([10]) == [11]\nassert op_inc_last3_rev([2, 4, 6]) == [7, 5, 3]\nassert op_inc_last3_rev([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_inc_dropzeros_absval", "entry_point": "op_inc_dropzeros_absval", "primitives": ["inc", "dropzeros", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then take the absolute value of each.", "solution": "def op_inc_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_inc_dropzeros_absval([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_dropzeros_absval([]) == []\nassert op_inc_dropzeros_absval([-2, -1, 0, 1, 2]) == [1, 1, 2, 3]\nassert op_inc_dropzeros_absval([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropzeros_absval([3, 1, 2]) == [4, 2, 3]\nassert op_inc_dropzeros_absval([10]) == [11]\nassert op_inc_dropzeros_absval([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropzeros_absval([-7, 12, -7]) == [6, 13, 6]"}
{"id": "op_div3_trimends_last3", "entry_point": "op_div3_trimends_last3", "primitives": ["div3", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then keep only the last three.", "solution": "def op_div3_trimends_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_trimends_last3([1, 2, 3, 4]) == []\nassert op_div3_trimends_last3([]) == []\nassert op_div3_trimends_last3([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends_last3([5, 5, 5]) == []\nassert op_div3_trimends_last3([3, 1, 2]) == []\nassert op_div3_trimends_last3([10]) == []\nassert op_div3_trimends_last3([2, 4, 6]) == []\nassert op_div3_trimends_last3([-7, 12, -7]) == []"}
{"id": "op_first3_odds_double", "entry_point": "op_first3_odds_double", "primitives": ["first3", "odds", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then double each.", "solution": "def op_first3_odds_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_odds_double([1, 2, 3, 4]) == [2, 6]\nassert op_first3_odds_double([]) == []\nassert op_first3_odds_double([-2, -1, 0, 1, 2]) == [-2]\nassert op_first3_odds_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_odds_double([3, 1, 2]) == [6, 2]\nassert op_first3_odds_double([10]) == []\nassert op_first3_odds_double([2, 4, 6]) == []\nassert op_first3_odds_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_first3_absval_sortabs", "entry_point": "op_first3_absval_sortabs", "primitives": ["first3", "absval", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then sort by absolute value.", "solution": "def op_first3_absval_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_absval_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_absval_sortabs([]) == []\nassert op_first3_absval_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_first3_absval_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_absval_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_absval_sortabs([10]) == [10]\nassert op_first3_absval_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_absval_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_first3_double_negate", "entry_point": "op_first3_double_negate", "primitives": ["first3", "double", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then negate each.", "solution": "def op_first3_double_negate(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_first3_double_negate([1, 2, 3, 4]) == [-2, -4, -6]\nassert op_first3_double_negate([]) == []\nassert op_first3_double_negate([-2, -1, 0, 1, 2]) == [4, 2, 0]\nassert op_first3_double_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_first3_double_negate([3, 1, 2]) == [-6, -2, -4]\nassert op_first3_double_negate([10]) == [-20]\nassert op_first3_double_negate([2, 4, 6]) == [-4, -8, -12]\nassert op_first3_double_negate([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_negate_gt5_div3", "entry_point": "op_negate_gt5_div3", "primitives": ["negate", "gt5", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then keep multiples of three.", "solution": "def op_negate_gt5_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_gt5_div3([1, 2, 3, 4]) == []\nassert op_negate_gt5_div3([]) == []\nassert op_negate_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_negate_gt5_div3([5, 5, 5]) == []\nassert op_negate_gt5_div3([3, 1, 2]) == []\nassert op_negate_gt5_div3([10]) == []\nassert op_negate_gt5_div3([2, 4, 6]) == []\nassert op_negate_gt5_div3([-7, 12, -7]) == []"}
{"id": "op_absval_dec_square", "entry_point": "op_absval_dec_square", "primitives": ["absval", "dec", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then square each.", "solution": "def op_absval_dec_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_dec_square([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_absval_dec_square([]) == []\nassert op_absval_dec_square([-2, -1, 0, 1, 2]) == [1, 0, 1, 0, 1]\nassert op_absval_dec_square([5, 5, 5]) == [16, 16, 16]\nassert op_absval_dec_square([3, 1, 2]) == [4, 0, 1]\nassert op_absval_dec_square([10]) == [81]\nassert op_absval_dec_square([2, 4, 6]) == [1, 9, 25]\nassert op_absval_dec_square([-7, 12, -7]) == [36, 121, 36]"}
{"id": "op_dec_padto3_dropwhileneg", "entry_point": "op_dec_padto3_dropwhileneg", "primitives": ["dec", "padto3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_dec_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_padto3_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_dec_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dec_padto3_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_dec_padto3_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_dec_padto3_dropwhileneg([10]) == [9, 0, 0]\nassert op_dec_padto3_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_dec_padto3_dropwhileneg([-7, 12, -7]) == [11, -8]"}
{"id": "op_inc_dropzeros_sortabs", "entry_point": "op_inc_dropzeros_sortabs", "primitives": ["inc", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then sort by absolute value.", "solution": "def op_inc_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_dropzeros_sortabs([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_dropzeros_sortabs([]) == []\nassert op_inc_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-1, 1, 2, 3]\nassert op_inc_dropzeros_sortabs([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropzeros_sortabs([3, 1, 2]) == [2, 3, 4]\nassert op_inc_dropzeros_sortabs([10]) == [11]\nassert op_inc_dropzeros_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropzeros_sortabs([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_dropshort_prefixup_counts", "entry_point": "op_dropshort_prefixup_counts", "primitives": ["dropshort", "prefixup", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then prefix each with a hash, then return how many strings remain.", "solution": "def op_dropshort_prefixup_counts(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    return len(r)", "tests": "assert op_dropshort_prefixup_counts(['Hello', 'world']) == 2\nassert op_dropshort_prefixup_counts([]) == 0\nassert op_dropshort_prefixup_counts(['  a ', '', 'BC', 'bc']) == 1\nassert op_dropshort_prefixup_counts(['one', 'one', 'Two']) == 3\nassert op_dropshort_prefixup_counts(['x']) == 0\nassert op_dropshort_prefixup_counts(['abc', 'de', '']) == 1"}
{"id": "op_takewhilepos_add10_odds", "entry_point": "op_takewhilepos_add10_odds", "primitives": ["takewhilepos", "add10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then keep the odd numbers.", "solution": "def op_takewhilepos_add10_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_add10_odds([1, 2, 3, 4]) == [11, 13]\nassert op_takewhilepos_add10_odds([]) == []\nassert op_takewhilepos_add10_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_add10_odds([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_add10_odds([3, 1, 2]) == [13, 11]\nassert op_takewhilepos_add10_odds([10]) == []\nassert op_takewhilepos_add10_odds([2, 4, 6]) == []\nassert op_takewhilepos_add10_odds([-7, 12, -7]) == []"}
{"id": "op_padto3_sorta_rev", "entry_point": "op_padto3_sorta_rev", "primitives": ["padto3", "sorta", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then reverse the order.", "solution": "def op_padto3_sorta_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_sorta_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_sorta_rev([]) == [0, 0, 0]\nassert op_padto3_sorta_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_padto3_sorta_rev([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sorta_rev([3, 1, 2]) == [3, 2, 1]\nassert op_padto3_sorta_rev([10]) == [10, 0, 0]\nassert op_padto3_sorta_rev([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_sorta_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_dropwhileneg_neg_evens", "entry_point": "op_dropwhileneg_neg_evens", "primitives": ["dropwhileneg", "neg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then keep the even numbers.", "solution": "def op_dropwhileneg_neg_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_neg_evens([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg_evens([]) == []\nassert op_dropwhileneg_neg_evens([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg_evens([5, 5, 5]) == []\nassert op_dropwhileneg_neg_evens([3, 1, 2]) == []\nassert op_dropwhileneg_neg_evens([10]) == []\nassert op_dropwhileneg_neg_evens([2, 4, 6]) == []\nassert op_dropwhileneg_neg_evens([-7, 12, -7]) == []"}
{"id": "op_trimends_inc_odds", "entry_point": "op_trimends_inc_odds", "primitives": ["trimends", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then keep the odd numbers.", "solution": "def op_trimends_inc_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_inc_odds([1, 2, 3, 4]) == [3]\nassert op_trimends_inc_odds([]) == []\nassert op_trimends_inc_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_inc_odds([5, 5, 5]) == []\nassert op_trimends_inc_odds([3, 1, 2]) == []\nassert op_trimends_inc_odds([10]) == []\nassert op_trimends_inc_odds([2, 4, 6]) == [5]\nassert op_trimends_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_sorta_sortabs_trimends", "entry_point": "op_sorta_sortabs_trimends", "primitives": ["sorta", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then drop the first and last elements.", "solution": "def op_sorta_sortabs_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_sortabs_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_sortabs_trimends([]) == []\nassert op_sorta_sortabs_trimends([-2, -1, 0, 1, 2]) == [-1, 1, -2]\nassert op_sorta_sortabs_trimends([5, 5, 5]) == [5]\nassert op_sorta_sortabs_trimends([3, 1, 2]) == [2]\nassert op_sorta_sortabs_trimends([10]) == []\nassert op_sorta_sortabs_trimends([2, 4, 6]) == [4]\nassert op_sorta_sortabs_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_inc_trimends_uniq", "entry_point": "op_inc_trimends_uniq", "primitives": ["inc", "trimends", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_inc_trimends_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_trimends_uniq([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends_uniq([]) == []\nassert op_inc_trimends_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends_uniq([5, 5, 5]) == [6]\nassert op_inc_trimends_uniq([3, 1, 2]) == [2]\nassert op_inc_trimends_uniq([10]) == []\nassert op_inc_trimends_uniq([2, 4, 6]) == [5]\nassert op_inc_trimends_uniq([-7, 12, -7]) == [13]"}
{"id": "op_takewhilepos_first3_sorta", "entry_point": "op_takewhilepos_first3_sorta", "primitives": ["takewhilepos", "first3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then sort ascending.", "solution": "def op_takewhilepos_first3_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_first3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_first3_sorta([]) == []\nassert op_takewhilepos_first3_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_first3_sorta([10]) == [10]\nassert op_takewhilepos_first3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_first3_sorta([-7, 12, -7]) == []"}
{"id": "op_first3_sortabs_last3", "entry_point": "op_first3_sortabs_last3", "primitives": ["first3", "sortabs", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then keep only the last three.", "solution": "def op_first3_sortabs_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_first3_sortabs_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs_last3([]) == []\nassert op_first3_sortabs_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sortabs_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_last3([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs_last3([10]) == [10]\nassert op_first3_sortabs_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropzeros_dec_double", "entry_point": "op_dropzeros_dec_double", "primitives": ["dropzeros", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then subtract one from each, then double each.", "solution": "def op_dropzeros_dec_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_dec_double([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_dropzeros_dec_double([]) == []\nassert op_dropzeros_dec_double([-2, -1, 0, 1, 2]) == [-6, -4, 0, 2]\nassert op_dropzeros_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_dropzeros_dec_double([3, 1, 2]) == [4, 0, 2]\nassert op_dropzeros_dec_double([10]) == [18]\nassert op_dropzeros_dec_double([2, 4, 6]) == [2, 6, 10]\nassert op_dropzeros_dec_double([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_add10_dropzeros_negate", "entry_point": "op_add10_dropzeros_negate", "primitives": ["add10", "dropzeros", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then negate each.", "solution": "def op_add10_dropzeros_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_dropzeros_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_add10_dropzeros_negate([]) == []\nassert op_add10_dropzeros_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_add10_dropzeros_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_dropzeros_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_add10_dropzeros_negate([10]) == [-20]\nassert op_add10_dropzeros_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_dropzeros_negate([-7, 12, -7]) == [-3, -22, -3]"}
{"id": "op_takewhilepos_pos_beforezero", "entry_point": "op_takewhilepos_pos_beforezero", "primitives": ["takewhilepos", "pos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then keep everything before the first zero.", "solution": "def op_takewhilepos_pos_beforezero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_takewhilepos_pos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_pos_beforezero([]) == []\nassert op_takewhilepos_pos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_pos_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_pos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_pos_beforezero([10]) == [10]\nassert op_takewhilepos_pos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_pos_beforezero([-7, 12, -7]) == []"}
{"id": "op_pos_first3_odds", "entry_point": "op_pos_first3_odds", "primitives": ["pos", "first3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then keep the odd numbers.", "solution": "def op_pos_first3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_pos_first3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_pos_first3_odds([]) == []\nassert op_pos_first3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_first3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_pos_first3_odds([3, 1, 2]) == [3, 1]\nassert op_pos_first3_odds([10]) == []\nassert op_pos_first3_odds([2, 4, 6]) == []\nassert op_pos_first3_odds([-7, 12, -7]) == []"}
{"id": "op_clamp10_beforezero_neg", "entry_point": "op_clamp10_beforezero_neg", "primitives": ["clamp10", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_clamp10_beforezero_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_beforezero_neg([1, 2, 3, 4]) == []\nassert op_clamp10_beforezero_neg([]) == []\nassert op_clamp10_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_beforezero_neg([5, 5, 5]) == []\nassert op_clamp10_beforezero_neg([3, 1, 2]) == []\nassert op_clamp10_beforezero_neg([10]) == []\nassert op_clamp10_beforezero_neg([2, 4, 6]) == []\nassert op_clamp10_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_first3_add10_uniq", "entry_point": "op_first3_add10_uniq", "primitives": ["first3", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_first3_add10_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_add10_uniq([1, 2, 3, 4]) == [11, 12, 13]\nassert op_first3_add10_uniq([]) == []\nassert op_first3_add10_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_first3_add10_uniq([5, 5, 5]) == [15]\nassert op_first3_add10_uniq([3, 1, 2]) == [13, 11, 12]\nassert op_first3_add10_uniq([10]) == [20]\nassert op_first3_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_first3_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_gt5_negate_add10", "entry_point": "op_gt5_negate_add10", "primitives": ["gt5", "negate", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then add ten to each.", "solution": "def op_gt5_negate_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_gt5_negate_add10([1, 2, 3, 4]) == []\nassert op_gt5_negate_add10([]) == []\nassert op_gt5_negate_add10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_add10([5, 5, 5]) == []\nassert op_gt5_negate_add10([3, 1, 2]) == []\nassert op_gt5_negate_add10([10]) == [0]\nassert op_gt5_negate_add10([2, 4, 6]) == [4]\nassert op_gt5_negate_add10([-7, 12, -7]) == [-2]"}
{"id": "op_rev_inc_prod", "entry_point": "op_rev_inc_prod", "primitives": ["rev", "inc", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then return their product.", "solution": "def op_rev_inc_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_rev_inc_prod([1, 2, 3, 4]) == 120\nassert op_rev_inc_prod([]) == 1\nassert op_rev_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_rev_inc_prod([5, 5, 5]) == 216\nassert op_rev_inc_prod([3, 1, 2]) == 24\nassert op_rev_inc_prod([10]) == 11\nassert op_rev_inc_prod([2, 4, 6]) == 105\nassert op_rev_inc_prod([-7, 12, -7]) == 468"}
{"id": "op_div3_square_sorta", "entry_point": "op_div3_square_sorta", "primitives": ["div3", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then sort ascending.", "solution": "def op_div3_square_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_square_sorta([1, 2, 3, 4]) == [9]\nassert op_div3_square_sorta([]) == []\nassert op_div3_square_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_square_sorta([5, 5, 5]) == []\nassert op_div3_square_sorta([3, 1, 2]) == [9]\nassert op_div3_square_sorta([10]) == []\nassert op_div3_square_sorta([2, 4, 6]) == [36]\nassert op_div3_square_sorta([-7, 12, -7]) == [144]"}
{"id": "op_neg_last3_len", "entry_point": "op_neg_last3_len", "primitives": ["neg", "last3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then return how many remain.", "solution": "def op_neg_last3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return len(r)", "tests": "assert op_neg_last3_len([1, 2, 3, 4]) == 0\nassert op_neg_last3_len([]) == 0\nassert op_neg_last3_len([-2, -1, 0, 1, 2]) == 2\nassert op_neg_last3_len([5, 5, 5]) == 0\nassert op_neg_last3_len([3, 1, 2]) == 0\nassert op_neg_last3_len([10]) == 0\nassert op_neg_last3_len([2, 4, 6]) == 0\nassert op_neg_last3_len([-7, 12, -7]) == 2"}
{"id": "op_takewhilepos_double_first3", "entry_point": "op_takewhilepos_double_first3", "primitives": ["takewhilepos", "double", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then keep only the first three.", "solution": "def op_takewhilepos_double_first3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_takewhilepos_double_first3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_takewhilepos_double_first3([]) == []\nassert op_takewhilepos_double_first3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double_first3([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_double_first3([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_double_first3([10]) == [20]\nassert op_takewhilepos_double_first3([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_double_first3([-7, 12, -7]) == []"}
{"id": "op_trimends_dropwhileneg_anyeven", "entry_point": "op_trimends_dropwhileneg_anyeven", "primitives": ["trimends", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values, then return whether any value is even.", "solution": "def op_trimends_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_trimends_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_trimends_dropwhileneg_anyeven([]) == False\nassert op_trimends_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_trimends_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_trimends_dropwhileneg_anyeven([3, 1, 2]) == False\nassert op_trimends_dropwhileneg_anyeven([10]) == False\nassert op_trimends_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_trimends_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_pos_counteven", "entry_point": "op_evens_pos_counteven", "primitives": ["evens", "pos", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers, then return how many values are even.", "solution": "def op_evens_pos_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_pos_counteven([1, 2, 3, 4]) == 2\nassert op_evens_pos_counteven([]) == 0\nassert op_evens_pos_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_evens_pos_counteven([5, 5, 5]) == 0\nassert op_evens_pos_counteven([3, 1, 2]) == 1\nassert op_evens_pos_counteven([10]) == 1\nassert op_evens_pos_counteven([2, 4, 6]) == 3\nassert op_evens_pos_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_dropfirst_dropwhileneg", "entry_point": "op_clamp10_dropfirst_dropwhileneg", "primitives": ["clamp10", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element, then drop the leading negative values.", "solution": "def op_clamp10_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_dropfirst_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_dropfirst_dropwhileneg([]) == []\nassert op_clamp10_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_dropfirst_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_clamp10_dropfirst_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_clamp10_dropfirst_dropwhileneg([10]) == []\nassert op_clamp10_dropfirst_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_clamp10_dropfirst_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_add10_last3_dec", "entry_point": "op_add10_last3_dec", "primitives": ["add10", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then subtract one from each.", "solution": "def op_add10_last3_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_last3_dec([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_last3_dec([]) == []\nassert op_add10_last3_dec([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_last3_dec([5, 5, 5]) == [14, 14, 14]\nassert op_add10_last3_dec([3, 1, 2]) == [12, 10, 11]\nassert op_add10_last3_dec([10]) == [19]\nassert op_add10_last3_dec([2, 4, 6]) == [11, 13, 15]\nassert op_add10_last3_dec([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_sorta_dec_anyeven", "entry_point": "op_sorta_dec_anyeven", "primitives": ["sorta", "dec", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then return whether any value is even.", "solution": "def op_sorta_dec_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_dec_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_dec_anyeven([]) == False\nassert op_sorta_dec_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_dec_anyeven([5, 5, 5]) == True\nassert op_sorta_dec_anyeven([3, 1, 2]) == True\nassert op_sorta_dec_anyeven([10]) == False\nassert op_sorta_dec_anyeven([2, 4, 6]) == False\nassert op_sorta_dec_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_uniq_firsteven", "entry_point": "op_sorta_uniq_firsteven", "primitives": ["sorta", "uniq", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_sorta_uniq_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_uniq_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_uniq_firsteven([]) == 0\nassert op_sorta_uniq_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_uniq_firsteven([5, 5, 5]) == 0\nassert op_sorta_uniq_firsteven([3, 1, 2]) == 2\nassert op_sorta_uniq_firsteven([10]) == 10\nassert op_sorta_uniq_firsteven([2, 4, 6]) == 2\nassert op_sorta_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_square_add10_double", "entry_point": "op_square_add10_double", "primitives": ["square", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add ten to each, then double each.", "solution": "def op_square_add10_double(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_square_add10_double([1, 2, 3, 4]) == [22, 28, 38, 52]\nassert op_square_add10_double([]) == []\nassert op_square_add10_double([-2, -1, 0, 1, 2]) == [28, 22, 20, 22, 28]\nassert op_square_add10_double([5, 5, 5]) == [70, 70, 70]\nassert op_square_add10_double([3, 1, 2]) == [38, 22, 28]\nassert op_square_add10_double([10]) == [220]\nassert op_square_add10_double([2, 4, 6]) == [28, 52, 92]\nassert op_square_add10_double([-7, 12, -7]) == [118, 308, 118]"}
{"id": "op_takewhilepos_gt5_uniq", "entry_point": "op_takewhilepos_gt5_uniq", "primitives": ["takewhilepos", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_gt5_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_gt5_uniq([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_uniq([]) == []\nassert op_takewhilepos_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_uniq([5, 5, 5]) == []\nassert op_takewhilepos_gt5_uniq([3, 1, 2]) == []\nassert op_takewhilepos_gt5_uniq([10]) == [10]\nassert op_takewhilepos_gt5_uniq([2, 4, 6]) == [6]\nassert op_takewhilepos_gt5_uniq([-7, 12, -7]) == []"}
{"id": "op_first3_absval_div3", "entry_point": "op_first3_absval_div3", "primitives": ["first3", "absval", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then keep multiples of three.", "solution": "def op_first3_absval_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_absval_div3([1, 2, 3, 4]) == [3]\nassert op_first3_absval_div3([]) == []\nassert op_first3_absval_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_absval_div3([5, 5, 5]) == []\nassert op_first3_absval_div3([3, 1, 2]) == [3]\nassert op_first3_absval_div3([10]) == []\nassert op_first3_absval_div3([2, 4, 6]) == [6]\nassert op_first3_absval_div3([-7, 12, -7]) == [12]"}
{"id": "op_ages_absval_negate", "entry_point": "op_ages_absval_negate", "primitives": ["ages", "absval", "negate"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then negate each.", "solution": "def op_ages_absval_negate(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_ages_absval_negate([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_absval_negate([]) == []\nassert op_ages_absval_negate([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_absval_negate([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_rev_sortabs_first3", "entry_point": "op_rev_sortabs_first3", "primitives": ["rev", "sortabs", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then keep only the first three.", "solution": "def op_rev_sortabs_first3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_rev_sortabs_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_rev_sortabs_first3([]) == []\nassert op_rev_sortabs_first3([-2, -1, 0, 1, 2]) == [0, 1, -1]\nassert op_rev_sortabs_first3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortabs_first3([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sortabs_first3([10]) == [10]\nassert op_rev_sortabs_first3([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sortabs_first3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_firstchar_lower_counts", "entry_point": "op_firstchar_lower_counts", "primitives": ["firstchar", "lower", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then lowercase each string, then return how many strings remain.", "solution": "def op_firstchar_lower_counts(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.lower() for s in r]\n    return len(r)", "tests": "assert op_firstchar_lower_counts(['Hello', 'world']) == 2\nassert op_firstchar_lower_counts([]) == 0\nassert op_firstchar_lower_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_firstchar_lower_counts(['one', 'one', 'Two']) == 3\nassert op_firstchar_lower_counts(['x']) == 1\nassert op_firstchar_lower_counts(['abc', 'de', '']) == 2"}
{"id": "op_square_negate_gt5", "entry_point": "op_square_negate_gt5", "primitives": ["square", "negate", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then negate each, then keep values greater than five.", "solution": "def op_square_negate_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_negate_gt5([1, 2, 3, 4]) == []\nassert op_square_negate_gt5([]) == []\nassert op_square_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_negate_gt5([5, 5, 5]) == []\nassert op_square_negate_gt5([3, 1, 2]) == []\nassert op_square_negate_gt5([10]) == []\nassert op_square_negate_gt5([2, 4, 6]) == []\nassert op_square_negate_gt5([-7, 12, -7]) == []"}
{"id": "op_odds_evens_dec", "entry_point": "op_odds_evens_dec", "primitives": ["odds", "evens", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then subtract one from each.", "solution": "def op_odds_evens_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_odds_evens_dec([1, 2, 3, 4]) == []\nassert op_odds_evens_dec([]) == []\nassert op_odds_evens_dec([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_dec([5, 5, 5]) == []\nassert op_odds_evens_dec([3, 1, 2]) == []\nassert op_odds_evens_dec([10]) == []\nassert op_odds_evens_dec([2, 4, 6]) == []\nassert op_odds_evens_dec([-7, 12, -7]) == []"}
{"id": "op_gt5_last3_sum", "entry_point": "op_gt5_last3_sum", "primitives": ["gt5", "last3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three, then return their sum.", "solution": "def op_gt5_last3_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_gt5_last3_sum([1, 2, 3, 4]) == 0\nassert op_gt5_last3_sum([]) == 0\nassert op_gt5_last3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_last3_sum([5, 5, 5]) == 0\nassert op_gt5_last3_sum([3, 1, 2]) == 0\nassert op_gt5_last3_sum([10]) == 10\nassert op_gt5_last3_sum([2, 4, 6]) == 6\nassert op_gt5_last3_sum([-7, 12, -7]) == 12"}
{"id": "op_absval_sortd_odds", "entry_point": "op_absval_sortd_odds", "primitives": ["absval", "sortd", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then keep the odd numbers.", "solution": "def op_absval_sortd_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_sortd_odds([1, 2, 3, 4]) == [3, 1]\nassert op_absval_sortd_odds([]) == []\nassert op_absval_sortd_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_sortd_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortd_odds([3, 1, 2]) == [3, 1]\nassert op_absval_sortd_odds([10]) == []\nassert op_absval_sortd_odds([2, 4, 6]) == []\nassert op_absval_sortd_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_sortalpha_prefixup_counts", "entry_point": "op_sortalpha_prefixup_counts", "primitives": ["sortalpha", "prefixup", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then prefix each with a hash, then return how many strings remain.", "solution": "def op_sortalpha_prefixup_counts(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = ['#' + s for s in r]\n    return len(r)", "tests": "assert op_sortalpha_prefixup_counts(['Hello', 'world']) == 2\nassert op_sortalpha_prefixup_counts([]) == 0\nassert op_sortalpha_prefixup_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_prefixup_counts(['one', 'one', 'Two']) == 3\nassert op_sortalpha_prefixup_counts(['x']) == 1\nassert op_sortalpha_prefixup_counts(['abc', 'de', '']) == 3"}
{"id": "op_negate_beforezero_prod", "entry_point": "op_negate_beforezero_prod", "primitives": ["negate", "beforezero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then return their product.", "solution": "def op_negate_beforezero_prod(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_negate_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_negate_beforezero_prod([]) == 1\nassert op_negate_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_negate_beforezero_prod([5, 5, 5]) == -125\nassert op_negate_beforezero_prod([3, 1, 2]) == -6\nassert op_negate_beforezero_prod([10]) == -10\nassert op_negate_beforezero_prod([2, 4, 6]) == -48\nassert op_negate_beforezero_prod([-7, 12, -7]) == -588"}
{"id": "op_last3_dec_neg", "entry_point": "op_last3_dec_neg", "primitives": ["last3", "dec", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then keep the negative numbers.", "solution": "def op_last3_dec_neg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_last3_dec_neg([1, 2, 3, 4]) == []\nassert op_last3_dec_neg([]) == []\nassert op_last3_dec_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_last3_dec_neg([5, 5, 5]) == []\nassert op_last3_dec_neg([3, 1, 2]) == []\nassert op_last3_dec_neg([10]) == []\nassert op_last3_dec_neg([2, 4, 6]) == []\nassert op_last3_dec_neg([-7, 12, -7]) == [-8, -8]"}
{"id": "op_div3_rev_beforezero", "entry_point": "op_div3_rev_beforezero", "primitives": ["div3", "rev", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then keep everything before the first zero.", "solution": "def op_div3_rev_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_rev_beforezero([1, 2, 3, 4]) == [3]\nassert op_div3_rev_beforezero([]) == []\nassert op_div3_rev_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_rev_beforezero([5, 5, 5]) == []\nassert op_div3_rev_beforezero([3, 1, 2]) == [3]\nassert op_div3_rev_beforezero([10]) == []\nassert op_div3_rev_beforezero([2, 4, 6]) == [6]\nassert op_div3_rev_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_padto3_last3_trimends", "entry_point": "op_padto3_last3_trimends", "primitives": ["padto3", "last3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then drop the first and last elements.", "solution": "def op_padto3_last3_trimends(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = r[1:-1]\n    return r", "tests": "assert op_padto3_last3_trimends([1, 2, 3, 4]) == [3]\nassert op_padto3_last3_trimends([]) == [0]\nassert op_padto3_last3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_padto3_last3_trimends([5, 5, 5]) == [5]\nassert op_padto3_last3_trimends([3, 1, 2]) == [1]\nassert op_padto3_last3_trimends([10]) == [0]\nassert op_padto3_last3_trimends([2, 4, 6]) == [4]\nassert op_padto3_last3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_uniq_beforezero_gt5", "entry_point": "op_uniq_beforezero_gt5", "primitives": ["uniq", "beforezero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_uniq_beforezero_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_uniq_beforezero_gt5([]) == []\nassert op_uniq_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_beforezero_gt5([5, 5, 5]) == []\nassert op_uniq_beforezero_gt5([3, 1, 2]) == []\nassert op_uniq_beforezero_gt5([10]) == [10]\nassert op_uniq_beforezero_gt5([2, 4, 6]) == [6]\nassert op_uniq_beforezero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_add10_oremptyzero_prod", "entry_point": "op_add10_oremptyzero_prod", "primitives": ["add10", "oremptyzero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then return their product.", "solution": "def op_add10_oremptyzero_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_add10_oremptyzero_prod([1, 2, 3, 4]) == 24024\nassert op_add10_oremptyzero_prod([]) == 0\nassert op_add10_oremptyzero_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_oremptyzero_prod([5, 5, 5]) == 3375\nassert op_add10_oremptyzero_prod([3, 1, 2]) == 1716\nassert op_add10_oremptyzero_prod([10]) == 20\nassert op_add10_oremptyzero_prod([2, 4, 6]) == 2688\nassert op_add10_oremptyzero_prod([-7, 12, -7]) == 198"}
{"id": "op_takewhilepos_dropwhileneg_oremptyzero", "entry_point": "op_takewhilepos_dropwhileneg_oremptyzero", "primitives": ["takewhilepos", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_takewhilepos_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_dropwhileneg_oremptyzero([]) == [0]\nassert op_takewhilepos_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_dropwhileneg_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropwhileneg_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropwhileneg_oremptyzero([10]) == [10]\nassert op_takewhilepos_dropwhileneg_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropwhileneg_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_last3_rev_sorta", "entry_point": "op_last3_rev_sorta", "primitives": ["last3", "rev", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then sort ascending.", "solution": "def op_last3_rev_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = sorted(r)\n    return r", "tests": "assert op_last3_rev_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_rev_sorta([]) == []\nassert op_last3_rev_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_rev_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_rev_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_rev_sorta([10]) == [10]\nassert op_last3_rev_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_rev_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_inc_sortabs_anyeven", "entry_point": "op_inc_sortabs_anyeven", "primitives": ["inc", "sortabs", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then return whether any value is even.", "solution": "def op_inc_sortabs_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_sortabs_anyeven([1, 2, 3, 4]) == True\nassert op_inc_sortabs_anyeven([]) == False\nassert op_inc_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_sortabs_anyeven([5, 5, 5]) == True\nassert op_inc_sortabs_anyeven([3, 1, 2]) == True\nassert op_inc_sortabs_anyeven([10]) == False\nassert op_inc_sortabs_anyeven([2, 4, 6]) == False\nassert op_inc_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_negate_first3", "entry_point": "op_absval_negate_first3", "primitives": ["absval", "negate", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then keep only the first three.", "solution": "def op_absval_negate_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_absval_negate_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_absval_negate_first3([]) == []\nassert op_absval_negate_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_absval_negate_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_absval_negate_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_absval_negate_first3([10]) == [-10]\nassert op_absval_negate_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_absval_negate_first3([-7, 12, -7]) == [-7, -12, -7]"}
{"id": "op_div3_absval_gt5", "entry_point": "op_div3_absval_gt5", "primitives": ["div3", "absval", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take the absolute value of each, then keep values greater than five.", "solution": "def op_div3_absval_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_absval_gt5([1, 2, 3, 4]) == []\nassert op_div3_absval_gt5([]) == []\nassert op_div3_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_absval_gt5([5, 5, 5]) == []\nassert op_div3_absval_gt5([3, 1, 2]) == []\nassert op_div3_absval_gt5([10]) == []\nassert op_div3_absval_gt5([2, 4, 6]) == [6]\nassert op_div3_absval_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortd_sortabs_prod", "entry_point": "op_sortd_sortabs_prod", "primitives": ["sortd", "sortabs", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then return their product.", "solution": "def op_sortd_sortabs_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_sortd_sortabs_prod([1, 2, 3, 4]) == 24\nassert op_sortd_sortabs_prod([]) == 1\nassert op_sortd_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_sortabs_prod([5, 5, 5]) == 125\nassert op_sortd_sortabs_prod([3, 1, 2]) == 6\nassert op_sortd_sortabs_prod([10]) == 10\nassert op_sortd_sortabs_prod([2, 4, 6]) == 48\nassert op_sortd_sortabs_prod([-7, 12, -7]) == 588"}
{"id": "op_double_first3_sum", "entry_point": "op_double_first3_sum", "primitives": ["double", "first3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three, then return their sum.", "solution": "def op_double_first3_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return sum(r)", "tests": "assert op_double_first3_sum([1, 2, 3, 4]) == 12\nassert op_double_first3_sum([]) == 0\nassert op_double_first3_sum([-2, -1, 0, 1, 2]) == -6\nassert op_double_first3_sum([5, 5, 5]) == 30\nassert op_double_first3_sum([3, 1, 2]) == 12\nassert op_double_first3_sum([10]) == 20\nassert op_double_first3_sum([2, 4, 6]) == 24\nassert op_double_first3_sum([-7, 12, -7]) == -4"}
{"id": "op_pos_beforezero_neg", "entry_point": "op_pos_beforezero_neg", "primitives": ["pos", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_pos_beforezero_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_pos_beforezero_neg([1, 2, 3, 4]) == []\nassert op_pos_beforezero_neg([]) == []\nassert op_pos_beforezero_neg([-2, -1, 0, 1, 2]) == []\nassert op_pos_beforezero_neg([5, 5, 5]) == []\nassert op_pos_beforezero_neg([3, 1, 2]) == []\nassert op_pos_beforezero_neg([10]) == []\nassert op_pos_beforezero_neg([2, 4, 6]) == []\nassert op_pos_beforezero_neg([-7, 12, -7]) == []"}
{"id": "op_neg_last3_first3", "entry_point": "op_neg_last3_first3", "primitives": ["neg", "last3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then keep only the first three.", "solution": "def op_neg_last3_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_neg_last3_first3([1, 2, 3, 4]) == []\nassert op_neg_last3_first3([]) == []\nassert op_neg_last3_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_last3_first3([5, 5, 5]) == []\nassert op_neg_last3_first3([3, 1, 2]) == []\nassert op_neg_last3_first3([10]) == []\nassert op_neg_last3_first3([2, 4, 6]) == []\nassert op_neg_last3_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_uniq_anyeven", "entry_point": "op_square_uniq_anyeven", "primitives": ["square", "uniq", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_square_uniq_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_square_uniq_anyeven([]) == False\nassert op_square_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_uniq_anyeven([5, 5, 5]) == False\nassert op_square_uniq_anyeven([3, 1, 2]) == True\nassert op_square_uniq_anyeven([10]) == True\nassert op_square_uniq_anyeven([2, 4, 6]) == True\nassert op_square_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_dropwhileneg_square", "entry_point": "op_sortd_dropwhileneg_square", "primitives": ["sortd", "dropwhileneg", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then square each.", "solution": "def op_sortd_dropwhileneg_square(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortd_dropwhileneg_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_dropwhileneg_square([]) == []\nassert op_sortd_dropwhileneg_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sortd_dropwhileneg_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_dropwhileneg_square([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_dropwhileneg_square([10]) == [100]\nassert op_sortd_dropwhileneg_square([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_dropwhileneg_square([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_div3_add10_dropzeros", "entry_point": "op_div3_add10_dropzeros", "primitives": ["div3", "add10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each, then drop the zeros.", "solution": "def op_div3_add10_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_div3_add10_dropzeros([1, 2, 3, 4]) == [13]\nassert op_div3_add10_dropzeros([]) == []\nassert op_div3_add10_dropzeros([-2, -1, 0, 1, 2]) == [10]\nassert op_div3_add10_dropzeros([5, 5, 5]) == []\nassert op_div3_add10_dropzeros([3, 1, 2]) == [13]\nassert op_div3_add10_dropzeros([10]) == []\nassert op_div3_add10_dropzeros([2, 4, 6]) == [16]\nassert op_div3_add10_dropzeros([-7, 12, -7]) == [22]"}
{"id": "op_pos_dec_square", "entry_point": "op_pos_dec_square", "primitives": ["pos", "dec", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then square each.", "solution": "def op_pos_dec_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_dec_square([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_pos_dec_square([]) == []\nassert op_pos_dec_square([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_dec_square([5, 5, 5]) == [16, 16, 16]\nassert op_pos_dec_square([3, 1, 2]) == [4, 0, 1]\nassert op_pos_dec_square([10]) == [81]\nassert op_pos_dec_square([2, 4, 6]) == [1, 9, 25]\nassert op_pos_dec_square([-7, 12, -7]) == [121]"}
{"id": "op_odds_sortabs_issorted", "entry_point": "op_odds_sortabs_issorted", "primitives": ["odds", "sortabs", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_odds_sortabs_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_odds_sortabs_issorted([1, 2, 3, 4]) == True\nassert op_odds_sortabs_issorted([]) == True\nassert op_odds_sortabs_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_sortabs_issorted([5, 5, 5]) == True\nassert op_odds_sortabs_issorted([3, 1, 2]) == True\nassert op_odds_sortabs_issorted([10]) == True\nassert op_odds_sortabs_issorted([2, 4, 6]) == True\nassert op_odds_sortabs_issorted([-7, 12, -7]) == True"}
{"id": "op_evens_double_first3", "entry_point": "op_evens_double_first3", "primitives": ["evens", "double", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then keep only the first three.", "solution": "def op_evens_double_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_evens_double_first3([1, 2, 3, 4]) == [4, 8]\nassert op_evens_double_first3([]) == []\nassert op_evens_double_first3([-2, -1, 0, 1, 2]) == [-4, 0, 4]\nassert op_evens_double_first3([5, 5, 5]) == []\nassert op_evens_double_first3([3, 1, 2]) == [4]\nassert op_evens_double_first3([10]) == [20]\nassert op_evens_double_first3([2, 4, 6]) == [4, 8, 12]\nassert op_evens_double_first3([-7, 12, -7]) == [24]"}
{"id": "op_sortabs_dropzeros_len", "entry_point": "op_sortabs_dropzeros_len", "primitives": ["sortabs", "dropzeros", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then return how many remain.", "solution": "def op_sortabs_dropzeros_len(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_sortabs_dropzeros_len([1, 2, 3, 4]) == 4\nassert op_sortabs_dropzeros_len([]) == 0\nassert op_sortabs_dropzeros_len([-2, -1, 0, 1, 2]) == 4\nassert op_sortabs_dropzeros_len([5, 5, 5]) == 3\nassert op_sortabs_dropzeros_len([3, 1, 2]) == 3\nassert op_sortabs_dropzeros_len([10]) == 1\nassert op_sortabs_dropzeros_len([2, 4, 6]) == 3\nassert op_sortabs_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_square_last3_firsteven", "entry_point": "op_square_last3_firsteven", "primitives": ["square", "last3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then return the first even value (0 if none).", "solution": "def op_square_last3_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_last3_firsteven([1, 2, 3, 4]) == 4\nassert op_square_last3_firsteven([]) == 0\nassert op_square_last3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_square_last3_firsteven([5, 5, 5]) == 0\nassert op_square_last3_firsteven([3, 1, 2]) == 4\nassert op_square_last3_firsteven([10]) == 100\nassert op_square_last3_firsteven([2, 4, 6]) == 4\nassert op_square_last3_firsteven([-7, 12, -7]) == 144"}
{"id": "op_div3_evens_max", "entry_point": "op_div3_evens_max", "primitives": ["div3", "evens", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_div3_evens_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_div3_evens_max([1, 2, 3, 4]) == 0\nassert op_div3_evens_max([]) == 0\nassert op_div3_evens_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_evens_max([5, 5, 5]) == 0\nassert op_div3_evens_max([3, 1, 2]) == 0\nassert op_div3_evens_max([10]) == 0\nassert op_div3_evens_max([2, 4, 6]) == 6\nassert op_div3_evens_max([-7, 12, -7]) == 12"}
{"id": "op_div3_square_anyeven", "entry_point": "op_div3_square_anyeven", "primitives": ["div3", "square", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then return whether any value is even.", "solution": "def op_div3_square_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_square_anyeven([1, 2, 3, 4]) == False\nassert op_div3_square_anyeven([]) == False\nassert op_div3_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_div3_square_anyeven([5, 5, 5]) == False\nassert op_div3_square_anyeven([3, 1, 2]) == False\nassert op_div3_square_anyeven([10]) == False\nassert op_div3_square_anyeven([2, 4, 6]) == True\nassert op_div3_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_first3_prod", "entry_point": "op_clamp10_first3_prod", "primitives": ["clamp10", "first3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the first three, then return their product.", "solution": "def op_clamp10_first3_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_first3_prod([1, 2, 3, 4]) == 6\nassert op_clamp10_first3_prod([]) == 1\nassert op_clamp10_first3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_first3_prod([5, 5, 5]) == 125\nassert op_clamp10_first3_prod([3, 1, 2]) == 6\nassert op_clamp10_first3_prod([10]) == 10\nassert op_clamp10_first3_prod([2, 4, 6]) == 48\nassert op_clamp10_first3_prod([-7, 12, -7]) == 490"}
{"id": "op_trimends_dec_sorta", "entry_point": "op_trimends_dec_sorta", "primitives": ["trimends", "dec", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then sort ascending.", "solution": "def op_trimends_dec_sorta(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_trimends_dec_sorta([1, 2, 3, 4]) == [1, 2]\nassert op_trimends_dec_sorta([]) == []\nassert op_trimends_dec_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_trimends_dec_sorta([5, 5, 5]) == [4]\nassert op_trimends_dec_sorta([3, 1, 2]) == [0]\nassert op_trimends_dec_sorta([10]) == []\nassert op_trimends_dec_sorta([2, 4, 6]) == [3]\nassert op_trimends_dec_sorta([-7, 12, -7]) == [11]"}
{"id": "op_dropwhileneg_inc_sortd", "entry_point": "op_dropwhileneg_inc_sortd", "primitives": ["dropwhileneg", "inc", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then sort descending.", "solution": "def op_dropwhileneg_inc_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_inc_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_dropwhileneg_inc_sortd([]) == []\nassert op_dropwhileneg_inc_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_dropwhileneg_inc_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_inc_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_dropwhileneg_inc_sortd([10]) == [11]\nassert op_dropwhileneg_inc_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_dropwhileneg_inc_sortd([-7, 12, -7]) == [13, -6]"}
{"id": "op_sortabs_oremptyzero_gt5", "entry_point": "op_sortabs_oremptyzero_gt5", "primitives": ["sortabs", "oremptyzero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then keep values greater than five.", "solution": "def op_sortabs_oremptyzero_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_oremptyzero_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_oremptyzero_gt5([]) == []\nassert op_sortabs_oremptyzero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_oremptyzero_gt5([5, 5, 5]) == []\nassert op_sortabs_oremptyzero_gt5([3, 1, 2]) == []\nassert op_sortabs_oremptyzero_gt5([10]) == [10]\nassert op_sortabs_oremptyzero_gt5([2, 4, 6]) == [6]\nassert op_sortabs_oremptyzero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_sorta_odds", "entry_point": "op_dropwhileneg_sorta_odds", "primitives": ["dropwhileneg", "sorta", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort ascending, then keep the odd numbers.", "solution": "def op_dropwhileneg_sorta_odds(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropwhileneg_sorta_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropwhileneg_sorta_odds([]) == []\nassert op_dropwhileneg_sorta_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_sorta_odds([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sorta_odds([3, 1, 2]) == [1, 3]\nassert op_dropwhileneg_sorta_odds([10]) == []\nassert op_dropwhileneg_sorta_odds([2, 4, 6]) == []\nassert op_dropwhileneg_sorta_odds([-7, 12, -7]) == [-7]"}
{"id": "op_dropzeros_takewhilepos_beforezero", "entry_point": "op_dropzeros_takewhilepos_beforezero", "primitives": ["dropzeros", "takewhilepos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_dropzeros_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_takewhilepos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_takewhilepos_beforezero([]) == []\nassert op_dropzeros_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos_beforezero([10]) == [10]\nassert op_dropzeros_takewhilepos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos_beforezero([-7, 12, -7]) == []"}
{"id": "op_first3_sortabs_dropzeros", "entry_point": "op_first3_sortabs_dropzeros", "primitives": ["first3", "sortabs", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then drop the zeros.", "solution": "def op_first3_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_first3_sortabs_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortabs_dropzeros([]) == []\nassert op_first3_sortabs_dropzeros([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_first3_sortabs_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortabs_dropzeros([10]) == [10]\nassert op_first3_sortabs_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortabs_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_double_inc_rev", "entry_point": "op_double_inc_rev", "primitives": ["double", "inc", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each, then reverse the order.", "solution": "def op_double_inc_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_inc_rev([1, 2, 3, 4]) == [9, 7, 5, 3]\nassert op_double_inc_rev([]) == []\nassert op_double_inc_rev([-2, -1, 0, 1, 2]) == [5, 3, 1, -1, -3]\nassert op_double_inc_rev([5, 5, 5]) == [11, 11, 11]\nassert op_double_inc_rev([3, 1, 2]) == [5, 3, 7]\nassert op_double_inc_rev([10]) == [21]\nassert op_double_inc_rev([2, 4, 6]) == [13, 9, 5]\nassert op_double_inc_rev([-7, 12, -7]) == [-13, 25, -13]"}
{"id": "op_gt5_uniq_clamp10", "entry_point": "op_gt5_uniq_clamp10", "primitives": ["gt5", "uniq", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_gt5_uniq_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_uniq_clamp10([1, 2, 3, 4]) == []\nassert op_gt5_uniq_clamp10([]) == []\nassert op_gt5_uniq_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_uniq_clamp10([5, 5, 5]) == []\nassert op_gt5_uniq_clamp10([3, 1, 2]) == []\nassert op_gt5_uniq_clamp10([10]) == [10]\nassert op_gt5_uniq_clamp10([2, 4, 6]) == [6]\nassert op_gt5_uniq_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_ages_dropfirst_padto3", "entry_point": "op_ages_dropfirst_padto3", "primitives": ["ages", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_ages_dropfirst_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_dropfirst_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 0, 0]\nassert op_ages_dropfirst_padto3([]) == [0, 0, 0]\nassert op_ages_dropfirst_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17, 0]\nassert op_ages_dropfirst_padto3([{'name': 'Fi', 'age': 41}]) == [0, 0, 0]"}
{"id": "op_gt5_sortabs_trimends", "entry_point": "op_gt5_sortabs_trimends", "primitives": ["gt5", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then drop the first and last elements.", "solution": "def op_gt5_sortabs_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_sortabs_trimends([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_trimends([]) == []\nassert op_gt5_sortabs_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_trimends([5, 5, 5]) == []\nassert op_gt5_sortabs_trimends([3, 1, 2]) == []\nassert op_gt5_sortabs_trimends([10]) == []\nassert op_gt5_sortabs_trimends([2, 4, 6]) == []\nassert op_gt5_sortabs_trimends([-7, 12, -7]) == []"}
{"id": "op_double_clamp10_dropzeros", "entry_point": "op_double_clamp10_dropzeros", "primitives": ["double", "clamp10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then cap each value at 10, then drop the zeros.", "solution": "def op_double_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_clamp10_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_clamp10_dropzeros([]) == []\nassert op_double_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_clamp10_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_double_clamp10_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_double_clamp10_dropzeros([10]) == [10]\nassert op_double_clamp10_dropzeros([2, 4, 6]) == [4, 8, 10]\nassert op_double_clamp10_dropzeros([-7, 12, -7]) == [-14, 10, -14]"}
{"id": "op_inc_evens_rev", "entry_point": "op_inc_evens_rev", "primitives": ["inc", "evens", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then reverse the order.", "solution": "def op_inc_evens_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_inc_evens_rev([]) == []\nassert op_inc_evens_rev([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_inc_evens_rev([5, 5, 5]) == [6, 6, 6]\nassert op_inc_evens_rev([3, 1, 2]) == [2, 4]\nassert op_inc_evens_rev([10]) == []\nassert op_inc_evens_rev([2, 4, 6]) == []\nassert op_inc_evens_rev([-7, 12, -7]) == [-6, -6]"}
{"id": "op_square_sortd_add10", "entry_point": "op_square_sortd_add10", "primitives": ["square", "sortd", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then add ten to each.", "solution": "def op_square_sortd_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_sortd_add10([1, 2, 3, 4]) == [26, 19, 14, 11]\nassert op_square_sortd_add10([]) == []\nassert op_square_sortd_add10([-2, -1, 0, 1, 2]) == [14, 14, 11, 11, 10]\nassert op_square_sortd_add10([5, 5, 5]) == [35, 35, 35]\nassert op_square_sortd_add10([3, 1, 2]) == [19, 14, 11]\nassert op_square_sortd_add10([10]) == [110]\nassert op_square_sortd_add10([2, 4, 6]) == [46, 26, 14]\nassert op_square_sortd_add10([-7, 12, -7]) == [154, 59, 59]"}
{"id": "op_dropwhileneg_uniq_sortd", "entry_point": "op_dropwhileneg_uniq_sortd", "primitives": ["dropwhileneg", "uniq", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_dropwhileneg_uniq_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_uniq_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_uniq_sortd([]) == []\nassert op_dropwhileneg_uniq_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_uniq_sortd([5, 5, 5]) == [5]\nassert op_dropwhileneg_uniq_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropwhileneg_uniq_sortd([10]) == [10]\nassert op_dropwhileneg_uniq_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_uniq_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortd_dropwhileneg_inc", "entry_point": "op_sortd_dropwhileneg_inc", "primitives": ["sortd", "dropwhileneg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then add one to each.", "solution": "def op_sortd_dropwhileneg_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_dropwhileneg_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_dropwhileneg_inc([]) == []\nassert op_sortd_dropwhileneg_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sortd_dropwhileneg_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_dropwhileneg_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_dropwhileneg_inc([10]) == [11]\nassert op_sortd_dropwhileneg_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_dropwhileneg_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_evens_sortabs_alldistinct", "entry_point": "op_evens_sortabs_alldistinct", "primitives": ["evens", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_evens_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_evens_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_evens_sortabs_alldistinct([]) == True\nassert op_evens_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_evens_sortabs_alldistinct([5, 5, 5]) == True\nassert op_evens_sortabs_alldistinct([3, 1, 2]) == True\nassert op_evens_sortabs_alldistinct([10]) == True\nassert op_evens_sortabs_alldistinct([2, 4, 6]) == True\nassert op_evens_sortabs_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortabs_div3_counteven", "entry_point": "op_sortabs_div3_counteven", "primitives": ["sortabs", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then return how many values are even.", "solution": "def op_sortabs_div3_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortabs_div3_counteven([1, 2, 3, 4]) == 0\nassert op_sortabs_div3_counteven([]) == 0\nassert op_sortabs_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_sortabs_div3_counteven([5, 5, 5]) == 0\nassert op_sortabs_div3_counteven([3, 1, 2]) == 0\nassert op_sortabs_div3_counteven([10]) == 0\nassert op_sortabs_div3_counteven([2, 4, 6]) == 1\nassert op_sortabs_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_uniq_beforezero_neg", "entry_point": "op_uniq_beforezero_neg", "primitives": ["uniq", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_uniq_beforezero_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_beforezero_neg([1, 2, 3, 4]) == []\nassert op_uniq_beforezero_neg([]) == []\nassert op_uniq_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_beforezero_neg([5, 5, 5]) == []\nassert op_uniq_beforezero_neg([3, 1, 2]) == []\nassert op_uniq_beforezero_neg([10]) == []\nassert op_uniq_beforezero_neg([2, 4, 6]) == []\nassert op_uniq_beforezero_neg([-7, 12, -7]) == [-7]"}
{"id": "op_div3_double_takewhilepos", "entry_point": "op_div3_double_takewhilepos", "primitives": ["div3", "double", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then take values while they are positive.", "solution": "def op_div3_double_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_double_takewhilepos([1, 2, 3, 4]) == [6]\nassert op_div3_double_takewhilepos([]) == []\nassert op_div3_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_takewhilepos([5, 5, 5]) == []\nassert op_div3_double_takewhilepos([3, 1, 2]) == [6]\nassert op_div3_double_takewhilepos([10]) == []\nassert op_div3_double_takewhilepos([2, 4, 6]) == [12]\nassert op_div3_double_takewhilepos([-7, 12, -7]) == [24]"}
{"id": "op_absval_gt5_uniq", "entry_point": "op_absval_gt5_uniq", "primitives": ["absval", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_absval_gt5_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_gt5_uniq([1, 2, 3, 4]) == []\nassert op_absval_gt5_uniq([]) == []\nassert op_absval_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_uniq([5, 5, 5]) == []\nassert op_absval_gt5_uniq([3, 1, 2]) == []\nassert op_absval_gt5_uniq([10]) == [10]\nassert op_absval_gt5_uniq([2, 4, 6]) == [6]\nassert op_absval_gt5_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_evens_rev_double", "entry_point": "op_evens_rev_double", "primitives": ["evens", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then double each.", "solution": "def op_evens_rev_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_rev_double([1, 2, 3, 4]) == [8, 4]\nassert op_evens_rev_double([]) == []\nassert op_evens_rev_double([-2, -1, 0, 1, 2]) == [4, 0, -4]\nassert op_evens_rev_double([5, 5, 5]) == []\nassert op_evens_rev_double([3, 1, 2]) == [4]\nassert op_evens_rev_double([10]) == [20]\nassert op_evens_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_evens_rev_double([-7, 12, -7]) == [24]"}
{"id": "op_sortd_last3_allpos", "entry_point": "op_sortd_last3_allpos", "primitives": ["sortd", "last3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three, then return whether all values are positive.", "solution": "def op_sortd_last3_allpos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_sortd_last3_allpos([1, 2, 3, 4]) == True\nassert op_sortd_last3_allpos([]) == True\nassert op_sortd_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortd_last3_allpos([5, 5, 5]) == True\nassert op_sortd_last3_allpos([3, 1, 2]) == True\nassert op_sortd_last3_allpos([10]) == True\nassert op_sortd_last3_allpos([2, 4, 6]) == True\nassert op_sortd_last3_allpos([-7, 12, -7]) == False"}
{"id": "op_beforezero_rev_oremptyzero", "entry_point": "op_beforezero_rev_oremptyzero", "primitives": ["beforezero", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then if empty, use a single zero.", "solution": "def op_beforezero_rev_oremptyzero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_beforezero_rev_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_rev_oremptyzero([]) == [0]\nassert op_beforezero_rev_oremptyzero([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_rev_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_rev_oremptyzero([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_rev_oremptyzero([10]) == [10]\nassert op_beforezero_rev_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_rev_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_evens_dropwhileneg_max", "entry_point": "op_evens_dropwhileneg_max", "primitives": ["evens", "dropwhileneg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_evens_dropwhileneg_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_evens_dropwhileneg_max([1, 2, 3, 4]) == 4\nassert op_evens_dropwhileneg_max([]) == 0\nassert op_evens_dropwhileneg_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_dropwhileneg_max([5, 5, 5]) == 0\nassert op_evens_dropwhileneg_max([3, 1, 2]) == 2\nassert op_evens_dropwhileneg_max([10]) == 10\nassert op_evens_dropwhileneg_max([2, 4, 6]) == 6\nassert op_evens_dropwhileneg_max([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_negate_dropzeros", "entry_point": "op_dropfirst_negate_dropzeros", "primitives": ["dropfirst", "negate", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then drop the zeros.", "solution": "def op_dropfirst_negate_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_negate_dropzeros([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropfirst_negate_dropzeros([]) == []\nassert op_dropfirst_negate_dropzeros([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_dropfirst_negate_dropzeros([5, 5, 5]) == [-5, -5]\nassert op_dropfirst_negate_dropzeros([3, 1, 2]) == [-1, -2]\nassert op_dropfirst_negate_dropzeros([10]) == []\nassert op_dropfirst_negate_dropzeros([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_negate_dropzeros([-7, 12, -7]) == [-12, 7]"}
{"id": "op_absval_neg_allpos", "entry_point": "op_absval_neg_allpos", "primitives": ["absval", "neg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the negative numbers, then return whether all values are positive.", "solution": "def op_absval_neg_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_neg_allpos([1, 2, 3, 4]) == True\nassert op_absval_neg_allpos([]) == True\nassert op_absval_neg_allpos([-2, -1, 0, 1, 2]) == True\nassert op_absval_neg_allpos([5, 5, 5]) == True\nassert op_absval_neg_allpos([3, 1, 2]) == True\nassert op_absval_neg_allpos([10]) == True\nassert op_absval_neg_allpos([2, 4, 6]) == True\nassert op_absval_neg_allpos([-7, 12, -7]) == True"}
{"id": "op_pos_uniq_negate", "entry_point": "op_pos_uniq_negate", "primitives": ["pos", "uniq", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_pos_uniq_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_uniq_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_uniq_negate([]) == []\nassert op_pos_uniq_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_uniq_negate([5, 5, 5]) == [-5]\nassert op_pos_uniq_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_pos_uniq_negate([10]) == [-10]\nassert op_pos_uniq_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_uniq_negate([-7, 12, -7]) == [-12]"}
{"id": "op_oremptyzero_dropfirst_neg", "entry_point": "op_oremptyzero_dropfirst_neg", "primitives": ["oremptyzero", "dropfirst", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then keep the negative numbers.", "solution": "def op_oremptyzero_dropfirst_neg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_oremptyzero_dropfirst_neg([1, 2, 3, 4]) == []\nassert op_oremptyzero_dropfirst_neg([]) == []\nassert op_oremptyzero_dropfirst_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_oremptyzero_dropfirst_neg([5, 5, 5]) == []\nassert op_oremptyzero_dropfirst_neg([3, 1, 2]) == []\nassert op_oremptyzero_dropfirst_neg([10]) == []\nassert op_oremptyzero_dropfirst_neg([2, 4, 6]) == []\nassert op_oremptyzero_dropfirst_neg([-7, 12, -7]) == [-7]"}
{"id": "op_takewhilepos_trimends_allpos", "entry_point": "op_takewhilepos_trimends_allpos", "primitives": ["takewhilepos", "trimends", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_takewhilepos_trimends_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_trimends_allpos([1, 2, 3, 4]) == True\nassert op_takewhilepos_trimends_allpos([]) == True\nassert op_takewhilepos_trimends_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_trimends_allpos([5, 5, 5]) == True\nassert op_takewhilepos_trimends_allpos([3, 1, 2]) == True\nassert op_takewhilepos_trimends_allpos([10]) == True\nassert op_takewhilepos_trimends_allpos([2, 4, 6]) == True\nassert op_takewhilepos_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_last3_add10_gt5", "entry_point": "op_last3_add10_gt5", "primitives": ["last3", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then keep values greater than five.", "solution": "def op_last3_add10_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_add10_gt5([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10_gt5([]) == []\nassert op_last3_add10_gt5([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_last3_add10_gt5([10]) == [20]\nassert op_last3_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_div3_padto3_dec", "entry_point": "op_div3_padto3_dec", "primitives": ["div3", "padto3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then subtract one from each.", "solution": "def op_div3_padto3_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_padto3_dec([1, 2, 3, 4]) == [2, -1, -1]\nassert op_div3_padto3_dec([]) == [-1, -1, -1]\nassert op_div3_padto3_dec([-2, -1, 0, 1, 2]) == [-1, -1, -1]\nassert op_div3_padto3_dec([5, 5, 5]) == [-1, -1, -1]\nassert op_div3_padto3_dec([3, 1, 2]) == [2, -1, -1]\nassert op_div3_padto3_dec([10]) == [-1, -1, -1]\nassert op_div3_padto3_dec([2, 4, 6]) == [5, -1, -1]\nassert op_div3_padto3_dec([-7, 12, -7]) == [11, -1, -1]"}
{"id": "op_ages_gt5_oremptyzero", "entry_point": "op_ages_gt5_oremptyzero", "primitives": ["ages", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_ages_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_gt5_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_gt5_oremptyzero([]) == [0]\nassert op_ages_gt5_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_gt5_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropzeros_neg_firsteven", "entry_point": "op_dropzeros_neg_firsteven", "primitives": ["dropzeros", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_dropzeros_neg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_dropzeros_neg_firsteven([]) == 0\nassert op_dropzeros_neg_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_neg_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_neg_firsteven([3, 1, 2]) == 0\nassert op_dropzeros_neg_firsteven([10]) == 0\nassert op_dropzeros_neg_firsteven([2, 4, 6]) == 0\nassert op_dropzeros_neg_firsteven([-7, 12, -7]) == 0"}
{"id": "op_clamp10_div3_anyeven", "entry_point": "op_clamp10_div3_anyeven", "primitives": ["clamp10", "div3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep multiples of three, then return whether any value is even.", "solution": "def op_clamp10_div3_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_div3_anyeven([1, 2, 3, 4]) == False\nassert op_clamp10_div3_anyeven([]) == False\nassert op_clamp10_div3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_div3_anyeven([5, 5, 5]) == False\nassert op_clamp10_div3_anyeven([3, 1, 2]) == False\nassert op_clamp10_div3_anyeven([10]) == False\nassert op_clamp10_div3_anyeven([2, 4, 6]) == True\nassert op_clamp10_div3_anyeven([-7, 12, -7]) == False"}
{"id": "op_dec_odds_alldistinct", "entry_point": "op_dec_odds_alldistinct", "primitives": ["dec", "odds", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the odd numbers, then return whether all values are distinct.", "solution": "def op_dec_odds_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_dec_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_odds_alldistinct([]) == True\nassert op_dec_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_odds_alldistinct([5, 5, 5]) == True\nassert op_dec_odds_alldistinct([3, 1, 2]) == True\nassert op_dec_odds_alldistinct([10]) == True\nassert op_dec_odds_alldistinct([2, 4, 6]) == True\nassert op_dec_odds_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropzeros_div3_min", "entry_point": "op_dropzeros_div3_min", "primitives": ["dropzeros", "div3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_dropzeros_div3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_dropzeros_div3_min([1, 2, 3, 4]) == 3\nassert op_dropzeros_div3_min([]) == 0\nassert op_dropzeros_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_div3_min([5, 5, 5]) == 0\nassert op_dropzeros_div3_min([3, 1, 2]) == 3\nassert op_dropzeros_div3_min([10]) == 0\nassert op_dropzeros_div3_min([2, 4, 6]) == 6\nassert op_dropzeros_div3_min([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_neg_beforezero", "entry_point": "op_oremptyzero_neg_beforezero", "primitives": ["oremptyzero", "neg", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then keep everything before the first zero.", "solution": "def op_oremptyzero_neg_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_neg_beforezero([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg_beforezero([]) == []\nassert op_oremptyzero_neg_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_neg_beforezero([5, 5, 5]) == []\nassert op_oremptyzero_neg_beforezero([3, 1, 2]) == []\nassert op_oremptyzero_neg_beforezero([10]) == []\nassert op_oremptyzero_neg_beforezero([2, 4, 6]) == []\nassert op_oremptyzero_neg_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dec_trimends_counteven", "entry_point": "op_dec_trimends_counteven", "primitives": ["dec", "trimends", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first and last elements, then return how many values are even.", "solution": "def op_dec_trimends_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_dec_trimends_counteven([]) == 0\nassert op_dec_trimends_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dec_trimends_counteven([5, 5, 5]) == 1\nassert op_dec_trimends_counteven([3, 1, 2]) == 1\nassert op_dec_trimends_counteven([10]) == 0\nassert op_dec_trimends_counteven([2, 4, 6]) == 0\nassert op_dec_trimends_counteven([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_last3_len", "entry_point": "op_dropzeros_last3_len", "primitives": ["dropzeros", "last3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then return how many remain.", "solution": "def op_dropzeros_last3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return len(r)", "tests": "assert op_dropzeros_last3_len([1, 2, 3, 4]) == 3\nassert op_dropzeros_last3_len([]) == 0\nassert op_dropzeros_last3_len([-2, -1, 0, 1, 2]) == 3\nassert op_dropzeros_last3_len([5, 5, 5]) == 3\nassert op_dropzeros_last3_len([3, 1, 2]) == 3\nassert op_dropzeros_last3_len([10]) == 1\nassert op_dropzeros_last3_len([2, 4, 6]) == 3\nassert op_dropzeros_last3_len([-7, 12, -7]) == 3"}
{"id": "op_sortabs_last3_uniq", "entry_point": "op_sortabs_last3_uniq", "primitives": ["sortabs", "last3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the last three, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_last3_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_last3_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_last3_uniq([]) == []\nassert op_sortabs_last3_uniq([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_sortabs_last3_uniq([5, 5, 5]) == [5]\nassert op_sortabs_last3_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_last3_uniq([10]) == [10]\nassert op_sortabs_last3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_last3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_pos_trimends_div3", "entry_point": "op_pos_trimends_div3", "primitives": ["pos", "trimends", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then keep multiples of three.", "solution": "def op_pos_trimends_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_pos_trimends_div3([1, 2, 3, 4]) == [3]\nassert op_pos_trimends_div3([]) == []\nassert op_pos_trimends_div3([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_div3([5, 5, 5]) == []\nassert op_pos_trimends_div3([3, 1, 2]) == []\nassert op_pos_trimends_div3([10]) == []\nassert op_pos_trimends_div3([2, 4, 6]) == []\nassert op_pos_trimends_div3([-7, 12, -7]) == []"}
{"id": "op_dropzeros_evens_allpos", "entry_point": "op_dropzeros_evens_allpos", "primitives": ["dropzeros", "evens", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then return whether all values are positive.", "solution": "def op_dropzeros_evens_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dropzeros_evens_allpos([1, 2, 3, 4]) == True\nassert op_dropzeros_evens_allpos([]) == True\nassert op_dropzeros_evens_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_evens_allpos([5, 5, 5]) == True\nassert op_dropzeros_evens_allpos([3, 1, 2]) == True\nassert op_dropzeros_evens_allpos([10]) == True\nassert op_dropzeros_evens_allpos([2, 4, 6]) == True\nassert op_dropzeros_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_gt5_pos", "entry_point": "op_inc_gt5_pos", "primitives": ["inc", "gt5", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then keep the positive numbers.", "solution": "def op_inc_gt5_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_gt5_pos([1, 2, 3, 4]) == []\nassert op_inc_gt5_pos([]) == []\nassert op_inc_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5_pos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_gt5_pos([3, 1, 2]) == []\nassert op_inc_gt5_pos([10]) == [11]\nassert op_inc_gt5_pos([2, 4, 6]) == [7]\nassert op_inc_gt5_pos([-7, 12, -7]) == [13]"}
{"id": "op_inc_dropfirst_sortd", "entry_point": "op_inc_dropfirst_sortd", "primitives": ["inc", "dropfirst", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first element, then sort descending.", "solution": "def op_inc_dropfirst_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_dropfirst_sortd([1, 2, 3, 4]) == [5, 4, 3]\nassert op_inc_dropfirst_sortd([]) == []\nassert op_inc_dropfirst_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 0]\nassert op_inc_dropfirst_sortd([5, 5, 5]) == [6, 6]\nassert op_inc_dropfirst_sortd([3, 1, 2]) == [3, 2]\nassert op_inc_dropfirst_sortd([10]) == []\nassert op_inc_dropfirst_sortd([2, 4, 6]) == [7, 5]\nassert op_inc_dropfirst_sortd([-7, 12, -7]) == [13, -6]"}
{"id": "op_sortabs_dropzeros_inc", "entry_point": "op_sortabs_dropzeros_inc", "primitives": ["sortabs", "dropzeros", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then add one to each.", "solution": "def op_sortabs_dropzeros_inc(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortabs_dropzeros_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_dropzeros_inc([]) == []\nassert op_sortabs_dropzeros_inc([-2, -1, 0, 1, 2]) == [0, 2, -1, 3]\nassert op_sortabs_dropzeros_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_dropzeros_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_dropzeros_inc([10]) == [11]\nassert op_sortabs_dropzeros_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_dropzeros_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_sorta_dropwhileneg_len", "entry_point": "op_sorta_dropwhileneg_len", "primitives": ["sorta", "dropwhileneg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then return how many remain.", "solution": "def op_sorta_dropwhileneg_len(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r)", "tests": "assert op_sorta_dropwhileneg_len([1, 2, 3, 4]) == 4\nassert op_sorta_dropwhileneg_len([]) == 0\nassert op_sorta_dropwhileneg_len([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_dropwhileneg_len([5, 5, 5]) == 3\nassert op_sorta_dropwhileneg_len([3, 1, 2]) == 3\nassert op_sorta_dropwhileneg_len([10]) == 1\nassert op_sorta_dropwhileneg_len([2, 4, 6]) == 3\nassert op_sorta_dropwhileneg_len([-7, 12, -7]) == 1"}
{"id": "op_last3_beforezero_anyeven", "entry_point": "op_last3_beforezero_anyeven", "primitives": ["last3", "beforezero", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then return whether any value is even.", "solution": "def op_last3_beforezero_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_beforezero_anyeven([1, 2, 3, 4]) == True\nassert op_last3_beforezero_anyeven([]) == False\nassert op_last3_beforezero_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_last3_beforezero_anyeven([5, 5, 5]) == False\nassert op_last3_beforezero_anyeven([3, 1, 2]) == True\nassert op_last3_beforezero_anyeven([10]) == True\nassert op_last3_beforezero_anyeven([2, 4, 6]) == True\nassert op_last3_beforezero_anyeven([-7, 12, -7]) == True"}
{"id": "op_padto3_rev_first3", "entry_point": "op_padto3_rev_first3", "primitives": ["padto3", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order, then keep only the first three.", "solution": "def op_padto3_rev_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_padto3_rev_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_padto3_rev_first3([]) == [0, 0, 0]\nassert op_padto3_rev_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_padto3_rev_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_rev_first3([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_rev_first3([10]) == [0, 0, 10]\nassert op_padto3_rev_first3([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_rev_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_pos_negate_sum", "entry_point": "op_pos_negate_sum", "primitives": ["pos", "negate", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then return their sum.", "solution": "def op_pos_negate_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_pos_negate_sum([1, 2, 3, 4]) == -10\nassert op_pos_negate_sum([]) == 0\nassert op_pos_negate_sum([-2, -1, 0, 1, 2]) == -3\nassert op_pos_negate_sum([5, 5, 5]) == -15\nassert op_pos_negate_sum([3, 1, 2]) == -6\nassert op_pos_negate_sum([10]) == -10\nassert op_pos_negate_sum([2, 4, 6]) == -12\nassert op_pos_negate_sum([-7, 12, -7]) == -12"}
{"id": "op_div3_clamp10_gt5", "entry_point": "op_div3_clamp10_gt5", "primitives": ["div3", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then keep values greater than five.", "solution": "def op_div3_clamp10_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_div3_clamp10_gt5([]) == []\nassert op_div3_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_clamp10_gt5([5, 5, 5]) == []\nassert op_div3_clamp10_gt5([3, 1, 2]) == []\nassert op_div3_clamp10_gt5([10]) == []\nassert op_div3_clamp10_gt5([2, 4, 6]) == [6]\nassert op_div3_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_dropwhileneg_first3_beforezero", "entry_point": "op_dropwhileneg_first3_beforezero", "primitives": ["dropwhileneg", "first3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then keep everything before the first zero.", "solution": "def op_dropwhileneg_first3_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_first3_beforezero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropwhileneg_first3_beforezero([]) == []\nassert op_dropwhileneg_first3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_first3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_first3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_first3_beforezero([10]) == [10]\nassert op_dropwhileneg_first3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_first3_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortabs_div3_allpos", "entry_point": "op_sortabs_div3_allpos", "primitives": ["sortabs", "div3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then return whether all values are positive.", "solution": "def op_sortabs_div3_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_div3_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_div3_allpos([]) == True\nassert op_sortabs_div3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_div3_allpos([5, 5, 5]) == True\nassert op_sortabs_div3_allpos([3, 1, 2]) == True\nassert op_sortabs_div3_allpos([10]) == True\nassert op_sortabs_div3_allpos([2, 4, 6]) == True\nassert op_sortabs_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_uniq_dropzeros", "entry_point": "op_sorta_uniq_dropzeros", "primitives": ["sorta", "uniq", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_sorta_uniq_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_uniq_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_uniq_dropzeros([]) == []\nassert op_sorta_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_sorta_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_sorta_uniq_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_uniq_dropzeros([10]) == [10]\nassert op_sorta_uniq_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_uniq_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_absval_neg_haszero", "entry_point": "op_absval_neg_haszero", "primitives": ["absval", "neg", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the negative numbers, then return whether the list contains a zero.", "solution": "def op_absval_neg_haszero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return 0 in r", "tests": "assert op_absval_neg_haszero([1, 2, 3, 4]) == False\nassert op_absval_neg_haszero([]) == False\nassert op_absval_neg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_absval_neg_haszero([5, 5, 5]) == False\nassert op_absval_neg_haszero([3, 1, 2]) == False\nassert op_absval_neg_haszero([10]) == False\nassert op_absval_neg_haszero([2, 4, 6]) == False\nassert op_absval_neg_haszero([-7, 12, -7]) == False"}
{"id": "op_div3_sorta_gt5", "entry_point": "op_div3_sorta_gt5", "primitives": ["div3", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending, then keep values greater than five.", "solution": "def op_div3_sorta_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_sorta_gt5([1, 2, 3, 4]) == []\nassert op_div3_sorta_gt5([]) == []\nassert op_div3_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_sorta_gt5([5, 5, 5]) == []\nassert op_div3_sorta_gt5([3, 1, 2]) == []\nassert op_div3_sorta_gt5([10]) == []\nassert op_div3_sorta_gt5([2, 4, 6]) == [6]\nassert op_div3_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_clamp10_pos", "entry_point": "op_beforezero_clamp10_pos", "primitives": ["beforezero", "clamp10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cap each value at 10, then keep the positive numbers.", "solution": "def op_beforezero_clamp10_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_clamp10_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_clamp10_pos([]) == []\nassert op_beforezero_clamp10_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_clamp10_pos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_clamp10_pos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_clamp10_pos([10]) == [10]\nassert op_beforezero_clamp10_pos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_clamp10_pos([-7, 12, -7]) == [10]"}
{"id": "op_add10_gt5_negate", "entry_point": "op_add10_gt5_negate", "primitives": ["add10", "gt5", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then negate each.", "solution": "def op_add10_gt5_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_gt5_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_add10_gt5_negate([]) == []\nassert op_add10_gt5_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_add10_gt5_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_gt5_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_add10_gt5_negate([10]) == [-20]\nassert op_add10_gt5_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_gt5_negate([-7, 12, -7]) == [-22]"}
{"id": "op_last3_absval_negate", "entry_point": "op_last3_absval_negate", "primitives": ["last3", "absval", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then negate each.", "solution": "def op_last3_absval_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_absval_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_absval_negate([]) == []\nassert op_last3_absval_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_absval_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_absval_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_last3_absval_negate([10]) == [-10]\nassert op_last3_absval_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_absval_negate([-7, 12, -7]) == [-7, -12, -7]"}
{"id": "op_sortabs_takewhilepos_alldistinct", "entry_point": "op_sortabs_takewhilepos_alldistinct", "primitives": ["sortabs", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_sortabs_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_takewhilepos_alldistinct([]) == True\nassert op_sortabs_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_sortabs_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_sortabs_takewhilepos_alldistinct([10]) == True\nassert op_sortabs_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_sortabs_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_beforezero_last3_rev", "entry_point": "op_beforezero_last3_rev", "primitives": ["beforezero", "last3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then reverse the order.", "solution": "def op_beforezero_last3_rev(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_beforezero_last3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_beforezero_last3_rev([]) == []\nassert op_beforezero_last3_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_last3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_last3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_last3_rev([10]) == [10]\nassert op_beforezero_last3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_last3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_trimends_absval", "entry_point": "op_rev_trimends_absval", "primitives": ["rev", "trimends", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_rev_trimends_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_trimends_absval([1, 2, 3, 4]) == [3, 2]\nassert op_rev_trimends_absval([]) == []\nassert op_rev_trimends_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_rev_trimends_absval([5, 5, 5]) == [5]\nassert op_rev_trimends_absval([3, 1, 2]) == [1]\nassert op_rev_trimends_absval([10]) == []\nassert op_rev_trimends_absval([2, 4, 6]) == [4]\nassert op_rev_trimends_absval([-7, 12, -7]) == [12]"}
{"id": "op_rev_last3_sorta", "entry_point": "op_rev_last3_sorta", "primitives": ["rev", "last3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then sort ascending.", "solution": "def op_rev_last3_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_rev_last3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_rev_last3_sorta([]) == []\nassert op_rev_last3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_rev_last3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_rev_last3_sorta([10]) == [10]\nassert op_rev_last3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_rev_last3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_uniq_sorta_sortabs", "entry_point": "op_uniq_sorta_sortabs", "primitives": ["uniq", "sorta", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then sort by absolute value.", "solution": "def op_uniq_sorta_sortabs(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_uniq_sorta_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sorta_sortabs([]) == []\nassert op_uniq_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_uniq_sorta_sortabs([5, 5, 5]) == [5]\nassert op_uniq_sorta_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sorta_sortabs([10]) == [10]\nassert op_uniq_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sorta_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sorta_dropzeros_neg", "entry_point": "op_sorta_dropzeros_neg", "primitives": ["sorta", "dropzeros", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then keep the negative numbers.", "solution": "def op_sorta_dropzeros_neg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sorta_dropzeros_neg([1, 2, 3, 4]) == []\nassert op_sorta_dropzeros_neg([]) == []\nassert op_sorta_dropzeros_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_dropzeros_neg([5, 5, 5]) == []\nassert op_sorta_dropzeros_neg([3, 1, 2]) == []\nassert op_sorta_dropzeros_neg([10]) == []\nassert op_sorta_dropzeros_neg([2, 4, 6]) == []\nassert op_sorta_dropzeros_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_absval_max", "entry_point": "op_dropwhileneg_absval_max", "primitives": ["dropwhileneg", "absval", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_absval_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_absval_max([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_absval_max([]) == 0\nassert op_dropwhileneg_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_absval_max([5, 5, 5]) == 5\nassert op_dropwhileneg_absval_max([3, 1, 2]) == 3\nassert op_dropwhileneg_absval_max([10]) == 10\nassert op_dropwhileneg_absval_max([2, 4, 6]) == 6\nassert op_dropwhileneg_absval_max([-7, 12, -7]) == 12"}
{"id": "op_neg_add10_counteven", "entry_point": "op_neg_add10_counteven", "primitives": ["neg", "add10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then return how many values are even.", "solution": "def op_neg_add10_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_add10_counteven([1, 2, 3, 4]) == 0\nassert op_neg_add10_counteven([]) == 0\nassert op_neg_add10_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_add10_counteven([5, 5, 5]) == 0\nassert op_neg_add10_counteven([3, 1, 2]) == 0\nassert op_neg_add10_counteven([10]) == 0\nassert op_neg_add10_counteven([2, 4, 6]) == 0\nassert op_neg_add10_counteven([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_beforezero_anyeven", "entry_point": "op_dropfirst_beforezero_anyeven", "primitives": ["dropfirst", "beforezero", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then return whether any value is even.", "solution": "def op_dropfirst_beforezero_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_beforezero_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_beforezero_anyeven([]) == False\nassert op_dropfirst_beforezero_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_beforezero_anyeven([5, 5, 5]) == False\nassert op_dropfirst_beforezero_anyeven([3, 1, 2]) == True\nassert op_dropfirst_beforezero_anyeven([10]) == False\nassert op_dropfirst_beforezero_anyeven([2, 4, 6]) == True\nassert op_dropfirst_beforezero_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_negate_max", "entry_point": "op_last3_negate_max", "primitives": ["last3", "negate", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then return the maximum (0 if empty).", "solution": "def op_last3_negate_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    return max(r) if r else 0", "tests": "assert op_last3_negate_max([1, 2, 3, 4]) == -2\nassert op_last3_negate_max([]) == 0\nassert op_last3_negate_max([-2, -1, 0, 1, 2]) == 0\nassert op_last3_negate_max([5, 5, 5]) == -5\nassert op_last3_negate_max([3, 1, 2]) == -1\nassert op_last3_negate_max([10]) == -10\nassert op_last3_negate_max([2, 4, 6]) == -2\nassert op_last3_negate_max([-7, 12, -7]) == 7"}
{"id": "op_add10_clamp10_firsteven", "entry_point": "op_add10_clamp10_firsteven", "primitives": ["add10", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_add10_clamp10_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_clamp10_firsteven([1, 2, 3, 4]) == 10\nassert op_add10_clamp10_firsteven([]) == 0\nassert op_add10_clamp10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_add10_clamp10_firsteven([5, 5, 5]) == 10\nassert op_add10_clamp10_firsteven([3, 1, 2]) == 10\nassert op_add10_clamp10_firsteven([10]) == 10\nassert op_add10_clamp10_firsteven([2, 4, 6]) == 10\nassert op_add10_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_negate_square_takewhilepos", "entry_point": "op_negate_square_takewhilepos", "primitives": ["negate", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then take values while they are positive.", "solution": "def op_negate_square_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_square_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_square_takewhilepos([]) == []\nassert op_negate_square_takewhilepos([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_negate_square_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_negate_square_takewhilepos([3, 1, 2]) == [9, 1, 4]\nassert op_negate_square_takewhilepos([10]) == [100]\nassert op_negate_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_negate_square_takewhilepos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_uniq_sortd_odds", "entry_point": "op_uniq_sortd_odds", "primitives": ["uniq", "sortd", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then keep the odd numbers.", "solution": "def op_uniq_sortd_odds(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_uniq_sortd_odds([1, 2, 3, 4]) == [3, 1]\nassert op_uniq_sortd_odds([]) == []\nassert op_uniq_sortd_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_uniq_sortd_odds([5, 5, 5]) == [5]\nassert op_uniq_sortd_odds([3, 1, 2]) == [3, 1]\nassert op_uniq_sortd_odds([10]) == []\nassert op_uniq_sortd_odds([2, 4, 6]) == []\nassert op_uniq_sortd_odds([-7, 12, -7]) == [-7]"}
{"id": "op_sortd_sorta_div3", "entry_point": "op_sortd_sorta_div3", "primitives": ["sortd", "sorta", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then keep multiples of three.", "solution": "def op_sortd_sorta_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_sorta_div3([1, 2, 3, 4]) == [3]\nassert op_sortd_sorta_div3([]) == []\nassert op_sortd_sorta_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_sorta_div3([5, 5, 5]) == []\nassert op_sortd_sorta_div3([3, 1, 2]) == [3]\nassert op_sortd_sorta_div3([10]) == []\nassert op_sortd_sorta_div3([2, 4, 6]) == [6]\nassert op_sortd_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_lower_sortalpha_nonempty", "entry_point": "op_lower_sortalpha_nonempty", "primitives": ["lower", "sortalpha", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort alphabetically, then drop empty strings.", "solution": "def op_lower_sortalpha_nonempty(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_lower_sortalpha_nonempty(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortalpha_nonempty([]) == []\nassert op_lower_sortalpha_nonempty(['  a ', '', 'BC', 'bc']) == ['  a ', 'bc', 'bc']\nassert op_lower_sortalpha_nonempty(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_sortalpha_nonempty(['x']) == ['x']\nassert op_lower_sortalpha_nonempty(['abc', 'de', '']) == ['abc', 'de']"}
{"id": "op_inc_takewhilepos_prod", "entry_point": "op_inc_takewhilepos_prod", "primitives": ["inc", "takewhilepos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive, then return their product.", "solution": "def op_inc_takewhilepos_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_inc_takewhilepos_prod([1, 2, 3, 4]) == 120\nassert op_inc_takewhilepos_prod([]) == 1\nassert op_inc_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_inc_takewhilepos_prod([5, 5, 5]) == 216\nassert op_inc_takewhilepos_prod([3, 1, 2]) == 24\nassert op_inc_takewhilepos_prod([10]) == 11\nassert op_inc_takewhilepos_prod([2, 4, 6]) == 105\nassert op_inc_takewhilepos_prod([-7, 12, -7]) == 1"}
{"id": "op_odds_evens_sortd", "entry_point": "op_odds_evens_sortd", "primitives": ["odds", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then sort descending.", "solution": "def op_odds_evens_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_evens_sortd([1, 2, 3, 4]) == []\nassert op_odds_evens_sortd([]) == []\nassert op_odds_evens_sortd([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_sortd([5, 5, 5]) == []\nassert op_odds_evens_sortd([3, 1, 2]) == []\nassert op_odds_evens_sortd([10]) == []\nassert op_odds_evens_sortd([2, 4, 6]) == []\nassert op_odds_evens_sortd([-7, 12, -7]) == []"}
{"id": "op_ages_sorta_sortabs", "entry_point": "op_ages_sorta_sortabs", "primitives": ["ages", "sorta", "sortabs"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then sort by absolute value.", "solution": "def op_ages_sorta_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_sorta_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sorta_sortabs([]) == []\nassert op_ages_sorta_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sorta_sortabs([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortabs_first3_neg", "entry_point": "op_sortabs_first3_neg", "primitives": ["sortabs", "first3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then keep the negative numbers.", "solution": "def op_sortabs_first3_neg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortabs_first3_neg([1, 2, 3, 4]) == []\nassert op_sortabs_first3_neg([]) == []\nassert op_sortabs_first3_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_sortabs_first3_neg([5, 5, 5]) == []\nassert op_sortabs_first3_neg([3, 1, 2]) == []\nassert op_sortabs_first3_neg([10]) == []\nassert op_sortabs_first3_neg([2, 4, 6]) == []\nassert op_sortabs_first3_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_sorta_max", "entry_point": "op_padto3_sorta_max", "primitives": ["padto3", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_padto3_sorta_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_padto3_sorta_max([1, 2, 3, 4]) == 4\nassert op_padto3_sorta_max([]) == 0\nassert op_padto3_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_sorta_max([5, 5, 5]) == 5\nassert op_padto3_sorta_max([3, 1, 2]) == 3\nassert op_padto3_sorta_max([10]) == 10\nassert op_padto3_sorta_max([2, 4, 6]) == 6\nassert op_padto3_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_odds_neg_firsteven", "entry_point": "op_odds_neg_firsteven", "primitives": ["odds", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_odds_neg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_odds_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_odds_neg_firsteven([]) == 0\nassert op_odds_neg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_neg_firsteven([5, 5, 5]) == 0\nassert op_odds_neg_firsteven([3, 1, 2]) == 0\nassert op_odds_neg_firsteven([10]) == 0\nassert op_odds_neg_firsteven([2, 4, 6]) == 0\nassert op_odds_neg_firsteven([-7, 12, -7]) == 0"}
{"id": "op_sortd_neg_dropwhileneg", "entry_point": "op_sortd_neg_dropwhileneg", "primitives": ["sortd", "neg", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then drop the leading negative values.", "solution": "def op_sortd_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_sortd_neg_dropwhileneg([]) == []\nassert op_sortd_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_sortd_neg_dropwhileneg([5, 5, 5]) == []\nassert op_sortd_neg_dropwhileneg([3, 1, 2]) == []\nassert op_sortd_neg_dropwhileneg([10]) == []\nassert op_sortd_neg_dropwhileneg([2, 4, 6]) == []\nassert op_sortd_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dropshort_lower_uniqs", "entry_point": "op_dropshort_lower_uniqs", "primitives": ["dropshort", "lower", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then lowercase each string, then drop duplicate strings keeping the first.", "solution": "def op_dropshort_lower_uniqs(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropshort_lower_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_dropshort_lower_uniqs([]) == []\nassert op_dropshort_lower_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_lower_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_dropshort_lower_uniqs(['x']) == []\nassert op_dropshort_lower_uniqs(['abc', 'de', '']) == ['abc']"}
{"id": "op_sortd_add10_alldistinct", "entry_point": "op_sortd_add10_alldistinct", "primitives": ["sortd", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then return whether all values are distinct.", "solution": "def op_sortd_add10_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_add10_alldistinct([]) == True\nassert op_sortd_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_add10_alldistinct([5, 5, 5]) == False\nassert op_sortd_add10_alldistinct([3, 1, 2]) == True\nassert op_sortd_add10_alldistinct([10]) == True\nassert op_sortd_add10_alldistinct([2, 4, 6]) == True\nassert op_sortd_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropfirst_padto3_dropwhileneg", "entry_point": "op_dropfirst_padto3_dropwhileneg", "primitives": ["dropfirst", "padto3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_dropfirst_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_padto3_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_dropfirst_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_padto3_dropwhileneg([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_padto3_dropwhileneg([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_padto3_dropwhileneg([10]) == [0, 0, 0]\nassert op_dropfirst_padto3_dropwhileneg([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_padto3_dropwhileneg([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_beforezero_div3_first3", "entry_point": "op_beforezero_div3_first3", "primitives": ["beforezero", "div3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three, then keep only the first three.", "solution": "def op_beforezero_div3_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_div3_first3([1, 2, 3, 4]) == [3]\nassert op_beforezero_div3_first3([]) == []\nassert op_beforezero_div3_first3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_div3_first3([5, 5, 5]) == []\nassert op_beforezero_div3_first3([3, 1, 2]) == [3]\nassert op_beforezero_div3_first3([10]) == []\nassert op_beforezero_div3_first3([2, 4, 6]) == [6]\nassert op_beforezero_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_upper_nonempty_sortalpha", "entry_point": "op_upper_nonempty_sortalpha", "primitives": ["upper", "nonempty", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop empty strings, then sort alphabetically.", "solution": "def op_upper_nonempty_sortalpha(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    r = sorted(r)\n    return r", "tests": "assert op_upper_nonempty_sortalpha(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_nonempty_sortalpha([]) == []\nassert op_upper_nonempty_sortalpha(['  a ', '', 'BC', 'bc']) == ['  A ', 'BC', 'BC']\nassert op_upper_nonempty_sortalpha(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_nonempty_sortalpha(['x']) == ['X']\nassert op_upper_nonempty_sortalpha(['abc', 'de', '']) == ['ABC', 'DE']"}
{"id": "op_pos_beforezero_uniq", "entry_point": "op_pos_beforezero_uniq", "primitives": ["pos", "beforezero", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then drop duplicates keeping first occurrence.", "solution": "def op_pos_beforezero_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_beforezero_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_beforezero_uniq([]) == []\nassert op_pos_beforezero_uniq([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_beforezero_uniq([5, 5, 5]) == [5]\nassert op_pos_beforezero_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_pos_beforezero_uniq([10]) == [10]\nassert op_pos_beforezero_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_pos_beforezero_uniq([-7, 12, -7]) == [12]"}
{"id": "op_gt5_sortabs_odds", "entry_point": "op_gt5_sortabs_odds", "primitives": ["gt5", "sortabs", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then keep the odd numbers.", "solution": "def op_gt5_sortabs_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_sortabs_odds([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_odds([]) == []\nassert op_gt5_sortabs_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_odds([5, 5, 5]) == []\nassert op_gt5_sortabs_odds([3, 1, 2]) == []\nassert op_gt5_sortabs_odds([10]) == []\nassert op_gt5_sortabs_odds([2, 4, 6]) == []\nassert op_gt5_sortabs_odds([-7, 12, -7]) == []"}
{"id": "op_square_pos_alldistinct", "entry_point": "op_square_pos_alldistinct", "primitives": ["square", "pos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then return whether all values are distinct.", "solution": "def op_square_pos_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_square_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_square_pos_alldistinct([]) == True\nassert op_square_pos_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_square_pos_alldistinct([5, 5, 5]) == False\nassert op_square_pos_alldistinct([3, 1, 2]) == True\nassert op_square_pos_alldistinct([10]) == True\nassert op_square_pos_alldistinct([2, 4, 6]) == True\nassert op_square_pos_alldistinct([-7, 12, -7]) == False"}
{"id": "op_absval_first3_firsteven", "entry_point": "op_absval_first3_firsteven", "primitives": ["absval", "first3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_absval_first3_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_first3_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_first3_firsteven([]) == 0\nassert op_absval_first3_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_first3_firsteven([5, 5, 5]) == 0\nassert op_absval_first3_firsteven([3, 1, 2]) == 2\nassert op_absval_first3_firsteven([10]) == 10\nassert op_absval_first3_firsteven([2, 4, 6]) == 2\nassert op_absval_first3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_dropwhileneg_div3", "entry_point": "op_oremptyzero_dropwhileneg_div3", "primitives": ["oremptyzero", "dropwhileneg", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then keep multiples of three.", "solution": "def op_oremptyzero_dropwhileneg_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_dropwhileneg_div3([]) == [0]\nassert op_oremptyzero_dropwhileneg_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_dropwhileneg_div3([5, 5, 5]) == []\nassert op_oremptyzero_dropwhileneg_div3([3, 1, 2]) == [3]\nassert op_oremptyzero_dropwhileneg_div3([10]) == []\nassert op_oremptyzero_dropwhileneg_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_dropwhileneg_div3([-7, 12, -7]) == [12]"}
{"id": "op_neg_clamp10_haszero", "entry_point": "op_neg_clamp10_haszero", "primitives": ["neg", "clamp10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then return whether the list contains a zero.", "solution": "def op_neg_clamp10_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_neg_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_neg_clamp10_haszero([]) == False\nassert op_neg_clamp10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_clamp10_haszero([5, 5, 5]) == False\nassert op_neg_clamp10_haszero([3, 1, 2]) == False\nassert op_neg_clamp10_haszero([10]) == False\nassert op_neg_clamp10_haszero([2, 4, 6]) == False\nassert op_neg_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_square_len", "entry_point": "op_dropfirst_square_len", "primitives": ["dropfirst", "square", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then return how many remain.", "solution": "def op_dropfirst_square_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_dropfirst_square_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_square_len([]) == 0\nassert op_dropfirst_square_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_square_len([5, 5, 5]) == 2\nassert op_dropfirst_square_len([3, 1, 2]) == 2\nassert op_dropfirst_square_len([10]) == 0\nassert op_dropfirst_square_len([2, 4, 6]) == 2\nassert op_dropfirst_square_len([-7, 12, -7]) == 2"}
{"id": "op_beforezero_dec_evens", "entry_point": "op_beforezero_dec_evens", "primitives": ["beforezero", "dec", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then keep the even numbers.", "solution": "def op_beforezero_dec_evens(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_beforezero_dec_evens([1, 2, 3, 4]) == [0, 2]\nassert op_beforezero_dec_evens([]) == []\nassert op_beforezero_dec_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_dec_evens([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dec_evens([3, 1, 2]) == [2, 0]\nassert op_beforezero_dec_evens([10]) == []\nassert op_beforezero_dec_evens([2, 4, 6]) == []\nassert op_beforezero_dec_evens([-7, 12, -7]) == [-8, -8]"}
{"id": "op_takewhilepos_dropwhileneg_anyeven", "entry_point": "op_takewhilepos_dropwhileneg_anyeven", "primitives": ["takewhilepos", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then return whether any value is even.", "solution": "def op_takewhilepos_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_takewhilepos_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_takewhilepos_dropwhileneg_anyeven([]) == False\nassert op_takewhilepos_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_takewhilepos_dropwhileneg_anyeven([3, 1, 2]) == True\nassert op_takewhilepos_dropwhileneg_anyeven([10]) == True\nassert op_takewhilepos_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_takewhilepos_dropwhileneg_anyeven([-7, 12, -7]) == False"}
{"id": "op_add10_takewhilepos_allpos", "entry_point": "op_add10_takewhilepos_allpos", "primitives": ["add10", "takewhilepos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then return whether all values are positive.", "solution": "def op_add10_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_add10_takewhilepos_allpos([]) == True\nassert op_add10_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_takewhilepos_allpos([5, 5, 5]) == True\nassert op_add10_takewhilepos_allpos([3, 1, 2]) == True\nassert op_add10_takewhilepos_allpos([10]) == True\nassert op_add10_takewhilepos_allpos([2, 4, 6]) == True\nassert op_add10_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_first3_trimends", "entry_point": "op_takewhilepos_first3_trimends", "primitives": ["takewhilepos", "first3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then drop the first and last elements.", "solution": "def op_takewhilepos_first3_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_first3_trimends([1, 2, 3, 4]) == [2]\nassert op_takewhilepos_first3_trimends([]) == []\nassert op_takewhilepos_first3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_trimends([5, 5, 5]) == [5]\nassert op_takewhilepos_first3_trimends([3, 1, 2]) == [1]\nassert op_takewhilepos_first3_trimends([10]) == []\nassert op_takewhilepos_first3_trimends([2, 4, 6]) == [4]\nassert op_takewhilepos_first3_trimends([-7, 12, -7]) == []"}
{"id": "op_strip_nonempty_prefixup", "entry_point": "op_strip_nonempty_prefixup", "primitives": ["strip", "nonempty", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop empty strings, then prefix each with a hash.", "solution": "def op_strip_nonempty_prefixup(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_strip_nonempty_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_nonempty_prefixup([]) == []\nassert op_strip_nonempty_prefixup(['  a ', '', 'BC', 'bc']) == ['#a', '#BC', '#bc']\nassert op_strip_nonempty_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_strip_nonempty_prefixup(['x']) == ['#x']\nassert op_strip_nonempty_prefixup(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_padto3_clamp10_first3", "entry_point": "op_padto3_clamp10_first3", "primitives": ["padto3", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10, then keep only the first three.", "solution": "def op_padto3_clamp10_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_clamp10_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_clamp10_first3([]) == [0, 0, 0]\nassert op_padto3_clamp10_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_padto3_clamp10_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_clamp10_first3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_clamp10_first3([10]) == [10, 0, 0]\nassert op_padto3_clamp10_first3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_clamp10_first3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_dropwhileneg_odds_sorta", "entry_point": "op_dropwhileneg_odds_sorta", "primitives": ["dropwhileneg", "odds", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then sort ascending.", "solution": "def op_dropwhileneg_odds_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_odds_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_dropwhileneg_odds_sorta([]) == []\nassert op_dropwhileneg_odds_sorta([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_odds_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_odds_sorta([3, 1, 2]) == [1, 3]\nassert op_dropwhileneg_odds_sorta([10]) == []\nassert op_dropwhileneg_odds_sorta([2, 4, 6]) == []\nassert op_dropwhileneg_odds_sorta([-7, 12, -7]) == [-7]"}
{"id": "op_neg_odds_absval", "entry_point": "op_neg_odds_absval", "primitives": ["neg", "odds", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then take the absolute value of each.", "solution": "def op_neg_odds_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_neg_odds_absval([1, 2, 3, 4]) == []\nassert op_neg_odds_absval([]) == []\nassert op_neg_odds_absval([-2, -1, 0, 1, 2]) == [1]\nassert op_neg_odds_absval([5, 5, 5]) == []\nassert op_neg_odds_absval([3, 1, 2]) == []\nassert op_neg_odds_absval([10]) == []\nassert op_neg_odds_absval([2, 4, 6]) == []\nassert op_neg_odds_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropzeros_clamp10_beforezero", "entry_point": "op_dropzeros_clamp10_beforezero", "primitives": ["dropzeros", "clamp10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then keep everything before the first zero.", "solution": "def op_dropzeros_clamp10_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_clamp10_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_clamp10_beforezero([]) == []\nassert op_dropzeros_clamp10_beforezero([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_dropzeros_clamp10_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_clamp10_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_clamp10_beforezero([10]) == [10]\nassert op_dropzeros_clamp10_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_clamp10_beforezero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_absval_padto3_takewhilepos", "entry_point": "op_absval_padto3_takewhilepos", "primitives": ["absval", "padto3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_absval_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_absval_padto3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_padto3_takewhilepos([]) == []\nassert op_absval_padto3_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_absval_padto3_takewhilepos([10]) == [10]\nassert op_absval_padto3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_padto3_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_takewhilepos_trimends", "entry_point": "op_double_takewhilepos_trimends", "primitives": ["double", "takewhilepos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then drop the first and last elements.", "solution": "def op_double_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_takewhilepos_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_double_takewhilepos_trimends([]) == []\nassert op_double_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_double_takewhilepos_trimends([5, 5, 5]) == [10]\nassert op_double_takewhilepos_trimends([3, 1, 2]) == [2]\nassert op_double_takewhilepos_trimends([10]) == []\nassert op_double_takewhilepos_trimends([2, 4, 6]) == [8]\nassert op_double_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_clamp10_first3", "entry_point": "op_add10_clamp10_first3", "primitives": ["add10", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then keep only the first three.", "solution": "def op_add10_clamp10_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_add10_clamp10_first3([1, 2, 3, 4]) == [10, 10, 10]\nassert op_add10_clamp10_first3([]) == []\nassert op_add10_clamp10_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_clamp10_first3([5, 5, 5]) == [10, 10, 10]\nassert op_add10_clamp10_first3([3, 1, 2]) == [10, 10, 10]\nassert op_add10_clamp10_first3([10]) == [10]\nassert op_add10_clamp10_first3([2, 4, 6]) == [10, 10, 10]\nassert op_add10_clamp10_first3([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_pos_padto3_max", "entry_point": "op_pos_padto3_max", "primitives": ["pos", "padto3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_pos_padto3_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_pos_padto3_max([1, 2, 3, 4]) == 4\nassert op_pos_padto3_max([]) == 0\nassert op_pos_padto3_max([-2, -1, 0, 1, 2]) == 2\nassert op_pos_padto3_max([5, 5, 5]) == 5\nassert op_pos_padto3_max([3, 1, 2]) == 3\nassert op_pos_padto3_max([10]) == 10\nassert op_pos_padto3_max([2, 4, 6]) == 6\nassert op_pos_padto3_max([-7, 12, -7]) == 12"}
{"id": "op_inc_oremptyzero_beforezero", "entry_point": "op_inc_oremptyzero_beforezero", "primitives": ["inc", "oremptyzero", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then keep everything before the first zero.", "solution": "def op_inc_oremptyzero_beforezero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_inc_oremptyzero_beforezero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_oremptyzero_beforezero([]) == []\nassert op_inc_oremptyzero_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_oremptyzero_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_oremptyzero_beforezero([3, 1, 2]) == [4, 2, 3]\nassert op_inc_oremptyzero_beforezero([10]) == [11]\nassert op_inc_oremptyzero_beforezero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_oremptyzero_beforezero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_beforezero_double_sorta", "entry_point": "op_beforezero_double_sorta", "primitives": ["beforezero", "double", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then sort ascending.", "solution": "def op_beforezero_double_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_double_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_beforezero_double_sorta([]) == []\nassert op_beforezero_double_sorta([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_beforezero_double_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_double_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_beforezero_double_sorta([10]) == [20]\nassert op_beforezero_double_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_double_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_absval_first3_alldistinct", "entry_point": "op_absval_first3_alldistinct", "primitives": ["absval", "first3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then return whether all values are distinct.", "solution": "def op_absval_first3_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_absval_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_first3_alldistinct([]) == True\nassert op_absval_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_absval_first3_alldistinct([5, 5, 5]) == False\nassert op_absval_first3_alldistinct([3, 1, 2]) == True\nassert op_absval_first3_alldistinct([10]) == True\nassert op_absval_first3_alldistinct([2, 4, 6]) == True\nassert op_absval_first3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_rev_sortabs", "entry_point": "op_oremptyzero_rev_sortabs", "primitives": ["oremptyzero", "rev", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then sort by absolute value.", "solution": "def op_oremptyzero_rev_sortabs(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_oremptyzero_rev_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_rev_sortabs([]) == [0]\nassert op_oremptyzero_rev_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_oremptyzero_rev_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_rev_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_rev_sortabs([10]) == [10]\nassert op_oremptyzero_rev_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_rev_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_gt5_inc_odds", "entry_point": "op_gt5_inc_odds", "primitives": ["gt5", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then keep the odd numbers.", "solution": "def op_gt5_inc_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_inc_odds([1, 2, 3, 4]) == []\nassert op_gt5_inc_odds([]) == []\nassert op_gt5_inc_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_odds([5, 5, 5]) == []\nassert op_gt5_inc_odds([3, 1, 2]) == []\nassert op_gt5_inc_odds([10]) == [11]\nassert op_gt5_inc_odds([2, 4, 6]) == [7]\nassert op_gt5_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_square_sortd_dropwhileneg", "entry_point": "op_square_sortd_dropwhileneg", "primitives": ["square", "sortd", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then drop the leading negative values.", "solution": "def op_square_sortd_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_sortd_dropwhileneg([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_sortd_dropwhileneg([]) == []\nassert op_square_sortd_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_square_sortd_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortd_dropwhileneg([3, 1, 2]) == [9, 4, 1]\nassert op_square_sortd_dropwhileneg([10]) == [100]\nassert op_square_sortd_dropwhileneg([2, 4, 6]) == [36, 16, 4]\nassert op_square_sortd_dropwhileneg([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_takewhilepos_padto3_len", "entry_point": "op_takewhilepos_padto3_len", "primitives": ["takewhilepos", "padto3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_takewhilepos_padto3_len(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_takewhilepos_padto3_len([1, 2, 3, 4]) == 4\nassert op_takewhilepos_padto3_len([]) == 3\nassert op_takewhilepos_padto3_len([-2, -1, 0, 1, 2]) == 3\nassert op_takewhilepos_padto3_len([5, 5, 5]) == 3\nassert op_takewhilepos_padto3_len([3, 1, 2]) == 3\nassert op_takewhilepos_padto3_len([10]) == 3\nassert op_takewhilepos_padto3_len([2, 4, 6]) == 3\nassert op_takewhilepos_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_dropwhileneg_dropzeros_rev", "entry_point": "op_dropwhileneg_dropzeros_rev", "primitives": ["dropwhileneg", "dropzeros", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then reverse the order.", "solution": "def op_dropwhileneg_dropzeros_rev(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropwhileneg_dropzeros_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropwhileneg_dropzeros_rev([]) == []\nassert op_dropwhileneg_dropzeros_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_dropwhileneg_dropzeros_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_dropzeros_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropwhileneg_dropzeros_rev([10]) == [10]\nassert op_dropwhileneg_dropzeros_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_dropzeros_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dec_negate_counteven", "entry_point": "op_dec_negate_counteven", "primitives": ["dec", "negate", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then return how many values are even.", "solution": "def op_dec_negate_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_negate_counteven([1, 2, 3, 4]) == 2\nassert op_dec_negate_counteven([]) == 0\nassert op_dec_negate_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dec_negate_counteven([5, 5, 5]) == 3\nassert op_dec_negate_counteven([3, 1, 2]) == 2\nassert op_dec_negate_counteven([10]) == 0\nassert op_dec_negate_counteven([2, 4, 6]) == 0\nassert op_dec_negate_counteven([-7, 12, -7]) == 2"}
{"id": "op_rev_evens_sortabs", "entry_point": "op_rev_evens_sortabs", "primitives": ["rev", "evens", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers, then sort by absolute value.", "solution": "def op_rev_evens_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_rev_evens_sortabs([]) == []\nassert op_rev_evens_sortabs([-2, -1, 0, 1, 2]) == [0, 2, -2]\nassert op_rev_evens_sortabs([5, 5, 5]) == []\nassert op_rev_evens_sortabs([3, 1, 2]) == [2]\nassert op_rev_evens_sortabs([10]) == [10]\nassert op_rev_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_odds_oremptyzero_trimends", "entry_point": "op_odds_oremptyzero_trimends", "primitives": ["odds", "oremptyzero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_odds_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_oremptyzero_trimends([1, 2, 3, 4]) == []\nassert op_odds_oremptyzero_trimends([]) == []\nassert op_odds_oremptyzero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_oremptyzero_trimends([5, 5, 5]) == [5]\nassert op_odds_oremptyzero_trimends([3, 1, 2]) == []\nassert op_odds_oremptyzero_trimends([10]) == []\nassert op_odds_oremptyzero_trimends([2, 4, 6]) == []\nassert op_odds_oremptyzero_trimends([-7, 12, -7]) == []"}
{"id": "op_dropzeros_inc_beforezero", "entry_point": "op_dropzeros_inc_beforezero", "primitives": ["dropzeros", "inc", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then keep everything before the first zero.", "solution": "def op_dropzeros_inc_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_inc_beforezero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropzeros_inc_beforezero([]) == []\nassert op_dropzeros_inc_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropzeros_inc_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_dropzeros_inc_beforezero([3, 1, 2]) == [4, 2, 3]\nassert op_dropzeros_inc_beforezero([10]) == [11]\nassert op_dropzeros_inc_beforezero([2, 4, 6]) == [3, 5, 7]\nassert op_dropzeros_inc_beforezero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sorta_inc_evens", "entry_point": "op_sorta_inc_evens", "primitives": ["sorta", "inc", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then keep the even numbers.", "solution": "def op_sorta_inc_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_inc_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_inc_evens([]) == []\nassert op_sorta_inc_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_sorta_inc_evens([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_evens([3, 1, 2]) == [2, 4]\nassert op_sorta_inc_evens([10]) == []\nassert op_sorta_inc_evens([2, 4, 6]) == []\nassert op_sorta_inc_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_double_uniq_sortabs", "entry_point": "op_double_uniq_sortabs", "primitives": ["double", "uniq", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then sort by absolute value.", "solution": "def op_double_uniq_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_uniq_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_uniq_sortabs([]) == []\nassert op_double_uniq_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_double_uniq_sortabs([5, 5, 5]) == [10]\nassert op_double_uniq_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_double_uniq_sortabs([10]) == [20]\nassert op_double_uniq_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_double_uniq_sortabs([-7, 12, -7]) == [-14, 24]"}
{"id": "op_neg_uniq_add10", "entry_point": "op_neg_uniq_add10", "primitives": ["neg", "uniq", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_neg_uniq_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_uniq_add10([1, 2, 3, 4]) == []\nassert op_neg_uniq_add10([]) == []\nassert op_neg_uniq_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_neg_uniq_add10([5, 5, 5]) == []\nassert op_neg_uniq_add10([3, 1, 2]) == []\nassert op_neg_uniq_add10([10]) == []\nassert op_neg_uniq_add10([2, 4, 6]) == []\nassert op_neg_uniq_add10([-7, 12, -7]) == [3]"}
{"id": "op_uniq_rev_dropzeros", "entry_point": "op_uniq_rev_dropzeros", "primitives": ["uniq", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order, then drop the zeros.", "solution": "def op_uniq_rev_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_rev_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_rev_dropzeros([]) == []\nassert op_uniq_rev_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_uniq_rev_dropzeros([5, 5, 5]) == [5]\nassert op_uniq_rev_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_uniq_rev_dropzeros([10]) == [10]\nassert op_uniq_rev_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_rev_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_rev_takewhilepos_max", "entry_point": "op_rev_takewhilepos_max", "primitives": ["rev", "takewhilepos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_rev_takewhilepos_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_rev_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_rev_takewhilepos_max([]) == 0\nassert op_rev_takewhilepos_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_takewhilepos_max([5, 5, 5]) == 5\nassert op_rev_takewhilepos_max([3, 1, 2]) == 3\nassert op_rev_takewhilepos_max([10]) == 10\nassert op_rev_takewhilepos_max([2, 4, 6]) == 6\nassert op_rev_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_oremptyzero_len", "entry_point": "op_dropzeros_oremptyzero_len", "primitives": ["dropzeros", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then return how many remain.", "solution": "def op_dropzeros_oremptyzero_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_dropzeros_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_dropzeros_oremptyzero_len([]) == 1\nassert op_dropzeros_oremptyzero_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_oremptyzero_len([5, 5, 5]) == 3\nassert op_dropzeros_oremptyzero_len([3, 1, 2]) == 3\nassert op_dropzeros_oremptyzero_len([10]) == 1\nassert op_dropzeros_oremptyzero_len([2, 4, 6]) == 3\nassert op_dropzeros_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_rev_trimends", "entry_point": "op_sortd_rev_trimends", "primitives": ["sortd", "rev", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then reverse the order, then drop the first and last elements.", "solution": "def op_sortd_rev_trimends(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_sortd_rev_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sortd_rev_trimends([]) == []\nassert op_sortd_rev_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sortd_rev_trimends([5, 5, 5]) == [5]\nassert op_sortd_rev_trimends([3, 1, 2]) == [2]\nassert op_sortd_rev_trimends([10]) == []\nassert op_sortd_rev_trimends([2, 4, 6]) == [4]\nassert op_sortd_rev_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_pos_takewhilepos", "entry_point": "op_padto3_pos_takewhilepos", "primitives": ["padto3", "pos", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then take values while they are positive.", "solution": "def op_padto3_pos_takewhilepos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_padto3_pos_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_pos_takewhilepos([]) == []\nassert op_padto3_pos_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_pos_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_pos_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_pos_takewhilepos([10]) == [10]\nassert op_padto3_pos_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_pos_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dec_neg_sortd", "entry_point": "op_dec_neg_sortd", "primitives": ["dec", "neg", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then sort descending.", "solution": "def op_dec_neg_sortd(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dec_neg_sortd([1, 2, 3, 4]) == []\nassert op_dec_neg_sortd([]) == []\nassert op_dec_neg_sortd([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_dec_neg_sortd([5, 5, 5]) == []\nassert op_dec_neg_sortd([3, 1, 2]) == []\nassert op_dec_neg_sortd([10]) == []\nassert op_dec_neg_sortd([2, 4, 6]) == []\nassert op_dec_neg_sortd([-7, 12, -7]) == [-8, -8]"}
{"id": "op_dropwhileneg_square_max", "entry_point": "op_dropwhileneg_square_max", "primitives": ["dropwhileneg", "square", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_square_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_square_max([1, 2, 3, 4]) == 16\nassert op_dropwhileneg_square_max([]) == 0\nassert op_dropwhileneg_square_max([-2, -1, 0, 1, 2]) == 4\nassert op_dropwhileneg_square_max([5, 5, 5]) == 25\nassert op_dropwhileneg_square_max([3, 1, 2]) == 9\nassert op_dropwhileneg_square_max([10]) == 100\nassert op_dropwhileneg_square_max([2, 4, 6]) == 36\nassert op_dropwhileneg_square_max([-7, 12, -7]) == 144"}
{"id": "op_inc_first3_neg", "entry_point": "op_inc_first3_neg", "primitives": ["inc", "first3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then keep the negative numbers.", "solution": "def op_inc_first3_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_first3_neg([1, 2, 3, 4]) == []\nassert op_inc_first3_neg([]) == []\nassert op_inc_first3_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_first3_neg([5, 5, 5]) == []\nassert op_inc_first3_neg([3, 1, 2]) == []\nassert op_inc_first3_neg([10]) == []\nassert op_inc_first3_neg([2, 4, 6]) == []\nassert op_inc_first3_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_gt5_add10_sortd", "entry_point": "op_gt5_add10_sortd", "primitives": ["gt5", "add10", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then sort descending.", "solution": "def op_gt5_add10_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_add10_sortd([1, 2, 3, 4]) == []\nassert op_gt5_add10_sortd([]) == []\nassert op_gt5_add10_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_sortd([5, 5, 5]) == []\nassert op_gt5_add10_sortd([3, 1, 2]) == []\nassert op_gt5_add10_sortd([10]) == [20]\nassert op_gt5_add10_sortd([2, 4, 6]) == [16]\nassert op_gt5_add10_sortd([-7, 12, -7]) == [22]"}
{"id": "op_square_last3_issorted", "entry_point": "op_square_last3_issorted", "primitives": ["square", "last3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_square_last3_issorted(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_square_last3_issorted([1, 2, 3, 4]) == True\nassert op_square_last3_issorted([]) == True\nassert op_square_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_square_last3_issorted([5, 5, 5]) == True\nassert op_square_last3_issorted([3, 1, 2]) == False\nassert op_square_last3_issorted([10]) == True\nassert op_square_last3_issorted([2, 4, 6]) == True\nassert op_square_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_clamp10_rev_first3", "entry_point": "op_clamp10_rev_first3", "primitives": ["clamp10", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then keep only the first three.", "solution": "def op_clamp10_rev_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_rev_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_clamp10_rev_first3([]) == []\nassert op_clamp10_rev_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_clamp10_rev_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_rev_first3([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_rev_first3([10]) == [10]\nassert op_clamp10_rev_first3([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_rev_first3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_gt5_pos_sortd", "entry_point": "op_gt5_pos_sortd", "primitives": ["gt5", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then sort descending.", "solution": "def op_gt5_pos_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_pos_sortd([1, 2, 3, 4]) == []\nassert op_gt5_pos_sortd([]) == []\nassert op_gt5_pos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_sortd([5, 5, 5]) == []\nassert op_gt5_pos_sortd([3, 1, 2]) == []\nassert op_gt5_pos_sortd([10]) == [10]\nassert op_gt5_pos_sortd([2, 4, 6]) == [6]\nassert op_gt5_pos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_inc_pos_double", "entry_point": "op_inc_pos_double", "primitives": ["inc", "pos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then double each.", "solution": "def op_inc_pos_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_pos_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_pos_double([]) == []\nassert op_inc_pos_double([-2, -1, 0, 1, 2]) == [2, 4, 6]\nassert op_inc_pos_double([5, 5, 5]) == [12, 12, 12]\nassert op_inc_pos_double([3, 1, 2]) == [8, 4, 6]\nassert op_inc_pos_double([10]) == [22]\nassert op_inc_pos_double([2, 4, 6]) == [6, 10, 14]\nassert op_inc_pos_double([-7, 12, -7]) == [26]"}
{"id": "op_dropzeros_double_rev", "entry_point": "op_dropzeros_double_rev", "primitives": ["dropzeros", "double", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then reverse the order.", "solution": "def op_dropzeros_double_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropzeros_double_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_dropzeros_double_rev([]) == []\nassert op_dropzeros_double_rev([-2, -1, 0, 1, 2]) == [4, 2, -2, -4]\nassert op_dropzeros_double_rev([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double_rev([3, 1, 2]) == [4, 2, 6]\nassert op_dropzeros_double_rev([10]) == [20]\nassert op_dropzeros_double_rev([2, 4, 6]) == [12, 8, 4]\nassert op_dropzeros_double_rev([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_sorta_neg_prod", "entry_point": "op_sorta_neg_prod", "primitives": ["sorta", "neg", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers, then return their product.", "solution": "def op_sorta_neg_prod(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_sorta_neg_prod([1, 2, 3, 4]) == 1\nassert op_sorta_neg_prod([]) == 1\nassert op_sorta_neg_prod([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_neg_prod([5, 5, 5]) == 1\nassert op_sorta_neg_prod([3, 1, 2]) == 1\nassert op_sorta_neg_prod([10]) == 1\nassert op_sorta_neg_prod([2, 4, 6]) == 1\nassert op_sorta_neg_prod([-7, 12, -7]) == 49"}
{"id": "op_gt5_takewhilepos_odds", "entry_point": "op_gt5_takewhilepos_odds", "primitives": ["gt5", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then keep the odd numbers.", "solution": "def op_gt5_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_takewhilepos_odds([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos_odds([]) == []\nassert op_gt5_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos_odds([5, 5, 5]) == []\nassert op_gt5_takewhilepos_odds([3, 1, 2]) == []\nassert op_gt5_takewhilepos_odds([10]) == []\nassert op_gt5_takewhilepos_odds([2, 4, 6]) == []\nassert op_gt5_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_neg_dropwhileneg_len", "entry_point": "op_neg_dropwhileneg_len", "primitives": ["neg", "dropwhileneg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values, then return how many remain.", "solution": "def op_neg_dropwhileneg_len(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r)", "tests": "assert op_neg_dropwhileneg_len([1, 2, 3, 4]) == 0\nassert op_neg_dropwhileneg_len([]) == 0\nassert op_neg_dropwhileneg_len([-2, -1, 0, 1, 2]) == 0\nassert op_neg_dropwhileneg_len([5, 5, 5]) == 0\nassert op_neg_dropwhileneg_len([3, 1, 2]) == 0\nassert op_neg_dropwhileneg_len([10]) == 0\nassert op_neg_dropwhileneg_len([2, 4, 6]) == 0\nassert op_neg_dropwhileneg_len([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_rev_dropfirst", "entry_point": "op_dropwhileneg_rev_dropfirst", "primitives": ["dropwhileneg", "rev", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then drop the first element.", "solution": "def op_dropwhileneg_rev_dropfirst(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = r[1:]\n    return r", "tests": "assert op_dropwhileneg_rev_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dropwhileneg_rev_dropfirst([]) == []\nassert op_dropwhileneg_rev_dropfirst([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_dropwhileneg_rev_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_rev_dropfirst([3, 1, 2]) == [1, 3]\nassert op_dropwhileneg_rev_dropfirst([10]) == []\nassert op_dropwhileneg_rev_dropfirst([2, 4, 6]) == [4, 2]\nassert op_dropwhileneg_rev_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_last3_dropwhileneg_dec", "entry_point": "op_last3_dropwhileneg_dec", "primitives": ["last3", "dropwhileneg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then subtract one from each.", "solution": "def op_last3_dropwhileneg_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_dropwhileneg_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_dropwhileneg_dec([]) == []\nassert op_last3_dropwhileneg_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_last3_dropwhileneg_dec([5, 5, 5]) == [4, 4, 4]\nassert op_last3_dropwhileneg_dec([3, 1, 2]) == [2, 0, 1]\nassert op_last3_dropwhileneg_dec([10]) == [9]\nassert op_last3_dropwhileneg_dec([2, 4, 6]) == [1, 3, 5]\nassert op_last3_dropwhileneg_dec([-7, 12, -7]) == [11, -8]"}
{"id": "op_dec_evens_sorta", "entry_point": "op_dec_evens_sorta", "primitives": ["dec", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then sort ascending.", "solution": "def op_dec_evens_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_evens_sorta([1, 2, 3, 4]) == [0, 2]\nassert op_dec_evens_sorta([]) == []\nassert op_dec_evens_sorta([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_dec_evens_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_dec_evens_sorta([3, 1, 2]) == [0, 2]\nassert op_dec_evens_sorta([10]) == []\nassert op_dec_evens_sorta([2, 4, 6]) == []\nassert op_dec_evens_sorta([-7, 12, -7]) == [-8, -8]"}
{"id": "op_double_evens_div3", "entry_point": "op_double_evens_div3", "primitives": ["double", "evens", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then keep multiples of three.", "solution": "def op_double_evens_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_evens_div3([1, 2, 3, 4]) == [6]\nassert op_double_evens_div3([]) == []\nassert op_double_evens_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_evens_div3([5, 5, 5]) == []\nassert op_double_evens_div3([3, 1, 2]) == [6]\nassert op_double_evens_div3([10]) == []\nassert op_double_evens_div3([2, 4, 6]) == [12]\nassert op_double_evens_div3([-7, 12, -7]) == [24]"}
{"id": "op_uniq_trimends_issorted", "entry_point": "op_uniq_trimends_issorted", "primitives": ["uniq", "trimends", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_uniq_trimends_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_uniq_trimends_issorted([1, 2, 3, 4]) == True\nassert op_uniq_trimends_issorted([]) == True\nassert op_uniq_trimends_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_trimends_issorted([5, 5, 5]) == True\nassert op_uniq_trimends_issorted([3, 1, 2]) == True\nassert op_uniq_trimends_issorted([10]) == True\nassert op_uniq_trimends_issorted([2, 4, 6]) == True\nassert op_uniq_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_odds_inc_max", "entry_point": "op_odds_inc_max", "primitives": ["odds", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then return the maximum (0 if empty).", "solution": "def op_odds_inc_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_odds_inc_max([1, 2, 3, 4]) == 4\nassert op_odds_inc_max([]) == 0\nassert op_odds_inc_max([-2, -1, 0, 1, 2]) == 2\nassert op_odds_inc_max([5, 5, 5]) == 6\nassert op_odds_inc_max([3, 1, 2]) == 4\nassert op_odds_inc_max([10]) == 0\nassert op_odds_inc_max([2, 4, 6]) == 0\nassert op_odds_inc_max([-7, 12, -7]) == -6"}
{"id": "op_oremptyzero_negate_issorted", "entry_point": "op_oremptyzero_negate_issorted", "primitives": ["oremptyzero", "negate", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_negate_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_oremptyzero_negate_issorted([1, 2, 3, 4]) == False\nassert op_oremptyzero_negate_issorted([]) == True\nassert op_oremptyzero_negate_issorted([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_negate_issorted([5, 5, 5]) == True\nassert op_oremptyzero_negate_issorted([3, 1, 2]) == False\nassert op_oremptyzero_negate_issorted([10]) == True\nassert op_oremptyzero_negate_issorted([2, 4, 6]) == False\nassert op_oremptyzero_negate_issorted([-7, 12, -7]) == False"}
{"id": "op_add10_sorta_double", "entry_point": "op_add10_sorta_double", "primitives": ["add10", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then double each.", "solution": "def op_add10_sorta_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_sorta_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_add10_sorta_double([]) == []\nassert op_add10_sorta_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_add10_sorta_double([5, 5, 5]) == [30, 30, 30]\nassert op_add10_sorta_double([3, 1, 2]) == [22, 24, 26]\nassert op_add10_sorta_double([10]) == [40]\nassert op_add10_sorta_double([2, 4, 6]) == [24, 28, 32]\nassert op_add10_sorta_double([-7, 12, -7]) == [6, 6, 44]"}
{"id": "op_inc_div3_gt5", "entry_point": "op_inc_div3_gt5", "primitives": ["inc", "div3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then keep values greater than five.", "solution": "def op_inc_div3_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_div3_gt5([1, 2, 3, 4]) == []\nassert op_inc_div3_gt5([]) == []\nassert op_inc_div3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_div3_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_inc_div3_gt5([3, 1, 2]) == []\nassert op_inc_div3_gt5([10]) == []\nassert op_inc_div3_gt5([2, 4, 6]) == []\nassert op_inc_div3_gt5([-7, 12, -7]) == []"}
{"id": "op_clamp10_first3_rev", "entry_point": "op_clamp10_first3_rev", "primitives": ["clamp10", "first3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the first three, then reverse the order.", "solution": "def op_clamp10_first3_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_first3_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_clamp10_first3_rev([]) == []\nassert op_clamp10_first3_rev([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_clamp10_first3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_first3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_first3_rev([10]) == [10]\nassert op_clamp10_first3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_first3_rev([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_inc_clamp10_uniq", "entry_point": "op_inc_clamp10_uniq", "primitives": ["inc", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_inc_clamp10_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_clamp10_uniq([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_clamp10_uniq([]) == []\nassert op_inc_clamp10_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_clamp10_uniq([5, 5, 5]) == [6]\nassert op_inc_clamp10_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_inc_clamp10_uniq([10]) == [10]\nassert op_inc_clamp10_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_inc_clamp10_uniq([-7, 12, -7]) == [-6, 10]"}
{"id": "op_beforezero_dropfirst_first3", "entry_point": "op_beforezero_dropfirst_first3", "primitives": ["beforezero", "dropfirst", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then keep only the first three.", "solution": "def op_beforezero_dropfirst_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_dropfirst_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_dropfirst_first3([]) == []\nassert op_beforezero_dropfirst_first3([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_dropfirst_first3([5, 5, 5]) == [5, 5]\nassert op_beforezero_dropfirst_first3([3, 1, 2]) == [1, 2]\nassert op_beforezero_dropfirst_first3([10]) == []\nassert op_beforezero_dropfirst_first3([2, 4, 6]) == [4, 6]\nassert op_beforezero_dropfirst_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_names_uniqs_joinc", "entry_point": "op_names_uniqs_joinc", "primitives": ["names", "uniqs", "joinc"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop duplicate strings keeping the first, then join them with commas.", "solution": "def op_names_uniqs_joinc(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = list(dict.fromkeys(r))\n    return ','.join(r)", "tests": "assert op_names_uniqs_joinc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada,Bo'\nassert op_names_uniqs_joinc([]) == ''\nassert op_names_uniqs_joinc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Cy,Dee,El'\nassert op_names_uniqs_joinc([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_pos_padto3_counteven", "entry_point": "op_pos_padto3_counteven", "primitives": ["pos", "padto3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_pos_padto3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_padto3_counteven([1, 2, 3, 4]) == 2\nassert op_pos_padto3_counteven([]) == 3\nassert op_pos_padto3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_padto3_counteven([5, 5, 5]) == 0\nassert op_pos_padto3_counteven([3, 1, 2]) == 1\nassert op_pos_padto3_counteven([10]) == 3\nassert op_pos_padto3_counteven([2, 4, 6]) == 3\nassert op_pos_padto3_counteven([-7, 12, -7]) == 3"}
{"id": "op_add10_rev_neg", "entry_point": "op_add10_rev_neg", "primitives": ["add10", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then keep the negative numbers.", "solution": "def op_add10_rev_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_rev_neg([1, 2, 3, 4]) == []\nassert op_add10_rev_neg([]) == []\nassert op_add10_rev_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_rev_neg([5, 5, 5]) == []\nassert op_add10_rev_neg([3, 1, 2]) == []\nassert op_add10_rev_neg([10]) == []\nassert op_add10_rev_neg([2, 4, 6]) == []\nassert op_add10_rev_neg([-7, 12, -7]) == []"}
{"id": "op_inc_last3_div3", "entry_point": "op_inc_last3_div3", "primitives": ["inc", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then keep multiples of three.", "solution": "def op_inc_last3_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_last3_div3([1, 2, 3, 4]) == [3]\nassert op_inc_last3_div3([]) == []\nassert op_inc_last3_div3([-2, -1, 0, 1, 2]) == [3]\nassert op_inc_last3_div3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_div3([3, 1, 2]) == [3]\nassert op_inc_last3_div3([10]) == []\nassert op_inc_last3_div3([2, 4, 6]) == [3]\nassert op_inc_last3_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_pos_dropzeros_double", "entry_point": "op_pos_dropzeros_double", "primitives": ["pos", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the zeros, then double each.", "solution": "def op_pos_dropzeros_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_dropzeros_double([]) == []\nassert op_pos_dropzeros_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_pos_dropzeros_double([10]) == [20]\nassert op_pos_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_dropzeros_double([-7, 12, -7]) == [24]"}
{"id": "op_uniq_sortd_min", "entry_point": "op_uniq_sortd_min", "primitives": ["uniq", "sortd", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then return the minimum (0 if empty).", "solution": "def op_uniq_sortd_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_uniq_sortd_min([1, 2, 3, 4]) == 1\nassert op_uniq_sortd_min([]) == 0\nassert op_uniq_sortd_min([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_sortd_min([5, 5, 5]) == 5\nassert op_uniq_sortd_min([3, 1, 2]) == 1\nassert op_uniq_sortd_min([10]) == 10\nassert op_uniq_sortd_min([2, 4, 6]) == 2\nassert op_uniq_sortd_min([-7, 12, -7]) == -7"}
{"id": "op_ages_clamp10_trimends", "entry_point": "op_ages_clamp10_trimends", "primitives": ["ages", "clamp10", "trimends"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then drop the first and last elements.", "solution": "def op_ages_clamp10_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_clamp10_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_clamp10_trimends([]) == []\nassert op_ages_clamp10_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10]\nassert op_ages_clamp10_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_beforezero_sortabs_alldistinct", "entry_point": "op_beforezero_sortabs_alldistinct", "primitives": ["beforezero", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_beforezero_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_sortabs_alldistinct([]) == True\nassert op_beforezero_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_sortabs_alldistinct([5, 5, 5]) == False\nassert op_beforezero_sortabs_alldistinct([3, 1, 2]) == True\nassert op_beforezero_sortabs_alldistinct([10]) == True\nassert op_beforezero_sortabs_alldistinct([2, 4, 6]) == True\nassert op_beforezero_sortabs_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_neg_takewhilepos", "entry_point": "op_dropzeros_neg_takewhilepos", "primitives": ["dropzeros", "neg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then take values while they are positive.", "solution": "def op_dropzeros_neg_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_dropzeros_neg_takewhilepos([]) == []\nassert op_dropzeros_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_neg_takewhilepos([5, 5, 5]) == []\nassert op_dropzeros_neg_takewhilepos([3, 1, 2]) == []\nassert op_dropzeros_neg_takewhilepos([10]) == []\nassert op_dropzeros_neg_takewhilepos([2, 4, 6]) == []\nassert op_dropzeros_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_beforezero_takewhilepos_padto3", "entry_point": "op_beforezero_takewhilepos_padto3", "primitives": ["beforezero", "takewhilepos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_beforezero_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_takewhilepos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_beforezero_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_beforezero_takewhilepos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_takewhilepos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_takewhilepos_padto3([10]) == [10, 0, 0]\nassert op_beforezero_takewhilepos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_takewhilepos_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_first3_dropzeros_haszero", "entry_point": "op_first3_dropzeros_haszero", "primitives": ["first3", "dropzeros", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then return whether the list contains a zero.", "solution": "def op_first3_dropzeros_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_first3_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_first3_dropzeros_haszero([]) == False\nassert op_first3_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_first3_dropzeros_haszero([5, 5, 5]) == False\nassert op_first3_dropzeros_haszero([3, 1, 2]) == False\nassert op_first3_dropzeros_haszero([10]) == False\nassert op_first3_dropzeros_haszero([2, 4, 6]) == False\nassert op_first3_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_dropzeros_sortabs_dropfirst", "entry_point": "op_dropzeros_sortabs_dropfirst", "primitives": ["dropzeros", "sortabs", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then drop the first element.", "solution": "def op_dropzeros_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_sortabs_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_sortabs_dropfirst([]) == []\nassert op_dropzeros_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_dropzeros_sortabs_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_sortabs_dropfirst([3, 1, 2]) == [2, 3]\nassert op_dropzeros_sortabs_dropfirst([10]) == []\nassert op_dropzeros_sortabs_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropzeros_sortabs_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_div3_padto3_max", "entry_point": "op_div3_padto3_max", "primitives": ["div3", "padto3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_div3_padto3_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_div3_padto3_max([1, 2, 3, 4]) == 3\nassert op_div3_padto3_max([]) == 0\nassert op_div3_padto3_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_padto3_max([5, 5, 5]) == 0\nassert op_div3_padto3_max([3, 1, 2]) == 3\nassert op_div3_padto3_max([10]) == 0\nassert op_div3_padto3_max([2, 4, 6]) == 6\nassert op_div3_padto3_max([-7, 12, -7]) == 12"}
{"id": "op_absval_beforezero_uniq", "entry_point": "op_absval_beforezero_uniq", "primitives": ["absval", "beforezero", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then drop duplicates keeping first occurrence.", "solution": "def op_absval_beforezero_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_beforezero_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_beforezero_uniq([]) == []\nassert op_absval_beforezero_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_beforezero_uniq([5, 5, 5]) == [5]\nassert op_absval_beforezero_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_absval_beforezero_uniq([10]) == [10]\nassert op_absval_beforezero_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_absval_beforezero_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_rev_negate_sortd", "entry_point": "op_rev_negate_sortd", "primitives": ["rev", "negate", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then sort descending.", "solution": "def op_rev_negate_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_negate_sortd([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_rev_negate_sortd([]) == []\nassert op_rev_negate_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_negate_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_negate_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_rev_negate_sortd([10]) == [-10]\nassert op_rev_negate_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_rev_negate_sortd([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_sorta_double_trimends", "entry_point": "op_sorta_double_trimends", "primitives": ["sorta", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each, then drop the first and last elements.", "solution": "def op_sorta_double_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_double_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_sorta_double_trimends([]) == []\nassert op_sorta_double_trimends([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_sorta_double_trimends([5, 5, 5]) == [10]\nassert op_sorta_double_trimends([3, 1, 2]) == [4]\nassert op_sorta_double_trimends([10]) == []\nassert op_sorta_double_trimends([2, 4, 6]) == [8]\nassert op_sorta_double_trimends([-7, 12, -7]) == [-14]"}
{"id": "op_pos_dropzeros_absval", "entry_point": "op_pos_dropzeros_absval", "primitives": ["pos", "dropzeros", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the zeros, then take the absolute value of each.", "solution": "def op_pos_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_dropzeros_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_dropzeros_absval([]) == []\nassert op_pos_dropzeros_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropzeros_absval([5, 5, 5]) == [5, 5, 5]\nassert op_pos_dropzeros_absval([3, 1, 2]) == [3, 1, 2]\nassert op_pos_dropzeros_absval([10]) == [10]\nassert op_pos_dropzeros_absval([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropzeros_absval([-7, 12, -7]) == [12]"}
{"id": "op_negate_uniq_haszero", "entry_point": "op_negate_uniq_haszero", "primitives": ["negate", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_negate_uniq_haszero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_negate_uniq_haszero([1, 2, 3, 4]) == False\nassert op_negate_uniq_haszero([]) == False\nassert op_negate_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_negate_uniq_haszero([5, 5, 5]) == False\nassert op_negate_uniq_haszero([3, 1, 2]) == False\nassert op_negate_uniq_haszero([10]) == False\nassert op_negate_uniq_haszero([2, 4, 6]) == False\nassert op_negate_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_square_evens", "entry_point": "op_gt5_square_evens", "primitives": ["gt5", "square", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then square each, then keep the even numbers.", "solution": "def op_gt5_square_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_gt5_square_evens([1, 2, 3, 4]) == []\nassert op_gt5_square_evens([]) == []\nassert op_gt5_square_evens([-2, -1, 0, 1, 2]) == []\nassert op_gt5_square_evens([5, 5, 5]) == []\nassert op_gt5_square_evens([3, 1, 2]) == []\nassert op_gt5_square_evens([10]) == [100]\nassert op_gt5_square_evens([2, 4, 6]) == [36]\nassert op_gt5_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_square_dropwhileneg_anyeven", "entry_point": "op_square_dropwhileneg_anyeven", "primitives": ["square", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then return whether any value is even.", "solution": "def op_square_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_square_dropwhileneg_anyeven([]) == False\nassert op_square_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_square_dropwhileneg_anyeven([3, 1, 2]) == True\nassert op_square_dropwhileneg_anyeven([10]) == True\nassert op_square_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_square_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_square_double_trimends", "entry_point": "op_square_double_trimends", "primitives": ["square", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then drop the first and last elements.", "solution": "def op_square_double_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_square_double_trimends([1, 2, 3, 4]) == [8, 18]\nassert op_square_double_trimends([]) == []\nassert op_square_double_trimends([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_square_double_trimends([5, 5, 5]) == [50]\nassert op_square_double_trimends([3, 1, 2]) == [2]\nassert op_square_double_trimends([10]) == []\nassert op_square_double_trimends([2, 4, 6]) == [32]\nassert op_square_double_trimends([-7, 12, -7]) == [288]"}
{"id": "op_takewhilepos_sorta_sum", "entry_point": "op_takewhilepos_sorta_sum", "primitives": ["takewhilepos", "sorta", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending, then return their sum.", "solution": "def op_takewhilepos_sorta_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_takewhilepos_sorta_sum([1, 2, 3, 4]) == 10\nassert op_takewhilepos_sorta_sum([]) == 0\nassert op_takewhilepos_sorta_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sorta_sum([5, 5, 5]) == 15\nassert op_takewhilepos_sorta_sum([3, 1, 2]) == 6\nassert op_takewhilepos_sorta_sum([10]) == 10\nassert op_takewhilepos_sorta_sum([2, 4, 6]) == 12\nassert op_takewhilepos_sorta_sum([-7, 12, -7]) == 0"}
{"id": "op_square_last3_neg", "entry_point": "op_square_last3_neg", "primitives": ["square", "last3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then keep the negative numbers.", "solution": "def op_square_last3_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_last3_neg([1, 2, 3, 4]) == []\nassert op_square_last3_neg([]) == []\nassert op_square_last3_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_last3_neg([5, 5, 5]) == []\nassert op_square_last3_neg([3, 1, 2]) == []\nassert op_square_last3_neg([10]) == []\nassert op_square_last3_neg([2, 4, 6]) == []\nassert op_square_last3_neg([-7, 12, -7]) == []"}
{"id": "op_rev_neg_odds", "entry_point": "op_rev_neg_odds", "primitives": ["rev", "neg", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_rev_neg_odds(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_rev_neg_odds([1, 2, 3, 4]) == []\nassert op_rev_neg_odds([]) == []\nassert op_rev_neg_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_rev_neg_odds([5, 5, 5]) == []\nassert op_rev_neg_odds([3, 1, 2]) == []\nassert op_rev_neg_odds([10]) == []\nassert op_rev_neg_odds([2, 4, 6]) == []\nassert op_rev_neg_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_ages_padto3_odds", "entry_point": "op_ages_padto3_odds", "primitives": ["ages", "padto3", "odds"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_ages_padto3_odds(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_ages_padto3_odds([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_padto3_odds([]) == []\nassert op_ages_padto3_odds([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_padto3_odds([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortabs_padto3_div3", "entry_point": "op_sortabs_padto3_div3", "primitives": ["sortabs", "padto3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then keep multiples of three.", "solution": "def op_sortabs_padto3_div3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortabs_padto3_div3([1, 2, 3, 4]) == [3]\nassert op_sortabs_padto3_div3([]) == [0, 0, 0]\nassert op_sortabs_padto3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortabs_padto3_div3([5, 5, 5]) == []\nassert op_sortabs_padto3_div3([3, 1, 2]) == [3]\nassert op_sortabs_padto3_div3([10]) == [0, 0]\nassert op_sortabs_padto3_div3([2, 4, 6]) == [6]\nassert op_sortabs_padto3_div3([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_add10_uniq", "entry_point": "op_oremptyzero_add10_uniq", "primitives": ["oremptyzero", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_add10_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_add10_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_oremptyzero_add10_uniq([]) == [10]\nassert op_oremptyzero_add10_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_oremptyzero_add10_uniq([5, 5, 5]) == [15]\nassert op_oremptyzero_add10_uniq([3, 1, 2]) == [13, 11, 12]\nassert op_oremptyzero_add10_uniq([10]) == [20]\nassert op_oremptyzero_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_oremptyzero_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_clamp10_evens_negate", "entry_point": "op_clamp10_evens_negate", "primitives": ["clamp10", "evens", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers, then negate each.", "solution": "def op_clamp10_evens_negate(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_clamp10_evens_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_clamp10_evens_negate([]) == []\nassert op_clamp10_evens_negate([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_clamp10_evens_negate([5, 5, 5]) == []\nassert op_clamp10_evens_negate([3, 1, 2]) == [-2]\nassert op_clamp10_evens_negate([10]) == [-10]\nassert op_clamp10_evens_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_clamp10_evens_negate([-7, 12, -7]) == [-10]"}
{"id": "op_dec_add10_haszero", "entry_point": "op_dec_add10_haszero", "primitives": ["dec", "add10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then return whether the list contains a zero.", "solution": "def op_dec_add10_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return 0 in r", "tests": "assert op_dec_add10_haszero([1, 2, 3, 4]) == False\nassert op_dec_add10_haszero([]) == False\nassert op_dec_add10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dec_add10_haszero([5, 5, 5]) == False\nassert op_dec_add10_haszero([3, 1, 2]) == False\nassert op_dec_add10_haszero([10]) == False\nassert op_dec_add10_haszero([2, 4, 6]) == False\nassert op_dec_add10_haszero([-7, 12, -7]) == False"}
{"id": "op_rev_absval_trimends", "entry_point": "op_rev_absval_trimends", "primitives": ["rev", "absval", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_rev_absval_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_absval_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_rev_absval_trimends([]) == []\nassert op_rev_absval_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_rev_absval_trimends([5, 5, 5]) == [5]\nassert op_rev_absval_trimends([3, 1, 2]) == [1]\nassert op_rev_absval_trimends([10]) == []\nassert op_rev_absval_trimends([2, 4, 6]) == [4]\nassert op_rev_absval_trimends([-7, 12, -7]) == [12]"}
{"id": "op_last3_sortabs_sortd", "entry_point": "op_last3_sortabs_sortd", "primitives": ["last3", "sortabs", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then sort descending.", "solution": "def op_last3_sortabs_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_sortabs_sortd([]) == []\nassert op_last3_sortabs_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_sortabs_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_sortabs_sortd([10]) == [10]\nassert op_last3_sortabs_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_sortabs_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_negate_dropzeros_min", "entry_point": "op_negate_dropzeros_min", "primitives": ["negate", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_negate_dropzeros_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_negate_dropzeros_min([1, 2, 3, 4]) == -4\nassert op_negate_dropzeros_min([]) == 0\nassert op_negate_dropzeros_min([-2, -1, 0, 1, 2]) == -2\nassert op_negate_dropzeros_min([5, 5, 5]) == -5\nassert op_negate_dropzeros_min([3, 1, 2]) == -3\nassert op_negate_dropzeros_min([10]) == -10\nassert op_negate_dropzeros_min([2, 4, 6]) == -6\nassert op_negate_dropzeros_min([-7, 12, -7]) == -12"}
{"id": "op_first3_dec_last3", "entry_point": "op_first3_dec_last3", "primitives": ["first3", "dec", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then keep only the last three.", "solution": "def op_first3_dec_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_dec_last3([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_dec_last3([]) == []\nassert op_first3_dec_last3([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_first3_dec_last3([5, 5, 5]) == [4, 4, 4]\nassert op_first3_dec_last3([3, 1, 2]) == [2, 0, 1]\nassert op_first3_dec_last3([10]) == [9]\nassert op_first3_dec_last3([2, 4, 6]) == [1, 3, 5]\nassert op_first3_dec_last3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_neg_padto3_haszero", "entry_point": "op_neg_padto3_haszero", "primitives": ["neg", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_neg_padto3_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_neg_padto3_haszero([1, 2, 3, 4]) == True\nassert op_neg_padto3_haszero([]) == True\nassert op_neg_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_neg_padto3_haszero([5, 5, 5]) == True\nassert op_neg_padto3_haszero([3, 1, 2]) == True\nassert op_neg_padto3_haszero([10]) == True\nassert op_neg_padto3_haszero([2, 4, 6]) == True\nassert op_neg_padto3_haszero([-7, 12, -7]) == True"}
{"id": "op_last3_padto3_double", "entry_point": "op_last3_padto3_double", "primitives": ["last3", "padto3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then double each.", "solution": "def op_last3_padto3_double(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_last3_padto3_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_padto3_double([]) == [0, 0, 0]\nassert op_last3_padto3_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_last3_padto3_double([5, 5, 5]) == [10, 10, 10]\nassert op_last3_padto3_double([3, 1, 2]) == [6, 2, 4]\nassert op_last3_padto3_double([10]) == [20, 0, 0]\nassert op_last3_padto3_double([2, 4, 6]) == [4, 8, 12]\nassert op_last3_padto3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_div3_oremptyzero_alldistinct", "entry_point": "op_div3_oremptyzero_alldistinct", "primitives": ["div3", "oremptyzero", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then return whether all values are distinct.", "solution": "def op_div3_oremptyzero_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return len(r) == len(set(r))", "tests": "assert op_div3_oremptyzero_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_oremptyzero_alldistinct([]) == True\nassert op_div3_oremptyzero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_oremptyzero_alldistinct([5, 5, 5]) == True\nassert op_div3_oremptyzero_alldistinct([3, 1, 2]) == True\nassert op_div3_oremptyzero_alldistinct([10]) == True\nassert op_div3_oremptyzero_alldistinct([2, 4, 6]) == True\nassert op_div3_oremptyzero_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_dec_prod", "entry_point": "op_div3_dec_prod", "primitives": ["div3", "dec", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each, then return their product.", "solution": "def op_div3_dec_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_div3_dec_prod([1, 2, 3, 4]) == 2\nassert op_div3_dec_prod([]) == 1\nassert op_div3_dec_prod([-2, -1, 0, 1, 2]) == -1\nassert op_div3_dec_prod([5, 5, 5]) == 1\nassert op_div3_dec_prod([3, 1, 2]) == 2\nassert op_div3_dec_prod([10]) == 1\nassert op_div3_dec_prod([2, 4, 6]) == 5\nassert op_div3_dec_prod([-7, 12, -7]) == 11"}
{"id": "op_ages_padto3_pos", "entry_point": "op_ages_padto3_pos", "primitives": ["ages", "padto3", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then keep the positive numbers.", "solution": "def op_ages_padto3_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_padto3_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_padto3_pos([]) == []\nassert op_ages_padto3_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_padto3_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_oremptyzero_odds_min", "entry_point": "op_oremptyzero_odds_min", "primitives": ["oremptyzero", "odds", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then return the minimum (0 if empty).", "solution": "def op_oremptyzero_odds_min(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return min(r) if r else 0", "tests": "assert op_oremptyzero_odds_min([1, 2, 3, 4]) == 1\nassert op_oremptyzero_odds_min([]) == 0\nassert op_oremptyzero_odds_min([-2, -1, 0, 1, 2]) == -1\nassert op_oremptyzero_odds_min([5, 5, 5]) == 5\nassert op_oremptyzero_odds_min([3, 1, 2]) == 1\nassert op_oremptyzero_odds_min([10]) == 0\nassert op_oremptyzero_odds_min([2, 4, 6]) == 0\nassert op_oremptyzero_odds_min([-7, 12, -7]) == -7"}
{"id": "op_add10_clamp10_neg", "entry_point": "op_add10_clamp10_neg", "primitives": ["add10", "clamp10", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then keep the negative numbers.", "solution": "def op_add10_clamp10_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_clamp10_neg([1, 2, 3, 4]) == []\nassert op_add10_clamp10_neg([]) == []\nassert op_add10_clamp10_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_clamp10_neg([5, 5, 5]) == []\nassert op_add10_clamp10_neg([3, 1, 2]) == []\nassert op_add10_clamp10_neg([10]) == []\nassert op_add10_clamp10_neg([2, 4, 6]) == []\nassert op_add10_clamp10_neg([-7, 12, -7]) == []"}
{"id": "op_div3_rev_last3", "entry_point": "op_div3_rev_last3", "primitives": ["div3", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then keep only the last three.", "solution": "def op_div3_rev_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_div3_rev_last3([1, 2, 3, 4]) == [3]\nassert op_div3_rev_last3([]) == []\nassert op_div3_rev_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev_last3([5, 5, 5]) == []\nassert op_div3_rev_last3([3, 1, 2]) == [3]\nassert op_div3_rev_last3([10]) == []\nassert op_div3_rev_last3([2, 4, 6]) == [6]\nassert op_div3_rev_last3([-7, 12, -7]) == [12]"}
{"id": "op_div3_inc_max", "entry_point": "op_div3_inc_max", "primitives": ["div3", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then return the maximum (0 if empty).", "solution": "def op_div3_inc_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_div3_inc_max([1, 2, 3, 4]) == 4\nassert op_div3_inc_max([]) == 0\nassert op_div3_inc_max([-2, -1, 0, 1, 2]) == 1\nassert op_div3_inc_max([5, 5, 5]) == 0\nassert op_div3_inc_max([3, 1, 2]) == 4\nassert op_div3_inc_max([10]) == 0\nassert op_div3_inc_max([2, 4, 6]) == 7\nassert op_div3_inc_max([-7, 12, -7]) == 13"}
{"id": "op_uniq_absval_double", "entry_point": "op_uniq_absval_double", "primitives": ["uniq", "absval", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then double each.", "solution": "def op_uniq_absval_double(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_uniq_absval_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_absval_double([]) == []\nassert op_uniq_absval_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_uniq_absval_double([5, 5, 5]) == [10]\nassert op_uniq_absval_double([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_absval_double([10]) == [20]\nassert op_uniq_absval_double([2, 4, 6]) == [4, 8, 12]\nassert op_uniq_absval_double([-7, 12, -7]) == [14, 24]"}
{"id": "op_clamp10_double_add10", "entry_point": "op_clamp10_double_add10", "primitives": ["clamp10", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then add ten to each.", "solution": "def op_clamp10_double_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_double_add10([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_clamp10_double_add10([]) == []\nassert op_clamp10_double_add10([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_clamp10_double_add10([5, 5, 5]) == [20, 20, 20]\nassert op_clamp10_double_add10([3, 1, 2]) == [16, 12, 14]\nassert op_clamp10_double_add10([10]) == [30]\nassert op_clamp10_double_add10([2, 4, 6]) == [14, 18, 22]\nassert op_clamp10_double_add10([-7, 12, -7]) == [-4, 30, -4]"}
{"id": "op_inc_padto3_last3", "entry_point": "op_inc_padto3_last3", "primitives": ["inc", "padto3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_inc_padto3_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_inc_padto3_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_padto3_last3([]) == [0, 0, 0]\nassert op_inc_padto3_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_padto3_last3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_padto3_last3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_padto3_last3([10]) == [11, 0, 0]\nassert op_inc_padto3_last3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_padto3_last3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropwhileneg_add10_sum", "entry_point": "op_dropwhileneg_add10_sum", "primitives": ["dropwhileneg", "add10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then return their sum.", "solution": "def op_dropwhileneg_add10_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_dropwhileneg_add10_sum([1, 2, 3, 4]) == 50\nassert op_dropwhileneg_add10_sum([]) == 0\nassert op_dropwhileneg_add10_sum([-2, -1, 0, 1, 2]) == 33\nassert op_dropwhileneg_add10_sum([5, 5, 5]) == 45\nassert op_dropwhileneg_add10_sum([3, 1, 2]) == 36\nassert op_dropwhileneg_add10_sum([10]) == 20\nassert op_dropwhileneg_add10_sum([2, 4, 6]) == 42\nassert op_dropwhileneg_add10_sum([-7, 12, -7]) == 25"}
{"id": "op_double_add10_sorta", "entry_point": "op_double_add10_sorta", "primitives": ["double", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then sort ascending.", "solution": "def op_double_add10_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_double_add10_sorta([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_add10_sorta([]) == []\nassert op_double_add10_sorta([-2, -1, 0, 1, 2]) == [6, 8, 10, 12, 14]\nassert op_double_add10_sorta([5, 5, 5]) == [20, 20, 20]\nassert op_double_add10_sorta([3, 1, 2]) == [12, 14, 16]\nassert op_double_add10_sorta([10]) == [30]\nassert op_double_add10_sorta([2, 4, 6]) == [14, 18, 22]\nassert op_double_add10_sorta([-7, 12, -7]) == [-4, -4, 34]"}
{"id": "op_div3_takewhilepos_anyeven", "entry_point": "op_div3_takewhilepos_anyeven", "primitives": ["div3", "takewhilepos", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then return whether any value is even.", "solution": "def op_div3_takewhilepos_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_takewhilepos_anyeven([1, 2, 3, 4]) == False\nassert op_div3_takewhilepos_anyeven([]) == False\nassert op_div3_takewhilepos_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_div3_takewhilepos_anyeven([5, 5, 5]) == False\nassert op_div3_takewhilepos_anyeven([3, 1, 2]) == False\nassert op_div3_takewhilepos_anyeven([10]) == False\nassert op_div3_takewhilepos_anyeven([2, 4, 6]) == True\nassert op_div3_takewhilepos_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_pos_anyeven", "entry_point": "op_uniq_pos_anyeven", "primitives": ["uniq", "pos", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then return whether any value is even.", "solution": "def op_uniq_pos_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_pos_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_pos_anyeven([]) == False\nassert op_uniq_pos_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_pos_anyeven([5, 5, 5]) == False\nassert op_uniq_pos_anyeven([3, 1, 2]) == True\nassert op_uniq_pos_anyeven([10]) == True\nassert op_uniq_pos_anyeven([2, 4, 6]) == True\nassert op_uniq_pos_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_add10_dec", "entry_point": "op_sorta_add10_dec", "primitives": ["sorta", "add10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then subtract one from each.", "solution": "def op_sorta_add10_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_add10_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_sorta_add10_dec([]) == []\nassert op_sorta_add10_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_sorta_add10_dec([5, 5, 5]) == [14, 14, 14]\nassert op_sorta_add10_dec([3, 1, 2]) == [10, 11, 12]\nassert op_sorta_add10_dec([10]) == [19]\nassert op_sorta_add10_dec([2, 4, 6]) == [11, 13, 15]\nassert op_sorta_add10_dec([-7, 12, -7]) == [2, 2, 21]"}
{"id": "op_odds_clamp10_inc", "entry_point": "op_odds_clamp10_inc", "primitives": ["odds", "clamp10", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then add one to each.", "solution": "def op_odds_clamp10_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_odds_clamp10_inc([1, 2, 3, 4]) == [2, 4]\nassert op_odds_clamp10_inc([]) == []\nassert op_odds_clamp10_inc([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_odds_clamp10_inc([5, 5, 5]) == [6, 6, 6]\nassert op_odds_clamp10_inc([3, 1, 2]) == [4, 2]\nassert op_odds_clamp10_inc([10]) == []\nassert op_odds_clamp10_inc([2, 4, 6]) == []\nassert op_odds_clamp10_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_inc_last3_sum", "entry_point": "op_inc_last3_sum", "primitives": ["inc", "last3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then return their sum.", "solution": "def op_inc_last3_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_inc_last3_sum([1, 2, 3, 4]) == 12\nassert op_inc_last3_sum([]) == 0\nassert op_inc_last3_sum([-2, -1, 0, 1, 2]) == 6\nassert op_inc_last3_sum([5, 5, 5]) == 18\nassert op_inc_last3_sum([3, 1, 2]) == 9\nassert op_inc_last3_sum([10]) == 11\nassert op_inc_last3_sum([2, 4, 6]) == 15\nassert op_inc_last3_sum([-7, 12, -7]) == 1"}
{"id": "op_gt5_oremptyzero_sorta", "entry_point": "op_gt5_oremptyzero_sorta", "primitives": ["gt5", "oremptyzero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then sort ascending.", "solution": "def op_gt5_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_oremptyzero_sorta([1, 2, 3, 4]) == [0]\nassert op_gt5_oremptyzero_sorta([]) == [0]\nassert op_gt5_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_oremptyzero_sorta([5, 5, 5]) == [0]\nassert op_gt5_oremptyzero_sorta([3, 1, 2]) == [0]\nassert op_gt5_oremptyzero_sorta([10]) == [10]\nassert op_gt5_oremptyzero_sorta([2, 4, 6]) == [6]\nassert op_gt5_oremptyzero_sorta([-7, 12, -7]) == [12]"}
{"id": "op_neg_negate_absval", "entry_point": "op_neg_negate_absval", "primitives": ["neg", "negate", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then take the absolute value of each.", "solution": "def op_neg_negate_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_neg_negate_absval([1, 2, 3, 4]) == []\nassert op_neg_negate_absval([]) == []\nassert op_neg_negate_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_negate_absval([5, 5, 5]) == []\nassert op_neg_negate_absval([3, 1, 2]) == []\nassert op_neg_negate_absval([10]) == []\nassert op_neg_negate_absval([2, 4, 6]) == []\nassert op_neg_negate_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_takewhilepos_trimends_issorted", "entry_point": "op_takewhilepos_trimends_issorted", "primitives": ["takewhilepos", "trimends", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_takewhilepos_trimends_issorted(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_takewhilepos_trimends_issorted([1, 2, 3, 4]) == True\nassert op_takewhilepos_trimends_issorted([]) == True\nassert op_takewhilepos_trimends_issorted([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_trimends_issorted([5, 5, 5]) == True\nassert op_takewhilepos_trimends_issorted([3, 1, 2]) == True\nassert op_takewhilepos_trimends_issorted([10]) == True\nassert op_takewhilepos_trimends_issorted([2, 4, 6]) == True\nassert op_takewhilepos_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_rev_beforezero_neg", "entry_point": "op_rev_beforezero_neg", "primitives": ["rev", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_rev_beforezero_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_beforezero_neg([1, 2, 3, 4]) == []\nassert op_rev_beforezero_neg([]) == []\nassert op_rev_beforezero_neg([-2, -1, 0, 1, 2]) == []\nassert op_rev_beforezero_neg([5, 5, 5]) == []\nassert op_rev_beforezero_neg([3, 1, 2]) == []\nassert op_rev_beforezero_neg([10]) == []\nassert op_rev_beforezero_neg([2, 4, 6]) == []\nassert op_rev_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_clamp10_padto3", "entry_point": "op_sortabs_clamp10_padto3", "primitives": ["sortabs", "clamp10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_sortabs_clamp10_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_clamp10_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_clamp10_padto3([]) == [0, 0, 0]\nassert op_sortabs_clamp10_padto3([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_clamp10_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_clamp10_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_clamp10_padto3([10]) == [10, 0, 0]\nassert op_sortabs_clamp10_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_clamp10_padto3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_dropfirst_trimends_double", "entry_point": "op_dropfirst_trimends_double", "primitives": ["dropfirst", "trimends", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then double each.", "solution": "def op_dropfirst_trimends_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_trimends_double([1, 2, 3, 4]) == [6]\nassert op_dropfirst_trimends_double([]) == []\nassert op_dropfirst_trimends_double([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropfirst_trimends_double([5, 5, 5]) == []\nassert op_dropfirst_trimends_double([3, 1, 2]) == []\nassert op_dropfirst_trimends_double([10]) == []\nassert op_dropfirst_trimends_double([2, 4, 6]) == []\nassert op_dropfirst_trimends_double([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_gt5_sortabs", "entry_point": "op_oremptyzero_gt5_sortabs", "primitives": ["oremptyzero", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then sort by absolute value.", "solution": "def op_oremptyzero_gt5_sortabs(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_oremptyzero_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_sortabs([]) == []\nassert op_oremptyzero_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_sortabs([5, 5, 5]) == []\nassert op_oremptyzero_gt5_sortabs([3, 1, 2]) == []\nassert op_oremptyzero_gt5_sortabs([10]) == [10]\nassert op_oremptyzero_gt5_sortabs([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_absval_rev_dropzeros", "entry_point": "op_absval_rev_dropzeros", "primitives": ["absval", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then drop the zeros.", "solution": "def op_absval_rev_dropzeros(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_absval_rev_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_rev_dropzeros([]) == []\nassert op_absval_rev_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_absval_rev_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_absval_rev_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_absval_rev_dropzeros([10]) == [10]\nassert op_absval_rev_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_absval_rev_dropzeros([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_div3_counteven", "entry_point": "op_double_div3_counteven", "primitives": ["double", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then return how many values are even.", "solution": "def op_double_div3_counteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_double_div3_counteven([1, 2, 3, 4]) == 1\nassert op_double_div3_counteven([]) == 0\nassert op_double_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_double_div3_counteven([5, 5, 5]) == 0\nassert op_double_div3_counteven([3, 1, 2]) == 1\nassert op_double_div3_counteven([10]) == 0\nassert op_double_div3_counteven([2, 4, 6]) == 1\nassert op_double_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_pos_absval_firsteven", "entry_point": "op_pos_absval_firsteven", "primitives": ["pos", "absval", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_pos_absval_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_absval_firsteven([1, 2, 3, 4]) == 2\nassert op_pos_absval_firsteven([]) == 0\nassert op_pos_absval_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_absval_firsteven([5, 5, 5]) == 0\nassert op_pos_absval_firsteven([3, 1, 2]) == 2\nassert op_pos_absval_firsteven([10]) == 10\nassert op_pos_absval_firsteven([2, 4, 6]) == 2\nassert op_pos_absval_firsteven([-7, 12, -7]) == 12"}
{"id": "op_clamp10_padto3_first3", "entry_point": "op_clamp10_padto3_first3", "primitives": ["clamp10", "padto3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then keep only the first three.", "solution": "def op_clamp10_padto3_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_padto3_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_padto3_first3([]) == [0, 0, 0]\nassert op_clamp10_padto3_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_clamp10_padto3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3_first3([10]) == [10, 0, 0]\nassert op_clamp10_padto3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3_first3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_takewhilepos_oremptyzero_min", "entry_point": "op_takewhilepos_oremptyzero_min", "primitives": ["takewhilepos", "oremptyzero", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_oremptyzero_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_oremptyzero_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_oremptyzero_min([]) == 0\nassert op_takewhilepos_oremptyzero_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_oremptyzero_min([5, 5, 5]) == 5\nassert op_takewhilepos_oremptyzero_min([3, 1, 2]) == 1\nassert op_takewhilepos_oremptyzero_min([10]) == 10\nassert op_takewhilepos_oremptyzero_min([2, 4, 6]) == 2\nassert op_takewhilepos_oremptyzero_min([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_square_dec", "entry_point": "op_oremptyzero_square_dec", "primitives": ["oremptyzero", "square", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then subtract one from each.", "solution": "def op_oremptyzero_square_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_square_dec([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_oremptyzero_square_dec([]) == [-1]\nassert op_oremptyzero_square_dec([-2, -1, 0, 1, 2]) == [3, 0, -1, 0, 3]\nassert op_oremptyzero_square_dec([5, 5, 5]) == [24, 24, 24]\nassert op_oremptyzero_square_dec([3, 1, 2]) == [8, 0, 3]\nassert op_oremptyzero_square_dec([10]) == [99]\nassert op_oremptyzero_square_dec([2, 4, 6]) == [3, 15, 35]\nassert op_oremptyzero_square_dec([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_last3_sortabs_firsteven", "entry_point": "op_last3_sortabs_firsteven", "primitives": ["last3", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_last3_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_last3_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_last3_sortabs_firsteven([]) == 0\nassert op_last3_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_last3_sortabs_firsteven([5, 5, 5]) == 0\nassert op_last3_sortabs_firsteven([3, 1, 2]) == 2\nassert op_last3_sortabs_firsteven([10]) == 10\nassert op_last3_sortabs_firsteven([2, 4, 6]) == 2\nassert op_last3_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sorta_takewhilepos_inc", "entry_point": "op_sorta_takewhilepos_inc", "primitives": ["sorta", "takewhilepos", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then add one to each.", "solution": "def op_sorta_takewhilepos_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_takewhilepos_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_takewhilepos_inc([]) == []\nassert op_sorta_takewhilepos_inc([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_takewhilepos_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_takewhilepos_inc([10]) == [11]\nassert op_sorta_takewhilepos_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_takewhilepos_inc([-7, 12, -7]) == []"}
{"id": "op_dropfirst_dropzeros_counteven", "entry_point": "op_dropfirst_dropzeros_counteven", "primitives": ["dropfirst", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then return how many values are even.", "solution": "def op_dropfirst_dropzeros_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_dropzeros_counteven([]) == 0\nassert op_dropfirst_dropzeros_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_dropfirst_dropzeros_counteven([5, 5, 5]) == 0\nassert op_dropfirst_dropzeros_counteven([3, 1, 2]) == 1\nassert op_dropfirst_dropzeros_counteven([10]) == 0\nassert op_dropfirst_dropzeros_counteven([2, 4, 6]) == 2\nassert op_dropfirst_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_odds_len", "entry_point": "op_clamp10_odds_len", "primitives": ["clamp10", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then return how many remain.", "solution": "def op_clamp10_odds_len(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_clamp10_odds_len([1, 2, 3, 4]) == 2\nassert op_clamp10_odds_len([]) == 0\nassert op_clamp10_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_clamp10_odds_len([5, 5, 5]) == 3\nassert op_clamp10_odds_len([3, 1, 2]) == 2\nassert op_clamp10_odds_len([10]) == 0\nassert op_clamp10_odds_len([2, 4, 6]) == 0\nassert op_clamp10_odds_len([-7, 12, -7]) == 2"}
{"id": "op_sortage_ages_evens", "entry_point": "op_sortage_ages_evens", "primitives": ["sortage", "ages", "evens"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then keep the even numbers.", "solution": "def op_sortage_ages_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortage_ages_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_sortage_ages_evens([]) == []\nassert op_sortage_ages_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_sortage_ages_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_neg_dropzeros_add10", "entry_point": "op_neg_dropzeros_add10", "primitives": ["neg", "dropzeros", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then add ten to each.", "solution": "def op_neg_dropzeros_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_dropzeros_add10([1, 2, 3, 4]) == []\nassert op_neg_dropzeros_add10([]) == []\nassert op_neg_dropzeros_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_neg_dropzeros_add10([5, 5, 5]) == []\nassert op_neg_dropzeros_add10([3, 1, 2]) == []\nassert op_neg_dropzeros_add10([10]) == []\nassert op_neg_dropzeros_add10([2, 4, 6]) == []\nassert op_neg_dropzeros_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_inc_div3_clamp10", "entry_point": "op_inc_div3_clamp10", "primitives": ["inc", "div3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then cap each value at 10.", "solution": "def op_inc_div3_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_inc_div3_clamp10([]) == []\nassert op_inc_div3_clamp10([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_inc_div3_clamp10([5, 5, 5]) == [6, 6, 6]\nassert op_inc_div3_clamp10([3, 1, 2]) == [3]\nassert op_inc_div3_clamp10([10]) == []\nassert op_inc_div3_clamp10([2, 4, 6]) == [3]\nassert op_inc_div3_clamp10([-7, 12, -7]) == [-6, -6]"}
{"id": "op_oremptyzero_gt5_uniq", "entry_point": "op_oremptyzero_gt5_uniq", "primitives": ["oremptyzero", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_gt5_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_gt5_uniq([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_uniq([]) == []\nassert op_oremptyzero_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_uniq([5, 5, 5]) == []\nassert op_oremptyzero_gt5_uniq([3, 1, 2]) == []\nassert op_oremptyzero_gt5_uniq([10]) == [10]\nassert op_oremptyzero_gt5_uniq([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_uniq([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_padto3_neg", "entry_point": "op_beforezero_padto3_neg", "primitives": ["beforezero", "padto3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_beforezero_padto3_neg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_beforezero_padto3_neg([1, 2, 3, 4]) == []\nassert op_beforezero_padto3_neg([]) == []\nassert op_beforezero_padto3_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_padto3_neg([5, 5, 5]) == []\nassert op_beforezero_padto3_neg([3, 1, 2]) == []\nassert op_beforezero_padto3_neg([10]) == []\nassert op_beforezero_padto3_neg([2, 4, 6]) == []\nassert op_beforezero_padto3_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_gt5_absval", "entry_point": "op_evens_gt5_absval", "primitives": ["evens", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then take the absolute value of each.", "solution": "def op_evens_gt5_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_evens_gt5_absval([1, 2, 3, 4]) == []\nassert op_evens_gt5_absval([]) == []\nassert op_evens_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5_absval([5, 5, 5]) == []\nassert op_evens_gt5_absval([3, 1, 2]) == []\nassert op_evens_gt5_absval([10]) == [10]\nassert op_evens_gt5_absval([2, 4, 6]) == [6]\nassert op_evens_gt5_absval([-7, 12, -7]) == [12]"}
{"id": "op_first3_negate_square", "entry_point": "op_first3_negate_square", "primitives": ["first3", "negate", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then negate each, then square each.", "solution": "def op_first3_negate_square(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_first3_negate_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_negate_square([]) == []\nassert op_first3_negate_square([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_first3_negate_square([5, 5, 5]) == [25, 25, 25]\nassert op_first3_negate_square([3, 1, 2]) == [9, 1, 4]\nassert op_first3_negate_square([10]) == [100]\nassert op_first3_negate_square([2, 4, 6]) == [4, 16, 36]\nassert op_first3_negate_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sortabs_pos_haszero", "entry_point": "op_sortabs_pos_haszero", "primitives": ["sortabs", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_sortabs_pos_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_sortabs_pos_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_pos_haszero([]) == False\nassert op_sortabs_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_pos_haszero([5, 5, 5]) == False\nassert op_sortabs_pos_haszero([3, 1, 2]) == False\nassert op_sortabs_pos_haszero([10]) == False\nassert op_sortabs_pos_haszero([2, 4, 6]) == False\nassert op_sortabs_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_sorta_inc", "entry_point": "op_oremptyzero_sorta_inc", "primitives": ["oremptyzero", "sorta", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then add one to each.", "solution": "def op_oremptyzero_sorta_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_sorta_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_oremptyzero_sorta_inc([]) == [1]\nassert op_oremptyzero_sorta_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_oremptyzero_sorta_inc([5, 5, 5]) == [6, 6, 6]\nassert op_oremptyzero_sorta_inc([3, 1, 2]) == [2, 3, 4]\nassert op_oremptyzero_sorta_inc([10]) == [11]\nassert op_oremptyzero_sorta_inc([2, 4, 6]) == [3, 5, 7]\nassert op_oremptyzero_sorta_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_strip_prefixup_maxlen", "entry_point": "op_strip_prefixup_maxlen", "primitives": ["strip", "prefixup", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash, then return the length of the longest string (0 if none).", "solution": "def op_strip_prefixup_maxlen(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_strip_prefixup_maxlen(['Hello', 'world']) == 6\nassert op_strip_prefixup_maxlen([]) == 0\nassert op_strip_prefixup_maxlen(['  a ', '', 'BC', 'bc']) == 3\nassert op_strip_prefixup_maxlen(['one', 'one', 'Two']) == 4\nassert op_strip_prefixup_maxlen(['x']) == 2\nassert op_strip_prefixup_maxlen(['abc', 'de', '']) == 4"}
{"id": "op_takewhilepos_clamp10_square", "entry_point": "op_takewhilepos_clamp10_square", "primitives": ["takewhilepos", "clamp10", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then square each.", "solution": "def op_takewhilepos_clamp10_square(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_takewhilepos_clamp10_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_clamp10_square([]) == []\nassert op_takewhilepos_clamp10_square([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10_square([5, 5, 5]) == [25, 25, 25]\nassert op_takewhilepos_clamp10_square([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_clamp10_square([10]) == [100]\nassert op_takewhilepos_clamp10_square([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_clamp10_square([-7, 12, -7]) == []"}
{"id": "op_negate_beforezero_pos", "entry_point": "op_negate_beforezero_pos", "primitives": ["negate", "beforezero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_negate_beforezero_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_beforezero_pos([1, 2, 3, 4]) == []\nassert op_negate_beforezero_pos([]) == []\nassert op_negate_beforezero_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_beforezero_pos([5, 5, 5]) == []\nassert op_negate_beforezero_pos([3, 1, 2]) == []\nassert op_negate_beforezero_pos([10]) == []\nassert op_negate_beforezero_pos([2, 4, 6]) == []\nassert op_negate_beforezero_pos([-7, 12, -7]) == [7, 7]"}
{"id": "op_oremptyzero_double_dropzeros", "entry_point": "op_oremptyzero_double_dropzeros", "primitives": ["oremptyzero", "double", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then drop the zeros.", "solution": "def op_oremptyzero_double_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_double_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_oremptyzero_double_dropzeros([]) == []\nassert op_oremptyzero_double_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_oremptyzero_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_double_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_oremptyzero_double_dropzeros([10]) == [20]\nassert op_oremptyzero_double_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_oremptyzero_double_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dropwhileneg_padto3_square", "entry_point": "op_dropwhileneg_padto3_square", "primitives": ["dropwhileneg", "padto3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements, then square each.", "solution": "def op_dropwhileneg_padto3_square(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropwhileneg_padto3_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropwhileneg_padto3_square([]) == [0, 0, 0]\nassert op_dropwhileneg_padto3_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropwhileneg_padto3_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_padto3_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_padto3_square([10]) == [100, 0, 0]\nassert op_dropwhileneg_padto3_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_padto3_square([-7, 12, -7]) == [144, 49, 0]"}
{"id": "op_div3_last3_dropfirst", "entry_point": "op_div3_last3_dropfirst", "primitives": ["div3", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then drop the first element.", "solution": "def op_div3_last3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_div3_last3_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_last3_dropfirst([]) == []\nassert op_div3_last3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_last3_dropfirst([5, 5, 5]) == []\nassert op_div3_last3_dropfirst([3, 1, 2]) == []\nassert op_div3_last3_dropfirst([10]) == []\nassert op_div3_last3_dropfirst([2, 4, 6]) == []\nassert op_div3_last3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_uniq_double_padto3", "entry_point": "op_uniq_double_padto3", "primitives": ["uniq", "double", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then pad with zeros to at least three elements.", "solution": "def op_uniq_double_padto3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_uniq_double_padto3([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_double_padto3([]) == [0, 0, 0]\nassert op_uniq_double_padto3([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_uniq_double_padto3([5, 5, 5]) == [10, 0, 0]\nassert op_uniq_double_padto3([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_double_padto3([10]) == [20, 0, 0]\nassert op_uniq_double_padto3([2, 4, 6]) == [4, 8, 12]\nassert op_uniq_double_padto3([-7, 12, -7]) == [-14, 24, 0]"}
{"id": "op_gt5_dropfirst_dropzeros", "entry_point": "op_gt5_dropfirst_dropzeros", "primitives": ["gt5", "dropfirst", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then drop the zeros.", "solution": "def op_gt5_dropfirst_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_gt5_dropfirst_dropzeros([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_dropzeros([]) == []\nassert op_gt5_dropfirst_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_dropzeros([5, 5, 5]) == []\nassert op_gt5_dropfirst_dropzeros([3, 1, 2]) == []\nassert op_gt5_dropfirst_dropzeros([10]) == []\nassert op_gt5_dropfirst_dropzeros([2, 4, 6]) == []\nassert op_gt5_dropfirst_dropzeros([-7, 12, -7]) == []"}
{"id": "op_add10_takewhilepos_evens", "entry_point": "op_add10_takewhilepos_evens", "primitives": ["add10", "takewhilepos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then keep the even numbers.", "solution": "def op_add10_takewhilepos_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_takewhilepos_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_takewhilepos_evens([]) == []\nassert op_add10_takewhilepos_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_takewhilepos_evens([5, 5, 5]) == []\nassert op_add10_takewhilepos_evens([3, 1, 2]) == [12]\nassert op_add10_takewhilepos_evens([10]) == [20]\nassert op_add10_takewhilepos_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_takewhilepos_evens([-7, 12, -7]) == [22]"}
{"id": "op_padto3_clamp10_evens", "entry_point": "op_padto3_clamp10_evens", "primitives": ["padto3", "clamp10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10, then keep the even numbers.", "solution": "def op_padto3_clamp10_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_clamp10_evens([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_clamp10_evens([]) == [0, 0, 0]\nassert op_padto3_clamp10_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_padto3_clamp10_evens([5, 5, 5]) == []\nassert op_padto3_clamp10_evens([3, 1, 2]) == [2]\nassert op_padto3_clamp10_evens([10]) == [10, 0, 0]\nassert op_padto3_clamp10_evens([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_clamp10_evens([-7, 12, -7]) == [10]"}
{"id": "op_square_pos_allpos", "entry_point": "op_square_pos_allpos", "primitives": ["square", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_square_pos_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_square_pos_allpos([1, 2, 3, 4]) == True\nassert op_square_pos_allpos([]) == True\nassert op_square_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_square_pos_allpos([5, 5, 5]) == True\nassert op_square_pos_allpos([3, 1, 2]) == True\nassert op_square_pos_allpos([10]) == True\nassert op_square_pos_allpos([2, 4, 6]) == True\nassert op_square_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_evens_sortd_clamp10", "entry_point": "op_evens_sortd_clamp10", "primitives": ["evens", "sortd", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then cap each value at 10.", "solution": "def op_evens_sortd_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_sortd_clamp10([1, 2, 3, 4]) == [4, 2]\nassert op_evens_sortd_clamp10([]) == []\nassert op_evens_sortd_clamp10([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_sortd_clamp10([5, 5, 5]) == []\nassert op_evens_sortd_clamp10([3, 1, 2]) == [2]\nassert op_evens_sortd_clamp10([10]) == [10]\nassert op_evens_sortd_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_evens_sortd_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_square_trimends_anyeven", "entry_point": "op_square_trimends_anyeven", "primitives": ["square", "trimends", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first and last elements, then return whether any value is even.", "solution": "def op_square_trimends_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:-1]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_trimends_anyeven([1, 2, 3, 4]) == True\nassert op_square_trimends_anyeven([]) == False\nassert op_square_trimends_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_trimends_anyeven([5, 5, 5]) == False\nassert op_square_trimends_anyeven([3, 1, 2]) == False\nassert op_square_trimends_anyeven([10]) == False\nassert op_square_trimends_anyeven([2, 4, 6]) == True\nassert op_square_trimends_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_last3_prod", "entry_point": "op_evens_last3_prod", "primitives": ["evens", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then return their product.", "solution": "def op_evens_last3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_evens_last3_prod([1, 2, 3, 4]) == 8\nassert op_evens_last3_prod([]) == 1\nassert op_evens_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_last3_prod([5, 5, 5]) == 1\nassert op_evens_last3_prod([3, 1, 2]) == 2\nassert op_evens_last3_prod([10]) == 10\nassert op_evens_last3_prod([2, 4, 6]) == 48\nassert op_evens_last3_prod([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_first3_gt5", "entry_point": "op_oremptyzero_first3_gt5", "primitives": ["oremptyzero", "first3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then keep values greater than five.", "solution": "def op_oremptyzero_first3_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_first3_gt5([1, 2, 3, 4]) == []\nassert op_oremptyzero_first3_gt5([]) == []\nassert op_oremptyzero_first3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_first3_gt5([5, 5, 5]) == []\nassert op_oremptyzero_first3_gt5([3, 1, 2]) == []\nassert op_oremptyzero_first3_gt5([10]) == [10]\nassert op_oremptyzero_first3_gt5([2, 4, 6]) == [6]\nassert op_oremptyzero_first3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_first3_firsteven", "entry_point": "op_sortabs_first3_firsteven", "primitives": ["sortabs", "first3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_sortabs_first3_firsteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sortabs_first3_firsteven([1, 2, 3, 4]) == 2\nassert op_sortabs_first3_firsteven([]) == 0\nassert op_sortabs_first3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_first3_firsteven([5, 5, 5]) == 0\nassert op_sortabs_first3_firsteven([3, 1, 2]) == 2\nassert op_sortabs_first3_firsteven([10]) == 10\nassert op_sortabs_first3_firsteven([2, 4, 6]) == 2\nassert op_sortabs_first3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sortabs_uniq_inc", "entry_point": "op_sortabs_uniq_inc", "primitives": ["sortabs", "uniq", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_sortabs_uniq_inc(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortabs_uniq_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_uniq_inc([]) == []\nassert op_sortabs_uniq_inc([-2, -1, 0, 1, 2]) == [1, 0, 2, -1, 3]\nassert op_sortabs_uniq_inc([5, 5, 5]) == [6]\nassert op_sortabs_uniq_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_uniq_inc([10]) == [11]\nassert op_sortabs_uniq_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_uniq_inc([-7, 12, -7]) == [-6, 13]"}
{"id": "op_double_dropfirst_max", "entry_point": "op_double_dropfirst_max", "primitives": ["double", "dropfirst", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_double_dropfirst_max(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_double_dropfirst_max([1, 2, 3, 4]) == 8\nassert op_double_dropfirst_max([]) == 0\nassert op_double_dropfirst_max([-2, -1, 0, 1, 2]) == 4\nassert op_double_dropfirst_max([5, 5, 5]) == 10\nassert op_double_dropfirst_max([3, 1, 2]) == 4\nassert op_double_dropfirst_max([10]) == 0\nassert op_double_dropfirst_max([2, 4, 6]) == 12\nassert op_double_dropfirst_max([-7, 12, -7]) == 24"}
{"id": "op_inc_first3_min", "entry_point": "op_inc_first3_min", "primitives": ["inc", "first3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_inc_first3_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_inc_first3_min([1, 2, 3, 4]) == 2\nassert op_inc_first3_min([]) == 0\nassert op_inc_first3_min([-2, -1, 0, 1, 2]) == -1\nassert op_inc_first3_min([5, 5, 5]) == 6\nassert op_inc_first3_min([3, 1, 2]) == 2\nassert op_inc_first3_min([10]) == 11\nassert op_inc_first3_min([2, 4, 6]) == 3\nassert op_inc_first3_min([-7, 12, -7]) == -6"}
{"id": "op_dropfirst_beforezero_dropwhileneg", "entry_point": "op_dropfirst_beforezero_dropwhileneg", "primitives": ["dropfirst", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_dropfirst_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_beforezero_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_beforezero_dropwhileneg([]) == []\nassert op_dropfirst_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_beforezero_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_dropfirst_beforezero_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_dropfirst_beforezero_dropwhileneg([10]) == []\nassert op_dropfirst_beforezero_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_dropfirst_beforezero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropwhileneg_rev_neg", "entry_point": "op_dropwhileneg_rev_neg", "primitives": ["dropwhileneg", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then keep the negative numbers.", "solution": "def op_dropwhileneg_rev_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_rev_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_rev_neg([]) == []\nassert op_dropwhileneg_rev_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_rev_neg([5, 5, 5]) == []\nassert op_dropwhileneg_rev_neg([3, 1, 2]) == []\nassert op_dropwhileneg_rev_neg([10]) == []\nassert op_dropwhileneg_rev_neg([2, 4, 6]) == []\nassert op_dropwhileneg_rev_neg([-7, 12, -7]) == [-7]"}
{"id": "op_odds_evens_div3", "entry_point": "op_odds_evens_div3", "primitives": ["odds", "evens", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then keep multiples of three.", "solution": "def op_odds_evens_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_evens_div3([1, 2, 3, 4]) == []\nassert op_odds_evens_div3([]) == []\nassert op_odds_evens_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_div3([5, 5, 5]) == []\nassert op_odds_evens_div3([3, 1, 2]) == []\nassert op_odds_evens_div3([10]) == []\nassert op_odds_evens_div3([2, 4, 6]) == []\nassert op_odds_evens_div3([-7, 12, -7]) == []"}
{"id": "op_sortalpha_sortlen_counts", "entry_point": "op_sortalpha_sortlen_counts", "primitives": ["sortalpha", "sortlen", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then sort by length, shortest first, then return how many strings remain.", "solution": "def op_sortalpha_sortlen_counts(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=len)\n    return len(r)", "tests": "assert op_sortalpha_sortlen_counts(['Hello', 'world']) == 2\nassert op_sortalpha_sortlen_counts([]) == 0\nassert op_sortalpha_sortlen_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_sortlen_counts(['one', 'one', 'Two']) == 3\nassert op_sortalpha_sortlen_counts(['x']) == 1\nassert op_sortalpha_sortlen_counts(['abc', 'de', '']) == 3"}
{"id": "op_trimends_div3_neg", "entry_point": "op_trimends_div3_neg", "primitives": ["trimends", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep multiples of three, then keep the negative numbers.", "solution": "def op_trimends_div3_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_div3_neg([1, 2, 3, 4]) == []\nassert op_trimends_div3_neg([]) == []\nassert op_trimends_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_trimends_div3_neg([5, 5, 5]) == []\nassert op_trimends_div3_neg([3, 1, 2]) == []\nassert op_trimends_div3_neg([10]) == []\nassert op_trimends_div3_neg([2, 4, 6]) == []\nassert op_trimends_div3_neg([-7, 12, -7]) == []"}
{"id": "op_trimends_evens_double", "entry_point": "op_trimends_evens_double", "primitives": ["trimends", "evens", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then double each.", "solution": "def op_trimends_evens_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_evens_double([1, 2, 3, 4]) == [4]\nassert op_trimends_evens_double([]) == []\nassert op_trimends_evens_double([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_evens_double([5, 5, 5]) == []\nassert op_trimends_evens_double([3, 1, 2]) == []\nassert op_trimends_evens_double([10]) == []\nassert op_trimends_evens_double([2, 4, 6]) == [8]\nassert op_trimends_evens_double([-7, 12, -7]) == [24]"}
{"id": "op_rev_dropzeros_last3", "entry_point": "op_rev_dropzeros_last3", "primitives": ["rev", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then keep only the last three.", "solution": "def op_rev_dropzeros_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_rev_dropzeros_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dropzeros_last3([]) == []\nassert op_rev_dropzeros_last3([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_rev_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros_last3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropzeros_last3([10]) == [10]\nassert op_rev_dropzeros_last3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropzeros_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_oremptyzero_allpos", "entry_point": "op_beforezero_oremptyzero_allpos", "primitives": ["beforezero", "oremptyzero", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_beforezero_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_oremptyzero_allpos([]) == False\nassert op_beforezero_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_oremptyzero_allpos([5, 5, 5]) == True\nassert op_beforezero_oremptyzero_allpos([3, 1, 2]) == True\nassert op_beforezero_oremptyzero_allpos([10]) == True\nassert op_beforezero_oremptyzero_allpos([2, 4, 6]) == True\nassert op_beforezero_oremptyzero_allpos([-7, 12, -7]) == False"}
{"id": "op_pos_oremptyzero_inc", "entry_point": "op_pos_oremptyzero_inc", "primitives": ["pos", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then if empty, use a single zero, then add one to each.", "solution": "def op_pos_oremptyzero_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_pos_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_pos_oremptyzero_inc([]) == [1]\nassert op_pos_oremptyzero_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_pos_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_pos_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_pos_oremptyzero_inc([10]) == [11]\nassert op_pos_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_pos_oremptyzero_inc([-7, 12, -7]) == [13]"}
{"id": "op_sortabs_padto3_takewhilepos", "entry_point": "op_sortabs_padto3_takewhilepos", "primitives": ["sortabs", "padto3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_sortabs_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortabs_padto3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_padto3_takewhilepos([]) == []\nassert op_sortabs_padto3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_padto3_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_padto3_takewhilepos([10]) == [10]\nassert op_sortabs_padto3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_padto3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_last3_dropfirst_sum", "entry_point": "op_last3_dropfirst_sum", "primitives": ["last3", "dropfirst", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then return their sum.", "solution": "def op_last3_dropfirst_sum(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return sum(r)", "tests": "assert op_last3_dropfirst_sum([1, 2, 3, 4]) == 7\nassert op_last3_dropfirst_sum([]) == 0\nassert op_last3_dropfirst_sum([-2, -1, 0, 1, 2]) == 3\nassert op_last3_dropfirst_sum([5, 5, 5]) == 10\nassert op_last3_dropfirst_sum([3, 1, 2]) == 3\nassert op_last3_dropfirst_sum([10]) == 0\nassert op_last3_dropfirst_sum([2, 4, 6]) == 10\nassert op_last3_dropfirst_sum([-7, 12, -7]) == 5"}
{"id": "op_ages_takewhilepos_inc", "entry_point": "op_ages_takewhilepos_inc", "primitives": ["ages", "takewhilepos", "inc"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then add one to each.", "solution": "def op_ages_takewhilepos_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_takewhilepos_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [37, 13]\nassert op_ages_takewhilepos_inc([]) == []\nassert op_ages_takewhilepos_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [19, 66, 18]\nassert op_ages_takewhilepos_inc([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_lower_sortlen_lens", "entry_point": "op_lower_sortlen_lens", "primitives": ["lower", "sortlen", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort by length, shortest first, then return the total number of characters.", "solution": "def op_lower_sortlen_lens(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    return sum(len(s) for s in r)", "tests": "assert op_lower_sortlen_lens(['Hello', 'world']) == 10\nassert op_lower_sortlen_lens([]) == 0\nassert op_lower_sortlen_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_lower_sortlen_lens(['one', 'one', 'Two']) == 9\nassert op_lower_sortlen_lens(['x']) == 1\nassert op_lower_sortlen_lens(['abc', 'de', '']) == 5"}
{"id": "op_ages_sorta_max", "entry_point": "op_ages_sorta_max", "primitives": ["ages", "sorta", "max"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_ages_sorta_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_ages_sorta_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_sorta_max([]) == 0\nassert op_ages_sorta_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_sorta_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_last3_beforezero_div3", "entry_point": "op_last3_beforezero_div3", "primitives": ["last3", "beforezero", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_last3_beforezero_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_last3_beforezero_div3([]) == []\nassert op_last3_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_div3([5, 5, 5]) == []\nassert op_last3_beforezero_div3([3, 1, 2]) == [3]\nassert op_last3_beforezero_div3([10]) == []\nassert op_last3_beforezero_div3([2, 4, 6]) == [6]\nassert op_last3_beforezero_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_square_sum", "entry_point": "op_dropfirst_square_sum", "primitives": ["dropfirst", "square", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then return their sum.", "solution": "def op_dropfirst_square_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_dropfirst_square_sum([1, 2, 3, 4]) == 29\nassert op_dropfirst_square_sum([]) == 0\nassert op_dropfirst_square_sum([-2, -1, 0, 1, 2]) == 6\nassert op_dropfirst_square_sum([5, 5, 5]) == 50\nassert op_dropfirst_square_sum([3, 1, 2]) == 5\nassert op_dropfirst_square_sum([10]) == 0\nassert op_dropfirst_square_sum([2, 4, 6]) == 52\nassert op_dropfirst_square_sum([-7, 12, -7]) == 193"}
{"id": "op_rev_add10_uniq", "entry_point": "op_rev_add10_uniq", "primitives": ["rev", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_rev_add10_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_add10_uniq([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_rev_add10_uniq([]) == []\nassert op_rev_add10_uniq([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_rev_add10_uniq([5, 5, 5]) == [15]\nassert op_rev_add10_uniq([3, 1, 2]) == [12, 11, 13]\nassert op_rev_add10_uniq([10]) == [20]\nassert op_rev_add10_uniq([2, 4, 6]) == [16, 14, 12]\nassert op_rev_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_takewhilepos_square_clamp10", "entry_point": "op_takewhilepos_square_clamp10", "primitives": ["takewhilepos", "square", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then cap each value at 10.", "solution": "def op_takewhilepos_square_clamp10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_takewhilepos_square_clamp10([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_takewhilepos_square_clamp10([]) == []\nassert op_takewhilepos_square_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_square_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_square_clamp10([10]) == [10]\nassert op_takewhilepos_square_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_takewhilepos_square_clamp10([-7, 12, -7]) == []"}
{"id": "op_absval_negate_sortabs", "entry_point": "op_absval_negate_sortabs", "primitives": ["absval", "negate", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then sort by absolute value.", "solution": "def op_absval_negate_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_negate_sortabs([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_absval_negate_sortabs([]) == []\nassert op_absval_negate_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -1, -2, -2]\nassert op_absval_negate_sortabs([5, 5, 5]) == [-5, -5, -5]\nassert op_absval_negate_sortabs([3, 1, 2]) == [-1, -2, -3]\nassert op_absval_negate_sortabs([10]) == [-10]\nassert op_absval_negate_sortabs([2, 4, 6]) == [-2, -4, -6]\nassert op_absval_negate_sortabs([-7, 12, -7]) == [-7, -7, -12]"}
{"id": "op_inc_rev_trimends", "entry_point": "op_inc_rev_trimends", "primitives": ["inc", "rev", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then drop the first and last elements.", "solution": "def op_inc_rev_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_rev_trimends([1, 2, 3, 4]) == [4, 3]\nassert op_inc_rev_trimends([]) == []\nassert op_inc_rev_trimends([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_inc_rev_trimends([5, 5, 5]) == [6]\nassert op_inc_rev_trimends([3, 1, 2]) == [2]\nassert op_inc_rev_trimends([10]) == []\nassert op_inc_rev_trimends([2, 4, 6]) == [5]\nassert op_inc_rev_trimends([-7, 12, -7]) == [13]"}
{"id": "op_padto3_evens_square", "entry_point": "op_padto3_evens_square", "primitives": ["padto3", "evens", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then square each.", "solution": "def op_padto3_evens_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_padto3_evens_square([]) == [0, 0, 0]\nassert op_padto3_evens_square([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_padto3_evens_square([5, 5, 5]) == []\nassert op_padto3_evens_square([3, 1, 2]) == [4]\nassert op_padto3_evens_square([10]) == [100, 0, 0]\nassert op_padto3_evens_square([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_neg_trimends_last3", "entry_point": "op_neg_trimends_last3", "primitives": ["neg", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then keep only the last three.", "solution": "def op_neg_trimends_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_neg_trimends_last3([1, 2, 3, 4]) == []\nassert op_neg_trimends_last3([]) == []\nassert op_neg_trimends_last3([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_last3([5, 5, 5]) == []\nassert op_neg_trimends_last3([3, 1, 2]) == []\nassert op_neg_trimends_last3([10]) == []\nassert op_neg_trimends_last3([2, 4, 6]) == []\nassert op_neg_trimends_last3([-7, 12, -7]) == []"}
{"id": "op_last3_neg_dropwhileneg", "entry_point": "op_last3_neg_dropwhileneg", "primitives": ["last3", "neg", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then drop the leading negative values.", "solution": "def op_last3_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_last3_neg_dropwhileneg([]) == []\nassert op_last3_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_dropwhileneg([5, 5, 5]) == []\nassert op_last3_neg_dropwhileneg([3, 1, 2]) == []\nassert op_last3_neg_dropwhileneg([10]) == []\nassert op_last3_neg_dropwhileneg([2, 4, 6]) == []\nassert op_last3_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_sorta_clamp10_firsteven", "entry_point": "op_sorta_clamp10_firsteven", "primitives": ["sorta", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_sorta_clamp10_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_clamp10_firsteven([]) == 0\nassert op_sorta_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_clamp10_firsteven([5, 5, 5]) == 0\nassert op_sorta_clamp10_firsteven([3, 1, 2]) == 2\nassert op_sorta_clamp10_firsteven([10]) == 10\nassert op_sorta_clamp10_firsteven([2, 4, 6]) == 2\nassert op_sorta_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_trimends_square_sorta", "entry_point": "op_trimends_square_sorta", "primitives": ["trimends", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then sort ascending.", "solution": "def op_trimends_square_sorta(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_trimends_square_sorta([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_square_sorta([]) == []\nassert op_trimends_square_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1]\nassert op_trimends_square_sorta([5, 5, 5]) == [25]\nassert op_trimends_square_sorta([3, 1, 2]) == [1]\nassert op_trimends_square_sorta([10]) == []\nassert op_trimends_square_sorta([2, 4, 6]) == [16]\nassert op_trimends_square_sorta([-7, 12, -7]) == [144]"}
{"id": "op_double_negate_trimends", "entry_point": "op_double_negate_trimends", "primitives": ["double", "negate", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then drop the first and last elements.", "solution": "def op_double_negate_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_negate_trimends([1, 2, 3, 4]) == [-4, -6]\nassert op_double_negate_trimends([]) == []\nassert op_double_negate_trimends([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_double_negate_trimends([5, 5, 5]) == [-10]\nassert op_double_negate_trimends([3, 1, 2]) == [-2]\nassert op_double_negate_trimends([10]) == []\nassert op_double_negate_trimends([2, 4, 6]) == [-8]\nassert op_double_negate_trimends([-7, 12, -7]) == [-24]"}
{"id": "op_ages_takewhilepos_square", "entry_point": "op_ages_takewhilepos_square", "primitives": ["ages", "takewhilepos", "square"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then square each.", "solution": "def op_ages_takewhilepos_square(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_ages_takewhilepos_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1296, 144]\nassert op_ages_takewhilepos_square([]) == []\nassert op_ages_takewhilepos_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [324, 4225, 289]\nassert op_ages_takewhilepos_square([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_clamp10_dropwhileneg_sortd", "entry_point": "op_clamp10_dropwhileneg_sortd", "primitives": ["clamp10", "dropwhileneg", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then sort descending.", "solution": "def op_clamp10_dropwhileneg_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_dropwhileneg_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_dropwhileneg_sortd([]) == []\nassert op_clamp10_dropwhileneg_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_clamp10_dropwhileneg_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_dropwhileneg_sortd([10]) == [10]\nassert op_clamp10_dropwhileneg_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_dropwhileneg_sortd([-7, 12, -7]) == [10, -7]"}
{"id": "op_absval_clamp10_haszero", "entry_point": "op_absval_clamp10_haszero", "primitives": ["absval", "clamp10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then return whether the list contains a zero.", "solution": "def op_absval_clamp10_haszero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_absval_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_absval_clamp10_haszero([]) == False\nassert op_absval_clamp10_haszero([-2, -1, 0, 1, 2]) == True\nassert op_absval_clamp10_haszero([5, 5, 5]) == False\nassert op_absval_clamp10_haszero([3, 1, 2]) == False\nassert op_absval_clamp10_haszero([10]) == False\nassert op_absval_clamp10_haszero([2, 4, 6]) == False\nassert op_absval_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_inc_clamp10", "entry_point": "op_dropwhileneg_inc_clamp10", "primitives": ["dropwhileneg", "inc", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then cap each value at 10.", "solution": "def op_dropwhileneg_inc_clamp10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropwhileneg_inc_clamp10([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropwhileneg_inc_clamp10([]) == []\nassert op_dropwhileneg_inc_clamp10([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_inc_clamp10([5, 5, 5]) == [6, 6, 6]\nassert op_dropwhileneg_inc_clamp10([3, 1, 2]) == [4, 2, 3]\nassert op_dropwhileneg_inc_clamp10([10]) == [10]\nassert op_dropwhileneg_inc_clamp10([2, 4, 6]) == [3, 5, 7]\nassert op_dropwhileneg_inc_clamp10([-7, 12, -7]) == [10, -6]"}
{"id": "op_neg_dropzeros_gt5", "entry_point": "op_neg_dropzeros_gt5", "primitives": ["neg", "dropzeros", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then keep values greater than five.", "solution": "def op_neg_dropzeros_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_neg_dropzeros_gt5([]) == []\nassert op_neg_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropzeros_gt5([5, 5, 5]) == []\nassert op_neg_dropzeros_gt5([3, 1, 2]) == []\nassert op_neg_dropzeros_gt5([10]) == []\nassert op_neg_dropzeros_gt5([2, 4, 6]) == []\nassert op_neg_dropzeros_gt5([-7, 12, -7]) == []"}
{"id": "op_sortabs_clamp10_first3", "entry_point": "op_sortabs_clamp10_first3", "primitives": ["sortabs", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then keep only the first three.", "solution": "def op_sortabs_clamp10_first3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_sortabs_clamp10_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_clamp10_first3([]) == []\nassert op_sortabs_clamp10_first3([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_sortabs_clamp10_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_clamp10_first3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_clamp10_first3([10]) == [10]\nassert op_sortabs_clamp10_first3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_clamp10_first3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_dropfirst_clamp10_div3", "entry_point": "op_dropfirst_clamp10_div3", "primitives": ["dropfirst", "clamp10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then keep multiples of three.", "solution": "def op_dropfirst_clamp10_div3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropfirst_clamp10_div3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_clamp10_div3([]) == []\nassert op_dropfirst_clamp10_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropfirst_clamp10_div3([5, 5, 5]) == []\nassert op_dropfirst_clamp10_div3([3, 1, 2]) == []\nassert op_dropfirst_clamp10_div3([10]) == []\nassert op_dropfirst_clamp10_div3([2, 4, 6]) == [6]\nassert op_dropfirst_clamp10_div3([-7, 12, -7]) == []"}
{"id": "op_clamp10_neg_negate", "entry_point": "op_clamp10_neg_negate", "primitives": ["clamp10", "neg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then negate each.", "solution": "def op_clamp10_neg_negate(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_clamp10_neg_negate([1, 2, 3, 4]) == []\nassert op_clamp10_neg_negate([]) == []\nassert op_clamp10_neg_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_neg_negate([5, 5, 5]) == []\nassert op_clamp10_neg_negate([3, 1, 2]) == []\nassert op_clamp10_neg_negate([10]) == []\nassert op_clamp10_neg_negate([2, 4, 6]) == []\nassert op_clamp10_neg_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_first3_sortabs_sum", "entry_point": "op_first3_sortabs_sum", "primitives": ["first3", "sortabs", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then return their sum.", "solution": "def op_first3_sortabs_sum(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return sum(r)", "tests": "assert op_first3_sortabs_sum([1, 2, 3, 4]) == 6\nassert op_first3_sortabs_sum([]) == 0\nassert op_first3_sortabs_sum([-2, -1, 0, 1, 2]) == -3\nassert op_first3_sortabs_sum([5, 5, 5]) == 15\nassert op_first3_sortabs_sum([3, 1, 2]) == 6\nassert op_first3_sortabs_sum([10]) == 10\nassert op_first3_sortabs_sum([2, 4, 6]) == 12\nassert op_first3_sortabs_sum([-7, 12, -7]) == -2"}
{"id": "op_dropzeros_trimends_beforezero", "entry_point": "op_dropzeros_trimends_beforezero", "primitives": ["dropzeros", "trimends", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_dropzeros_trimends_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_trimends_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_dropzeros_trimends_beforezero([]) == []\nassert op_dropzeros_trimends_beforezero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_trimends_beforezero([5, 5, 5]) == [5]\nassert op_dropzeros_trimends_beforezero([3, 1, 2]) == [1]\nassert op_dropzeros_trimends_beforezero([10]) == []\nassert op_dropzeros_trimends_beforezero([2, 4, 6]) == [4]\nassert op_dropzeros_trimends_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_div3_rev_uniq", "entry_point": "op_div3_rev_uniq", "primitives": ["div3", "rev", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then drop duplicates keeping first occurrence.", "solution": "def op_div3_rev_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_rev_uniq([1, 2, 3, 4]) == [3]\nassert op_div3_rev_uniq([]) == []\nassert op_div3_rev_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev_uniq([5, 5, 5]) == []\nassert op_div3_rev_uniq([3, 1, 2]) == [3]\nassert op_div3_rev_uniq([10]) == []\nassert op_div3_rev_uniq([2, 4, 6]) == [6]\nassert op_div3_rev_uniq([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_add10_rev", "entry_point": "op_clamp10_add10_rev", "primitives": ["clamp10", "add10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then reverse the order.", "solution": "def op_clamp10_add10_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_add10_rev([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_clamp10_add10_rev([]) == []\nassert op_clamp10_add10_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_clamp10_add10_rev([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_add10_rev([3, 1, 2]) == [12, 11, 13]\nassert op_clamp10_add10_rev([10]) == [20]\nassert op_clamp10_add10_rev([2, 4, 6]) == [16, 14, 12]\nassert op_clamp10_add10_rev([-7, 12, -7]) == [3, 20, 3]"}
{"id": "op_first3_sortd_prod", "entry_point": "op_first3_sortd_prod", "primitives": ["first3", "sortd", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then return their product.", "solution": "def op_first3_sortd_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return __import__('math').prod(r)", "tests": "assert op_first3_sortd_prod([1, 2, 3, 4]) == 6\nassert op_first3_sortd_prod([]) == 1\nassert op_first3_sortd_prod([-2, -1, 0, 1, 2]) == 0\nassert op_first3_sortd_prod([5, 5, 5]) == 125\nassert op_first3_sortd_prod([3, 1, 2]) == 6\nassert op_first3_sortd_prod([10]) == 10\nassert op_first3_sortd_prod([2, 4, 6]) == 48\nassert op_first3_sortd_prod([-7, 12, -7]) == 588"}
{"id": "op_dropwhileneg_rev_sum", "entry_point": "op_dropwhileneg_rev_sum", "primitives": ["dropwhileneg", "rev", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then return their sum.", "solution": "def op_dropwhileneg_rev_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return sum(r)", "tests": "assert op_dropwhileneg_rev_sum([1, 2, 3, 4]) == 10\nassert op_dropwhileneg_rev_sum([]) == 0\nassert op_dropwhileneg_rev_sum([-2, -1, 0, 1, 2]) == 3\nassert op_dropwhileneg_rev_sum([5, 5, 5]) == 15\nassert op_dropwhileneg_rev_sum([3, 1, 2]) == 6\nassert op_dropwhileneg_rev_sum([10]) == 10\nassert op_dropwhileneg_rev_sum([2, 4, 6]) == 12\nassert op_dropwhileneg_rev_sum([-7, 12, -7]) == 5"}
{"id": "op_oremptyzero_last3_dropfirst", "entry_point": "op_oremptyzero_last3_dropfirst", "primitives": ["oremptyzero", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then drop the first element.", "solution": "def op_oremptyzero_last3_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_last3_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_oremptyzero_last3_dropfirst([]) == []\nassert op_oremptyzero_last3_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_oremptyzero_last3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_last3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_oremptyzero_last3_dropfirst([10]) == []\nassert op_oremptyzero_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_oremptyzero_last3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_dec_uniq_allpos", "entry_point": "op_dec_uniq_allpos", "primitives": ["dec", "uniq", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_dec_uniq_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_dec_uniq_allpos([1, 2, 3, 4]) == False\nassert op_dec_uniq_allpos([]) == True\nassert op_dec_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_uniq_allpos([5, 5, 5]) == True\nassert op_dec_uniq_allpos([3, 1, 2]) == False\nassert op_dec_uniq_allpos([10]) == True\nassert op_dec_uniq_allpos([2, 4, 6]) == True\nassert op_dec_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_absval_padto3_prod", "entry_point": "op_absval_padto3_prod", "primitives": ["absval", "padto3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then return their product.", "solution": "def op_absval_padto3_prod(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_absval_padto3_prod([1, 2, 3, 4]) == 24\nassert op_absval_padto3_prod([]) == 0\nassert op_absval_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_absval_padto3_prod([5, 5, 5]) == 125\nassert op_absval_padto3_prod([3, 1, 2]) == 6\nassert op_absval_padto3_prod([10]) == 0\nassert op_absval_padto3_prod([2, 4, 6]) == 48\nassert op_absval_padto3_prod([-7, 12, -7]) == 588"}
{"id": "op_last3_rev_padto3", "entry_point": "op_last3_rev_padto3", "primitives": ["last3", "rev", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then pad with zeros to at least three elements.", "solution": "def op_last3_rev_padto3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_last3_rev_padto3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_rev_padto3([]) == [0, 0, 0]\nassert op_last3_rev_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_rev_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_rev_padto3([3, 1, 2]) == [2, 1, 3]\nassert op_last3_rev_padto3([10]) == [10, 0, 0]\nassert op_last3_rev_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_last3_rev_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_neg_trimends_gt5", "entry_point": "op_neg_trimends_gt5", "primitives": ["neg", "trimends", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then keep values greater than five.", "solution": "def op_neg_trimends_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_trimends_gt5([1, 2, 3, 4]) == []\nassert op_neg_trimends_gt5([]) == []\nassert op_neg_trimends_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_gt5([5, 5, 5]) == []\nassert op_neg_trimends_gt5([3, 1, 2]) == []\nassert op_neg_trimends_gt5([10]) == []\nassert op_neg_trimends_gt5([2, 4, 6]) == []\nassert op_neg_trimends_gt5([-7, 12, -7]) == []"}
{"id": "op_dropzeros_takewhilepos_square", "entry_point": "op_dropzeros_takewhilepos_square", "primitives": ["dropzeros", "takewhilepos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then square each.", "solution": "def op_dropzeros_takewhilepos_square(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropzeros_takewhilepos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropzeros_takewhilepos_square([]) == []\nassert op_dropzeros_takewhilepos_square([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_takewhilepos_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropzeros_takewhilepos_square([10]) == [100]\nassert op_dropzeros_takewhilepos_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_takewhilepos_square([-7, 12, -7]) == []"}
{"id": "op_first3_padto3_add10", "entry_point": "op_first3_padto3_add10", "primitives": ["first3", "padto3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then add ten to each.", "solution": "def op_first3_padto3_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_padto3_add10([1, 2, 3, 4]) == [11, 12, 13]\nassert op_first3_padto3_add10([]) == [10, 10, 10]\nassert op_first3_padto3_add10([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_first3_padto3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_first3_padto3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_first3_padto3_add10([10]) == [20, 10, 10]\nassert op_first3_padto3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_first3_padto3_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_odds_oremptyzero_max", "entry_point": "op_odds_oremptyzero_max", "primitives": ["odds", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_odds_oremptyzero_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_odds_oremptyzero_max([1, 2, 3, 4]) == 3\nassert op_odds_oremptyzero_max([]) == 0\nassert op_odds_oremptyzero_max([-2, -1, 0, 1, 2]) == 1\nassert op_odds_oremptyzero_max([5, 5, 5]) == 5\nassert op_odds_oremptyzero_max([3, 1, 2]) == 3\nassert op_odds_oremptyzero_max([10]) == 0\nassert op_odds_oremptyzero_max([2, 4, 6]) == 0\nassert op_odds_oremptyzero_max([-7, 12, -7]) == -7"}
{"id": "op_takewhilepos_sortabs_oremptyzero", "entry_point": "op_takewhilepos_sortabs_oremptyzero", "primitives": ["takewhilepos", "sortabs", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_takewhilepos_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_takewhilepos_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_sortabs_oremptyzero([]) == [0]\nassert op_takewhilepos_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_sortabs_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_sortabs_oremptyzero([10]) == [10]\nassert op_takewhilepos_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_sortabs_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_inc_add10_firsteven", "entry_point": "op_inc_add10_firsteven", "primitives": ["inc", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return the first even value (0 if none).", "solution": "def op_inc_add10_firsteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_inc_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_inc_add10_firsteven([]) == 0\nassert op_inc_add10_firsteven([-2, -1, 0, 1, 2]) == 10\nassert op_inc_add10_firsteven([5, 5, 5]) == 16\nassert op_inc_add10_firsteven([3, 1, 2]) == 14\nassert op_inc_add10_firsteven([10]) == 0\nassert op_inc_add10_firsteven([2, 4, 6]) == 0\nassert op_inc_add10_firsteven([-7, 12, -7]) == 4"}
{"id": "op_last3_sortd_rev", "entry_point": "op_last3_sortd_rev", "primitives": ["last3", "sortd", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then reverse the order.", "solution": "def op_last3_sortd_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_sortd_rev([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortd_rev([]) == []\nassert op_last3_sortd_rev([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sortd_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortd_rev([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortd_rev([10]) == [10]\nassert op_last3_sortd_rev([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortd_rev([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_padto3_last3_odds", "entry_point": "op_padto3_last3_odds", "primitives": ["padto3", "last3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then keep the odd numbers.", "solution": "def op_padto3_last3_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_last3_odds([1, 2, 3, 4]) == [3]\nassert op_padto3_last3_odds([]) == []\nassert op_padto3_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_padto3_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_last3_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_last3_odds([10]) == []\nassert op_padto3_last3_odds([2, 4, 6]) == []\nassert op_padto3_last3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_oremptyzero_dropzeros_len", "entry_point": "op_oremptyzero_dropzeros_len", "primitives": ["oremptyzero", "dropzeros", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then return how many remain.", "solution": "def op_oremptyzero_dropzeros_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_oremptyzero_dropzeros_len([1, 2, 3, 4]) == 4\nassert op_oremptyzero_dropzeros_len([]) == 0\nassert op_oremptyzero_dropzeros_len([-2, -1, 0, 1, 2]) == 4\nassert op_oremptyzero_dropzeros_len([5, 5, 5]) == 3\nassert op_oremptyzero_dropzeros_len([3, 1, 2]) == 3\nassert op_oremptyzero_dropzeros_len([10]) == 1\nassert op_oremptyzero_dropzeros_len([2, 4, 6]) == 3\nassert op_oremptyzero_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_negate_sortabs_clamp10", "entry_point": "op_negate_sortabs_clamp10", "primitives": ["negate", "sortabs", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort by absolute value, then cap each value at 10.", "solution": "def op_negate_sortabs_clamp10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_negate_sortabs_clamp10([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_sortabs_clamp10([]) == []\nassert op_negate_sortabs_clamp10([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_negate_sortabs_clamp10([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sortabs_clamp10([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sortabs_clamp10([10]) == [-10]\nassert op_negate_sortabs_clamp10([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sortabs_clamp10([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_dropwhileneg_inc_trimends", "entry_point": "op_dropwhileneg_inc_trimends", "primitives": ["dropwhileneg", "inc", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then drop the first and last elements.", "solution": "def op_dropwhileneg_inc_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_inc_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_dropwhileneg_inc_trimends([]) == []\nassert op_dropwhileneg_inc_trimends([-2, -1, 0, 1, 2]) == [2]\nassert op_dropwhileneg_inc_trimends([5, 5, 5]) == [6]\nassert op_dropwhileneg_inc_trimends([3, 1, 2]) == [2]\nassert op_dropwhileneg_inc_trimends([10]) == []\nassert op_dropwhileneg_inc_trimends([2, 4, 6]) == [5]\nassert op_dropwhileneg_inc_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_padto3_evens", "entry_point": "op_add10_padto3_evens", "primitives": ["add10", "padto3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then pad with zeros to at least three elements, then keep the even numbers.", "solution": "def op_add10_padto3_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_padto3_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_padto3_evens([]) == [0, 0, 0]\nassert op_add10_padto3_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_padto3_evens([5, 5, 5]) == []\nassert op_add10_padto3_evens([3, 1, 2]) == [12]\nassert op_add10_padto3_evens([10]) == [20, 0, 0]\nassert op_add10_padto3_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_padto3_evens([-7, 12, -7]) == [22]"}
{"id": "op_inc_takewhilepos_odds", "entry_point": "op_inc_takewhilepos_odds", "primitives": ["inc", "takewhilepos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive, then keep the odd numbers.", "solution": "def op_inc_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_takewhilepos_odds([1, 2, 3, 4]) == [3, 5]\nassert op_inc_takewhilepos_odds([]) == []\nassert op_inc_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_inc_takewhilepos_odds([5, 5, 5]) == []\nassert op_inc_takewhilepos_odds([3, 1, 2]) == [3]\nassert op_inc_takewhilepos_odds([10]) == [11]\nassert op_inc_takewhilepos_odds([2, 4, 6]) == [3, 5, 7]\nassert op_inc_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_inc_dec_sorta", "entry_point": "op_inc_dec_sorta", "primitives": ["inc", "dec", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then sort ascending.", "solution": "def op_inc_dec_sorta(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_inc_dec_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_dec_sorta([]) == []\nassert op_inc_dec_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_dec_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_inc_dec_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_inc_dec_sorta([10]) == [10]\nassert op_inc_dec_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_inc_dec_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_inc_firsteven", "entry_point": "op_pos_inc_firsteven", "primitives": ["pos", "inc", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then return the first even value (0 if none).", "solution": "def op_pos_inc_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_inc_firsteven([1, 2, 3, 4]) == 2\nassert op_pos_inc_firsteven([]) == 0\nassert op_pos_inc_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_pos_inc_firsteven([5, 5, 5]) == 6\nassert op_pos_inc_firsteven([3, 1, 2]) == 4\nassert op_pos_inc_firsteven([10]) == 0\nassert op_pos_inc_firsteven([2, 4, 6]) == 0\nassert op_pos_inc_firsteven([-7, 12, -7]) == 0"}
{"id": "op_inc_first3_sortd", "entry_point": "op_inc_first3_sortd", "primitives": ["inc", "first3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then sort descending.", "solution": "def op_inc_first3_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_first3_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_inc_first3_sortd([]) == []\nassert op_inc_first3_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_inc_first3_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_inc_first3_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_inc_first3_sortd([10]) == [11]\nassert op_inc_first3_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_inc_first3_sortd([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_dropfirst_first3_square", "entry_point": "op_dropfirst_first3_square", "primitives": ["dropfirst", "first3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then square each.", "solution": "def op_dropfirst_first3_square(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropfirst_first3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropfirst_first3_square([]) == []\nassert op_dropfirst_first3_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_dropfirst_first3_square([5, 5, 5]) == [25, 25]\nassert op_dropfirst_first3_square([3, 1, 2]) == [1, 4]\nassert op_dropfirst_first3_square([10]) == []\nassert op_dropfirst_first3_square([2, 4, 6]) == [16, 36]\nassert op_dropfirst_first3_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_double_square_dropfirst", "entry_point": "op_double_square_dropfirst", "primitives": ["double", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then drop the first element.", "solution": "def op_double_square_dropfirst(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_double_square_dropfirst([1, 2, 3, 4]) == [16, 36, 64]\nassert op_double_square_dropfirst([]) == []\nassert op_double_square_dropfirst([-2, -1, 0, 1, 2]) == [4, 0, 4, 16]\nassert op_double_square_dropfirst([5, 5, 5]) == [100, 100]\nassert op_double_square_dropfirst([3, 1, 2]) == [4, 16]\nassert op_double_square_dropfirst([10]) == []\nassert op_double_square_dropfirst([2, 4, 6]) == [64, 144]\nassert op_double_square_dropfirst([-7, 12, -7]) == [576, 196]"}
{"id": "op_first3_clamp10_max", "entry_point": "op_first3_clamp10_max", "primitives": ["first3", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_first3_clamp10_max(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_first3_clamp10_max([1, 2, 3, 4]) == 3\nassert op_first3_clamp10_max([]) == 0\nassert op_first3_clamp10_max([-2, -1, 0, 1, 2]) == 0\nassert op_first3_clamp10_max([5, 5, 5]) == 5\nassert op_first3_clamp10_max([3, 1, 2]) == 3\nassert op_first3_clamp10_max([10]) == 10\nassert op_first3_clamp10_max([2, 4, 6]) == 6\nassert op_first3_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_uniq_add10_negate", "entry_point": "op_uniq_add10_negate", "primitives": ["uniq", "add10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then negate each.", "solution": "def op_uniq_add10_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_add10_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_uniq_add10_negate([]) == []\nassert op_uniq_add10_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_uniq_add10_negate([5, 5, 5]) == [-15]\nassert op_uniq_add10_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_uniq_add10_negate([10]) == [-20]\nassert op_uniq_add10_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_uniq_add10_negate([-7, 12, -7]) == [-3, -22]"}
{"id": "op_add10_gt5_counteven", "entry_point": "op_add10_gt5_counteven", "primitives": ["add10", "gt5", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then return how many values are even.", "solution": "def op_add10_gt5_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_gt5_counteven([1, 2, 3, 4]) == 2\nassert op_add10_gt5_counteven([]) == 0\nassert op_add10_gt5_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_gt5_counteven([5, 5, 5]) == 0\nassert op_add10_gt5_counteven([3, 1, 2]) == 1\nassert op_add10_gt5_counteven([10]) == 1\nassert op_add10_gt5_counteven([2, 4, 6]) == 3\nassert op_add10_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_negate_last3_padto3", "entry_point": "op_negate_last3_padto3", "primitives": ["negate", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_negate_last3_padto3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_negate_last3_padto3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_last3_padto3([]) == [0, 0, 0]\nassert op_negate_last3_padto3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_negate_last3_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_last3_padto3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_last3_padto3([10]) == [-10, 0, 0]\nassert op_negate_last3_padto3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_last3_padto3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_beforezero_dropzeros_square", "entry_point": "op_beforezero_dropzeros_square", "primitives": ["beforezero", "dropzeros", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then square each.", "solution": "def op_beforezero_dropzeros_square(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_beforezero_dropzeros_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_beforezero_dropzeros_square([]) == []\nassert op_beforezero_dropzeros_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_beforezero_dropzeros_square([5, 5, 5]) == [25, 25, 25]\nassert op_beforezero_dropzeros_square([3, 1, 2]) == [9, 1, 4]\nassert op_beforezero_dropzeros_square([10]) == [100]\nassert op_beforezero_dropzeros_square([2, 4, 6]) == [4, 16, 36]\nassert op_beforezero_dropzeros_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sorta_beforezero_rev", "entry_point": "op_sorta_beforezero_rev", "primitives": ["sorta", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then reverse the order.", "solution": "def op_sorta_beforezero_rev(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_sorta_beforezero_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_beforezero_rev([]) == []\nassert op_sorta_beforezero_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sorta_beforezero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_beforezero_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_beforezero_rev([10]) == [10]\nassert op_sorta_beforezero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_beforezero_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_inc_first3_counteven", "entry_point": "op_inc_first3_counteven", "primitives": ["inc", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then return how many values are even.", "solution": "def op_inc_first3_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_first3_counteven([1, 2, 3, 4]) == 2\nassert op_inc_first3_counteven([]) == 0\nassert op_inc_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_inc_first3_counteven([5, 5, 5]) == 3\nassert op_inc_first3_counteven([3, 1, 2]) == 2\nassert op_inc_first3_counteven([10]) == 0\nassert op_inc_first3_counteven([2, 4, 6]) == 0\nassert op_inc_first3_counteven([-7, 12, -7]) == 2"}
{"id": "op_sortd_oremptyzero_sum", "entry_point": "op_sortd_oremptyzero_sum", "primitives": ["sortd", "oremptyzero", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then return their sum.", "solution": "def op_sortd_oremptyzero_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_sortd_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_sortd_oremptyzero_sum([]) == 0\nassert op_sortd_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_oremptyzero_sum([5, 5, 5]) == 15\nassert op_sortd_oremptyzero_sum([3, 1, 2]) == 6\nassert op_sortd_oremptyzero_sum([10]) == 10\nassert op_sortd_oremptyzero_sum([2, 4, 6]) == 12\nassert op_sortd_oremptyzero_sum([-7, 12, -7]) == -2"}
{"id": "op_pos_dropwhileneg_add10", "entry_point": "op_pos_dropwhileneg_add10", "primitives": ["pos", "dropwhileneg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then add ten to each.", "solution": "def op_pos_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_dropwhileneg_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_dropwhileneg_add10([]) == []\nassert op_pos_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_dropwhileneg_add10([5, 5, 5]) == [15, 15, 15]\nassert op_pos_dropwhileneg_add10([3, 1, 2]) == [13, 11, 12]\nassert op_pos_dropwhileneg_add10([10]) == [20]\nassert op_pos_dropwhileneg_add10([2, 4, 6]) == [12, 14, 16]\nassert op_pos_dropwhileneg_add10([-7, 12, -7]) == [22]"}
{"id": "op_evens_oremptyzero_dropzeros", "entry_point": "op_evens_oremptyzero_dropzeros", "primitives": ["evens", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then drop the zeros.", "solution": "def op_evens_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_evens_oremptyzero_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_evens_oremptyzero_dropzeros([]) == []\nassert op_evens_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_evens_oremptyzero_dropzeros([5, 5, 5]) == []\nassert op_evens_oremptyzero_dropzeros([3, 1, 2]) == [2]\nassert op_evens_oremptyzero_dropzeros([10]) == [10]\nassert op_evens_oremptyzero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_evens_oremptyzero_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_last3_add10", "entry_point": "op_takewhilepos_last3_add10", "primitives": ["takewhilepos", "last3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then add ten to each.", "solution": "def op_takewhilepos_last3_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_last3_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_takewhilepos_last3_add10([]) == []\nassert op_takewhilepos_last3_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_last3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_takewhilepos_last3_add10([10]) == [20]\nassert op_takewhilepos_last3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_takewhilepos_last3_add10([-7, 12, -7]) == []"}
{"id": "op_add10_sorta_padto3", "entry_point": "op_add10_sorta_padto3", "primitives": ["add10", "sorta", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then pad with zeros to at least three elements.", "solution": "def op_add10_sorta_padto3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_add10_sorta_padto3([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_sorta_padto3([]) == [0, 0, 0]\nassert op_add10_sorta_padto3([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_sorta_padto3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sorta_padto3([3, 1, 2]) == [11, 12, 13]\nassert op_add10_sorta_padto3([10]) == [20, 0, 0]\nassert op_add10_sorta_padto3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sorta_padto3([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_sorta_add10_uniq", "entry_point": "op_sorta_add10_uniq", "primitives": ["sorta", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_sorta_add10_uniq(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sorta_add10_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sorta_add10_uniq([]) == []\nassert op_sorta_add10_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_sorta_add10_uniq([5, 5, 5]) == [15]\nassert op_sorta_add10_uniq([3, 1, 2]) == [11, 12, 13]\nassert op_sorta_add10_uniq([10]) == [20]\nassert op_sorta_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_sorta_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_gt5_takewhilepos_sortabs", "entry_point": "op_gt5_takewhilepos_sortabs", "primitives": ["gt5", "takewhilepos", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then sort by absolute value.", "solution": "def op_gt5_takewhilepos_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_takewhilepos_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos_sortabs([]) == []\nassert op_gt5_takewhilepos_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos_sortabs([5, 5, 5]) == []\nassert op_gt5_takewhilepos_sortabs([3, 1, 2]) == []\nassert op_gt5_takewhilepos_sortabs([10]) == [10]\nassert op_gt5_takewhilepos_sortabs([2, 4, 6]) == [6]\nassert op_gt5_takewhilepos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_sortd_clamp10_len", "entry_point": "op_sortd_clamp10_len", "primitives": ["sortd", "clamp10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10, then return how many remain.", "solution": "def op_sortd_clamp10_len(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_sortd_clamp10_len([1, 2, 3, 4]) == 4\nassert op_sortd_clamp10_len([]) == 0\nassert op_sortd_clamp10_len([-2, -1, 0, 1, 2]) == 5\nassert op_sortd_clamp10_len([5, 5, 5]) == 3\nassert op_sortd_clamp10_len([3, 1, 2]) == 3\nassert op_sortd_clamp10_len([10]) == 1\nassert op_sortd_clamp10_len([2, 4, 6]) == 3\nassert op_sortd_clamp10_len([-7, 12, -7]) == 3"}
{"id": "op_takewhilepos_inc_firsteven", "entry_point": "op_takewhilepos_inc_firsteven", "primitives": ["takewhilepos", "inc", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then return the first even value (0 if none).", "solution": "def op_takewhilepos_inc_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_inc_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_inc_firsteven([]) == 0\nassert op_takewhilepos_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_inc_firsteven([5, 5, 5]) == 6\nassert op_takewhilepos_inc_firsteven([3, 1, 2]) == 4\nassert op_takewhilepos_inc_firsteven([10]) == 0\nassert op_takewhilepos_inc_firsteven([2, 4, 6]) == 0\nassert op_takewhilepos_inc_firsteven([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_dropwhileneg_rev", "entry_point": "op_oremptyzero_dropwhileneg_rev", "primitives": ["oremptyzero", "dropwhileneg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then reverse the order.", "solution": "def op_oremptyzero_dropwhileneg_rev(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_oremptyzero_dropwhileneg_rev([]) == [0]\nassert op_oremptyzero_dropwhileneg_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_oremptyzero_dropwhileneg_rev([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropwhileneg_rev([3, 1, 2]) == [2, 1, 3]\nassert op_oremptyzero_dropwhileneg_rev([10]) == [10]\nassert op_oremptyzero_dropwhileneg_rev([2, 4, 6]) == [6, 4, 2]\nassert op_oremptyzero_dropwhileneg_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_last3_dropzeros_rev", "entry_point": "op_last3_dropzeros_rev", "primitives": ["last3", "dropzeros", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then reverse the order.", "solution": "def op_last3_dropzeros_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_dropzeros_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_dropzeros_rev([]) == []\nassert op_last3_dropzeros_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_last3_dropzeros_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropzeros_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_dropzeros_rev([10]) == [10]\nassert op_last3_dropzeros_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_dropzeros_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_trimends_first3_add10", "entry_point": "op_trimends_first3_add10", "primitives": ["trimends", "first3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then add ten to each.", "solution": "def op_trimends_first3_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_first3_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_first3_add10([]) == []\nassert op_trimends_first3_add10([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_first3_add10([5, 5, 5]) == [15]\nassert op_trimends_first3_add10([3, 1, 2]) == [11]\nassert op_trimends_first3_add10([10]) == []\nassert op_trimends_first3_add10([2, 4, 6]) == [14]\nassert op_trimends_first3_add10([-7, 12, -7]) == [22]"}
{"id": "op_dec_takewhilepos_pos", "entry_point": "op_dec_takewhilepos_pos", "primitives": ["dec", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then keep the positive numbers.", "solution": "def op_dec_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dec_takewhilepos_pos([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos_pos([]) == []\nassert op_dec_takewhilepos_pos([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos_pos([5, 5, 5]) == [4, 4, 4]\nassert op_dec_takewhilepos_pos([3, 1, 2]) == [2]\nassert op_dec_takewhilepos_pos([10]) == [9]\nassert op_dec_takewhilepos_pos([2, 4, 6]) == [1, 3, 5]\nassert op_dec_takewhilepos_pos([-7, 12, -7]) == []"}
{"id": "op_first3_neg_padto3", "entry_point": "op_first3_neg_padto3", "primitives": ["first3", "neg", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_first3_neg_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_first3_neg_padto3([]) == [0, 0, 0]\nassert op_first3_neg_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_first3_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_first3_neg_padto3([10]) == [0, 0, 0]\nassert op_first3_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_first3_neg_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_double_gt5_div3", "entry_point": "op_double_gt5_div3", "primitives": ["double", "gt5", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then keep multiples of three.", "solution": "def op_double_gt5_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_gt5_div3([1, 2, 3, 4]) == [6]\nassert op_double_gt5_div3([]) == []\nassert op_double_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_div3([5, 5, 5]) == []\nassert op_double_gt5_div3([3, 1, 2]) == [6]\nassert op_double_gt5_div3([10]) == []\nassert op_double_gt5_div3([2, 4, 6]) == [12]\nassert op_double_gt5_div3([-7, 12, -7]) == [24]"}
{"id": "op_div3_square_trimends", "entry_point": "op_div3_square_trimends", "primitives": ["div3", "square", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then drop the first and last elements.", "solution": "def op_div3_square_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_square_trimends([1, 2, 3, 4]) == []\nassert op_div3_square_trimends([]) == []\nassert op_div3_square_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_square_trimends([5, 5, 5]) == []\nassert op_div3_square_trimends([3, 1, 2]) == []\nassert op_div3_square_trimends([10]) == []\nassert op_div3_square_trimends([2, 4, 6]) == []\nassert op_div3_square_trimends([-7, 12, -7]) == []"}
{"id": "op_gt5_add10_beforezero", "entry_point": "op_gt5_add10_beforezero", "primitives": ["gt5", "add10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then keep everything before the first zero.", "solution": "def op_gt5_add10_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_gt5_add10_beforezero([1, 2, 3, 4]) == []\nassert op_gt5_add10_beforezero([]) == []\nassert op_gt5_add10_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_beforezero([5, 5, 5]) == []\nassert op_gt5_add10_beforezero([3, 1, 2]) == []\nassert op_gt5_add10_beforezero([10]) == [20]\nassert op_gt5_add10_beforezero([2, 4, 6]) == [16]\nassert op_gt5_add10_beforezero([-7, 12, -7]) == [22]"}
{"id": "op_inc_uniq_sortd", "entry_point": "op_inc_uniq_sortd", "primitives": ["inc", "uniq", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_inc_uniq_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_uniq_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_uniq_sortd([]) == []\nassert op_inc_uniq_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_uniq_sortd([5, 5, 5]) == [6]\nassert op_inc_uniq_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_inc_uniq_sortd([10]) == [11]\nassert op_inc_uniq_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_inc_uniq_sortd([-7, 12, -7]) == [13, -6]"}
{"id": "op_dec_inc_last3", "entry_point": "op_dec_inc_last3", "primitives": ["dec", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then keep only the last three.", "solution": "def op_dec_inc_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_inc_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dec_inc_last3([]) == []\nassert op_dec_inc_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dec_inc_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc_last3([10]) == [10]\nassert op_dec_inc_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sorta_absval_div3", "entry_point": "op_sorta_absval_div3", "primitives": ["sorta", "absval", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then keep multiples of three.", "solution": "def op_sorta_absval_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_absval_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_absval_div3([]) == []\nassert op_sorta_absval_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sorta_absval_div3([5, 5, 5]) == []\nassert op_sorta_absval_div3([3, 1, 2]) == [3]\nassert op_sorta_absval_div3([10]) == []\nassert op_sorta_absval_div3([2, 4, 6]) == [6]\nassert op_sorta_absval_div3([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortd_max", "entry_point": "op_rev_sortd_max", "primitives": ["rev", "sortd", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then return the maximum (0 if empty).", "solution": "def op_rev_sortd_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return max(r) if r else 0", "tests": "assert op_rev_sortd_max([1, 2, 3, 4]) == 4\nassert op_rev_sortd_max([]) == 0\nassert op_rev_sortd_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_sortd_max([5, 5, 5]) == 5\nassert op_rev_sortd_max([3, 1, 2]) == 3\nassert op_rev_sortd_max([10]) == 10\nassert op_rev_sortd_max([2, 4, 6]) == 6\nassert op_rev_sortd_max([-7, 12, -7]) == 12"}
{"id": "op_rev_square_firsteven", "entry_point": "op_rev_square_firsteven", "primitives": ["rev", "square", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then return the first even value (0 if none).", "solution": "def op_rev_square_firsteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_rev_square_firsteven([1, 2, 3, 4]) == 16\nassert op_rev_square_firsteven([]) == 0\nassert op_rev_square_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_rev_square_firsteven([5, 5, 5]) == 0\nassert op_rev_square_firsteven([3, 1, 2]) == 4\nassert op_rev_square_firsteven([10]) == 100\nassert op_rev_square_firsteven([2, 4, 6]) == 36\nassert op_rev_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_rev_square_inc", "entry_point": "op_rev_square_inc", "primitives": ["rev", "square", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then add one to each.", "solution": "def op_rev_square_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_square_inc([1, 2, 3, 4]) == [17, 10, 5, 2]\nassert op_rev_square_inc([]) == []\nassert op_rev_square_inc([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_rev_square_inc([5, 5, 5]) == [26, 26, 26]\nassert op_rev_square_inc([3, 1, 2]) == [5, 2, 10]\nassert op_rev_square_inc([10]) == [101]\nassert op_rev_square_inc([2, 4, 6]) == [37, 17, 5]\nassert op_rev_square_inc([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_gt5_sortabs_sorta", "entry_point": "op_gt5_sortabs_sorta", "primitives": ["gt5", "sortabs", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then sort ascending.", "solution": "def op_gt5_sortabs_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_sortabs_sorta([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_sorta([]) == []\nassert op_gt5_sortabs_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_sorta([5, 5, 5]) == []\nassert op_gt5_sortabs_sorta([3, 1, 2]) == []\nassert op_gt5_sortabs_sorta([10]) == [10]\nassert op_gt5_sortabs_sorta([2, 4, 6]) == [6]\nassert op_gt5_sortabs_sorta([-7, 12, -7]) == [12]"}
{"id": "op_first3_sortabs_len", "entry_point": "op_first3_sortabs_len", "primitives": ["first3", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then return how many remain.", "solution": "def op_first3_sortabs_len(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_first3_sortabs_len([1, 2, 3, 4]) == 3\nassert op_first3_sortabs_len([]) == 0\nassert op_first3_sortabs_len([-2, -1, 0, 1, 2]) == 3\nassert op_first3_sortabs_len([5, 5, 5]) == 3\nassert op_first3_sortabs_len([3, 1, 2]) == 3\nassert op_first3_sortabs_len([10]) == 1\nassert op_first3_sortabs_len([2, 4, 6]) == 3\nassert op_first3_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_gt5_negate_sorta", "entry_point": "op_gt5_negate_sorta", "primitives": ["gt5", "negate", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then sort ascending.", "solution": "def op_gt5_negate_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_negate_sorta([1, 2, 3, 4]) == []\nassert op_gt5_negate_sorta([]) == []\nassert op_gt5_negate_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_sorta([5, 5, 5]) == []\nassert op_gt5_negate_sorta([3, 1, 2]) == []\nassert op_gt5_negate_sorta([10]) == [-10]\nassert op_gt5_negate_sorta([2, 4, 6]) == [-6]\nassert op_gt5_negate_sorta([-7, 12, -7]) == [-12]"}
{"id": "op_div3_rev_inc", "entry_point": "op_div3_rev_inc", "primitives": ["div3", "rev", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then add one to each.", "solution": "def op_div3_rev_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_div3_rev_inc([1, 2, 3, 4]) == [4]\nassert op_div3_rev_inc([]) == []\nassert op_div3_rev_inc([-2, -1, 0, 1, 2]) == [1]\nassert op_div3_rev_inc([5, 5, 5]) == []\nassert op_div3_rev_inc([3, 1, 2]) == [4]\nassert op_div3_rev_inc([10]) == []\nassert op_div3_rev_inc([2, 4, 6]) == [7]\nassert op_div3_rev_inc([-7, 12, -7]) == [13]"}
{"id": "op_evens_odds_issorted", "entry_point": "op_evens_odds_issorted", "primitives": ["evens", "odds", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_evens_odds_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_evens_odds_issorted([1, 2, 3, 4]) == True\nassert op_evens_odds_issorted([]) == True\nassert op_evens_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_odds_issorted([5, 5, 5]) == True\nassert op_evens_odds_issorted([3, 1, 2]) == True\nassert op_evens_odds_issorted([10]) == True\nassert op_evens_odds_issorted([2, 4, 6]) == True\nassert op_evens_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_add10_first3_clamp10", "entry_point": "op_add10_first3_clamp10", "primitives": ["add10", "first3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then cap each value at 10.", "solution": "def op_add10_first3_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_first3_clamp10([1, 2, 3, 4]) == [10, 10, 10]\nassert op_add10_first3_clamp10([]) == []\nassert op_add10_first3_clamp10([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_add10_first3_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_add10_first3_clamp10([10]) == [10]\nassert op_add10_first3_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_add10_first3_clamp10([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_dropfirst_dropwhileneg_double", "entry_point": "op_dropfirst_dropwhileneg_double", "primitives": ["dropfirst", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then double each.", "solution": "def op_dropfirst_dropwhileneg_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropfirst_dropwhileneg_double([]) == []\nassert op_dropfirst_dropwhileneg_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropfirst_dropwhileneg_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_dropwhileneg_double([3, 1, 2]) == [2, 4]\nassert op_dropfirst_dropwhileneg_double([10]) == []\nassert op_dropfirst_dropwhileneg_double([2, 4, 6]) == [8, 12]\nassert op_dropfirst_dropwhileneg_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_oremptyzero_neg_inc", "entry_point": "op_oremptyzero_neg_inc", "primitives": ["oremptyzero", "neg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then add one to each.", "solution": "def op_oremptyzero_neg_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_neg_inc([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg_inc([]) == []\nassert op_oremptyzero_neg_inc([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_oremptyzero_neg_inc([5, 5, 5]) == []\nassert op_oremptyzero_neg_inc([3, 1, 2]) == []\nassert op_oremptyzero_neg_inc([10]) == []\nassert op_oremptyzero_neg_inc([2, 4, 6]) == []\nassert op_oremptyzero_neg_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_negate_padto3_issorted", "entry_point": "op_negate_padto3_issorted", "primitives": ["negate", "padto3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_negate_padto3_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_negate_padto3_issorted([1, 2, 3, 4]) == False\nassert op_negate_padto3_issorted([]) == True\nassert op_negate_padto3_issorted([-2, -1, 0, 1, 2]) == False\nassert op_negate_padto3_issorted([5, 5, 5]) == True\nassert op_negate_padto3_issorted([3, 1, 2]) == False\nassert op_negate_padto3_issorted([10]) == True\nassert op_negate_padto3_issorted([2, 4, 6]) == False\nassert op_negate_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_dropfirst_takewhilepos_firsteven", "entry_point": "op_dropfirst_takewhilepos_firsteven", "primitives": ["dropfirst", "takewhilepos", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_dropfirst_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_takewhilepos_firsteven([]) == 0\nassert op_dropfirst_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_dropfirst_takewhilepos_firsteven([10]) == 0\nassert op_dropfirst_takewhilepos_firsteven([2, 4, 6]) == 4\nassert op_dropfirst_takewhilepos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_pos_padto3_dropfirst", "entry_point": "op_pos_padto3_dropfirst", "primitives": ["pos", "padto3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_pos_padto3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_pos_padto3_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_padto3_dropfirst([]) == [0, 0]\nassert op_pos_padto3_dropfirst([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_pos_padto3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_pos_padto3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_pos_padto3_dropfirst([10]) == [0, 0]\nassert op_pos_padto3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_pos_padto3_dropfirst([-7, 12, -7]) == [0, 0]"}
{"id": "op_pos_clamp10_beforezero", "entry_point": "op_pos_clamp10_beforezero", "primitives": ["pos", "clamp10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then keep everything before the first zero.", "solution": "def op_pos_clamp10_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_clamp10_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_clamp10_beforezero([]) == []\nassert op_pos_clamp10_beforezero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_clamp10_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_pos_clamp10_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_pos_clamp10_beforezero([10]) == [10]\nassert op_pos_clamp10_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_clamp10_beforezero([-7, 12, -7]) == [10]"}
{"id": "op_inc_dropfirst_prod", "entry_point": "op_inc_dropfirst_prod", "primitives": ["inc", "dropfirst", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first element, then return their product.", "solution": "def op_inc_dropfirst_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:]\n    return __import__('math').prod(r)", "tests": "assert op_inc_dropfirst_prod([1, 2, 3, 4]) == 60\nassert op_inc_dropfirst_prod([]) == 1\nassert op_inc_dropfirst_prod([-2, -1, 0, 1, 2]) == 0\nassert op_inc_dropfirst_prod([5, 5, 5]) == 36\nassert op_inc_dropfirst_prod([3, 1, 2]) == 6\nassert op_inc_dropfirst_prod([10]) == 1\nassert op_inc_dropfirst_prod([2, 4, 6]) == 35\nassert op_inc_dropfirst_prod([-7, 12, -7]) == -78"}
{"id": "op_double_sortabs_gt5", "entry_point": "op_double_sortabs_gt5", "primitives": ["double", "sortabs", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then keep values greater than five.", "solution": "def op_double_sortabs_gt5(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_double_sortabs_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_double_sortabs_gt5([]) == []\nassert op_double_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_double_sortabs_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortabs_gt5([3, 1, 2]) == [6]\nassert op_double_sortabs_gt5([10]) == [20]\nassert op_double_sortabs_gt5([2, 4, 6]) == [8, 12]\nassert op_double_sortabs_gt5([-7, 12, -7]) == [24]"}
{"id": "op_ages_uniq_sortabs", "entry_point": "op_ages_uniq_sortabs", "primitives": ["ages", "uniq", "sortabs"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then sort by absolute value.", "solution": "def op_ages_uniq_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_uniq_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_uniq_sortabs([]) == []\nassert op_ages_uniq_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_uniq_sortabs([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropfirst_oremptyzero_max", "entry_point": "op_dropfirst_oremptyzero_max", "primitives": ["dropfirst", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_dropfirst_oremptyzero_max(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_dropfirst_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_dropfirst_oremptyzero_max([]) == 0\nassert op_dropfirst_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_oremptyzero_max([5, 5, 5]) == 5\nassert op_dropfirst_oremptyzero_max([3, 1, 2]) == 2\nassert op_dropfirst_oremptyzero_max([10]) == 0\nassert op_dropfirst_oremptyzero_max([2, 4, 6]) == 6\nassert op_dropfirst_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_takewhilepos_beforezero", "entry_point": "op_dropfirst_takewhilepos_beforezero", "primitives": ["dropfirst", "takewhilepos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_dropfirst_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_takewhilepos_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_takewhilepos_beforezero([]) == []\nassert op_dropfirst_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_takewhilepos_beforezero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_takewhilepos_beforezero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_takewhilepos_beforezero([10]) == []\nassert op_dropfirst_takewhilepos_beforezero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_takewhilepos_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sorta_inc_div3", "entry_point": "op_sorta_inc_div3", "primitives": ["sorta", "inc", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then keep multiples of three.", "solution": "def op_sorta_inc_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_inc_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_inc_div3([]) == []\nassert op_sorta_inc_div3([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_sorta_inc_div3([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_div3([3, 1, 2]) == [3]\nassert op_sorta_inc_div3([10]) == []\nassert op_sorta_inc_div3([2, 4, 6]) == [3]\nassert op_sorta_inc_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_oremptyzero_padto3_absval", "entry_point": "op_oremptyzero_padto3_absval", "primitives": ["oremptyzero", "padto3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_oremptyzero_padto3_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_padto3_absval([]) == [0, 0, 0]\nassert op_oremptyzero_padto3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_oremptyzero_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_padto3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_padto3_absval([10]) == [10, 0, 0]\nassert op_oremptyzero_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_padto3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_evens_trimends_negate", "entry_point": "op_evens_trimends_negate", "primitives": ["evens", "trimends", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then negate each.", "solution": "def op_evens_trimends_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_trimends_negate([1, 2, 3, 4]) == []\nassert op_evens_trimends_negate([]) == []\nassert op_evens_trimends_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_trimends_negate([5, 5, 5]) == []\nassert op_evens_trimends_negate([3, 1, 2]) == []\nassert op_evens_trimends_negate([10]) == []\nassert op_evens_trimends_negate([2, 4, 6]) == [-4]\nassert op_evens_trimends_negate([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_last3_inc", "entry_point": "op_takewhilepos_last3_inc", "primitives": ["takewhilepos", "last3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then add one to each.", "solution": "def op_takewhilepos_last3_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_last3_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_takewhilepos_last3_inc([]) == []\nassert op_takewhilepos_last3_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_last3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_takewhilepos_last3_inc([10]) == [11]\nassert op_takewhilepos_last3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_last3_inc([-7, 12, -7]) == []"}
{"id": "op_rev_negate_sorta", "entry_point": "op_rev_negate_sorta", "primitives": ["rev", "negate", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then sort ascending.", "solution": "def op_rev_negate_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_rev_negate_sorta([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_rev_negate_sorta([]) == []\nassert op_rev_negate_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_negate_sorta([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_negate_sorta([3, 1, 2]) == [-3, -2, -1]\nassert op_rev_negate_sorta([10]) == [-10]\nassert op_rev_negate_sorta([2, 4, 6]) == [-6, -4, -2]\nassert op_rev_negate_sorta([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_ages_dropwhileneg_trimends", "entry_point": "op_ages_dropwhileneg_trimends", "primitives": ["ages", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_ages_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_dropwhileneg_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_dropwhileneg_trimends([]) == []\nassert op_ages_dropwhileneg_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_dropwhileneg_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_negate_sorta_trimends", "entry_point": "op_negate_sorta_trimends", "primitives": ["negate", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then drop the first and last elements.", "solution": "def op_negate_sorta_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_sorta_trimends([1, 2, 3, 4]) == [-3, -2]\nassert op_negate_sorta_trimends([]) == []\nassert op_negate_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_negate_sorta_trimends([5, 5, 5]) == [-5]\nassert op_negate_sorta_trimends([3, 1, 2]) == [-2]\nassert op_negate_sorta_trimends([10]) == []\nassert op_negate_sorta_trimends([2, 4, 6]) == [-4]\nassert op_negate_sorta_trimends([-7, 12, -7]) == [7]"}
{"id": "op_negate_odds_len", "entry_point": "op_negate_odds_len", "primitives": ["negate", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then return how many remain.", "solution": "def op_negate_odds_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_negate_odds_len([1, 2, 3, 4]) == 2\nassert op_negate_odds_len([]) == 0\nassert op_negate_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_negate_odds_len([5, 5, 5]) == 3\nassert op_negate_odds_len([3, 1, 2]) == 2\nassert op_negate_odds_len([10]) == 0\nassert op_negate_odds_len([2, 4, 6]) == 0\nassert op_negate_odds_len([-7, 12, -7]) == 2"}
{"id": "op_odds_sorta_last3", "entry_point": "op_odds_sorta_last3", "primitives": ["odds", "sorta", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then keep only the last three.", "solution": "def op_odds_sorta_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    r = r[-3:]\n    return r", "tests": "assert op_odds_sorta_last3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sorta_last3([]) == []\nassert op_odds_sorta_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_sorta_last3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sorta_last3([3, 1, 2]) == [1, 3]\nassert op_odds_sorta_last3([10]) == []\nassert op_odds_sorta_last3([2, 4, 6]) == []\nassert op_odds_sorta_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_ages_dec_sum", "entry_point": "op_ages_dec_sum", "primitives": ["ages", "dec", "sum"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then return their sum.", "solution": "def op_ages_dec_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    return sum(r)", "tests": "assert op_ages_dec_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 46\nassert op_ages_dec_sum([]) == 0\nassert op_ages_dec_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 97\nassert op_ages_dec_sum([{'name': 'Fi', 'age': 41}]) == 40"}
{"id": "op_last3_neg_alldistinct", "entry_point": "op_last3_neg_alldistinct", "primitives": ["last3", "neg", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then return whether all values are distinct.", "solution": "def op_last3_neg_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return len(r) == len(set(r))", "tests": "assert op_last3_neg_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_neg_alldistinct([]) == True\nassert op_last3_neg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_neg_alldistinct([5, 5, 5]) == True\nassert op_last3_neg_alldistinct([3, 1, 2]) == True\nassert op_last3_neg_alldistinct([10]) == True\nassert op_last3_neg_alldistinct([2, 4, 6]) == True\nassert op_last3_neg_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_oremptyzero_dropzeros", "entry_point": "op_dropwhileneg_oremptyzero_dropzeros", "primitives": ["dropwhileneg", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then drop the zeros.", "solution": "def op_dropwhileneg_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_oremptyzero_dropzeros([]) == []\nassert op_dropwhileneg_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_oremptyzero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_oremptyzero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_oremptyzero_dropzeros([10]) == [10]\nassert op_dropwhileneg_oremptyzero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_oremptyzero_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropwhileneg_rev_gt5", "entry_point": "op_dropwhileneg_rev_gt5", "primitives": ["dropwhileneg", "rev", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then keep values greater than five.", "solution": "def op_dropwhileneg_rev_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_rev_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_rev_gt5([]) == []\nassert op_dropwhileneg_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_rev_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_rev_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_rev_gt5([10]) == [10]\nassert op_dropwhileneg_rev_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_rev_gt5([-7, 12, -7]) == [12]"}
{"id": "op_inc_negate_padto3", "entry_point": "op_inc_negate_padto3", "primitives": ["inc", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then negate each, then pad with zeros to at least three elements.", "solution": "def op_inc_negate_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_negate_padto3([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_inc_negate_padto3([]) == [0, 0, 0]\nassert op_inc_negate_padto3([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_inc_negate_padto3([5, 5, 5]) == [-6, -6, -6]\nassert op_inc_negate_padto3([3, 1, 2]) == [-4, -2, -3]\nassert op_inc_negate_padto3([10]) == [-11, 0, 0]\nassert op_inc_negate_padto3([2, 4, 6]) == [-3, -5, -7]\nassert op_inc_negate_padto3([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_last3_sortabs_beforezero", "entry_point": "op_last3_sortabs_beforezero", "primitives": ["last3", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_last3_sortabs_beforezero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_last3_sortabs_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortabs_beforezero([]) == []\nassert op_last3_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_last3_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortabs_beforezero([10]) == [10]\nassert op_last3_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortabs_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropzeros_double_clamp10", "entry_point": "op_dropzeros_double_clamp10", "primitives": ["dropzeros", "double", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then cap each value at 10.", "solution": "def op_dropzeros_double_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_double_clamp10([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double_clamp10([]) == []\nassert op_dropzeros_double_clamp10([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_dropzeros_double_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_double_clamp10([10]) == [10]\nassert op_dropzeros_double_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_dropzeros_double_clamp10([-7, 12, -7]) == [-14, 10, -14]"}
{"id": "op_absval_dropzeros_first3", "entry_point": "op_absval_dropzeros_first3", "primitives": ["absval", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then keep only the first three.", "solution": "def op_absval_dropzeros_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_absval_dropzeros_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_dropzeros_first3([]) == []\nassert op_absval_dropzeros_first3([-2, -1, 0, 1, 2]) == [2, 1, 1]\nassert op_absval_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropzeros_first3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_dropzeros_first3([10]) == [10]\nassert op_absval_dropzeros_first3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_dropzeros_first3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sorta_clamp10_uniq", "entry_point": "op_sorta_clamp10_uniq", "primitives": ["sorta", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_sorta_clamp10_uniq(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sorta_clamp10_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10_uniq([]) == []\nassert op_sorta_clamp10_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_clamp10_uniq([5, 5, 5]) == [5]\nassert op_sorta_clamp10_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_uniq([10]) == [10]\nassert op_sorta_clamp10_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_beforezero_rev_absval", "entry_point": "op_beforezero_rev_absval", "primitives": ["beforezero", "rev", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then take the absolute value of each.", "solution": "def op_beforezero_rev_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_rev_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_rev_absval([]) == []\nassert op_beforezero_rev_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_beforezero_rev_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_rev_absval([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_rev_absval([10]) == [10]\nassert op_beforezero_rev_absval([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_rev_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sortabs_double_absval", "entry_point": "op_sortabs_double_absval", "primitives": ["sortabs", "double", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then take the absolute value of each.", "solution": "def op_sortabs_double_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_double_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_double_absval([]) == []\nassert op_sortabs_double_absval([-2, -1, 0, 1, 2]) == [0, 2, 2, 4, 4]\nassert op_sortabs_double_absval([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double_absval([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_double_absval([10]) == [20]\nassert op_sortabs_double_absval([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_double_absval([-7, 12, -7]) == [14, 14, 24]"}
{"id": "op_evens_dropzeros_beforezero", "entry_point": "op_evens_dropzeros_beforezero", "primitives": ["evens", "dropzeros", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then keep everything before the first zero.", "solution": "def op_evens_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_dropzeros_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_dropzeros_beforezero([]) == []\nassert op_evens_dropzeros_beforezero([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_evens_dropzeros_beforezero([5, 5, 5]) == []\nassert op_evens_dropzeros_beforezero([3, 1, 2]) == [2]\nassert op_evens_dropzeros_beforezero([10]) == [10]\nassert op_evens_dropzeros_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_dropzeros_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_trimends_padto3_prod", "entry_point": "op_trimends_padto3_prod", "primitives": ["trimends", "padto3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then return their product.", "solution": "def op_trimends_padto3_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_trimends_padto3_prod([1, 2, 3, 4]) == 0\nassert op_trimends_padto3_prod([]) == 0\nassert op_trimends_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_padto3_prod([5, 5, 5]) == 0\nassert op_trimends_padto3_prod([3, 1, 2]) == 0\nassert op_trimends_padto3_prod([10]) == 0\nassert op_trimends_padto3_prod([2, 4, 6]) == 0\nassert op_trimends_padto3_prod([-7, 12, -7]) == 0"}
{"id": "op_inc_oremptyzero_dec", "entry_point": "op_inc_oremptyzero_dec", "primitives": ["inc", "oremptyzero", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then subtract one from each.", "solution": "def op_inc_oremptyzero_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_oremptyzero_dec([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_oremptyzero_dec([]) == [-1]\nassert op_inc_oremptyzero_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_oremptyzero_dec([5, 5, 5]) == [5, 5, 5]\nassert op_inc_oremptyzero_dec([3, 1, 2]) == [3, 1, 2]\nassert op_inc_oremptyzero_dec([10]) == [10]\nassert op_inc_oremptyzero_dec([2, 4, 6]) == [2, 4, 6]\nassert op_inc_oremptyzero_dec([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_first3_square_pos", "entry_point": "op_first3_square_pos", "primitives": ["first3", "square", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each, then keep the positive numbers.", "solution": "def op_first3_square_pos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_first3_square_pos([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_square_pos([]) == []\nassert op_first3_square_pos([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_first3_square_pos([5, 5, 5]) == [25, 25, 25]\nassert op_first3_square_pos([3, 1, 2]) == [9, 1, 4]\nassert op_first3_square_pos([10]) == [100]\nassert op_first3_square_pos([2, 4, 6]) == [4, 16, 36]\nassert op_first3_square_pos([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_double_negate_anyeven", "entry_point": "op_double_negate_anyeven", "primitives": ["double", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then return whether any value is even.", "solution": "def op_double_negate_anyeven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_double_negate_anyeven([1, 2, 3, 4]) == True\nassert op_double_negate_anyeven([]) == False\nassert op_double_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_double_negate_anyeven([5, 5, 5]) == True\nassert op_double_negate_anyeven([3, 1, 2]) == True\nassert op_double_negate_anyeven([10]) == True\nassert op_double_negate_anyeven([2, 4, 6]) == True\nassert op_double_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_negate_rev", "entry_point": "op_sorta_negate_rev", "primitives": ["sorta", "negate", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then reverse the order.", "solution": "def op_sorta_negate_rev(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sorta_negate_rev([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_sorta_negate_rev([]) == []\nassert op_sorta_negate_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_negate_rev([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_negate_rev([3, 1, 2]) == [-3, -2, -1]\nassert op_sorta_negate_rev([10]) == [-10]\nassert op_sorta_negate_rev([2, 4, 6]) == [-6, -4, -2]\nassert op_sorta_negate_rev([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_oremptyzero_sorta_trimends", "entry_point": "op_oremptyzero_sorta_trimends", "primitives": ["oremptyzero", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then drop the first and last elements.", "solution": "def op_oremptyzero_sorta_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_oremptyzero_sorta_trimends([]) == []\nassert op_oremptyzero_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_oremptyzero_sorta_trimends([5, 5, 5]) == [5]\nassert op_oremptyzero_sorta_trimends([3, 1, 2]) == [2]\nassert op_oremptyzero_sorta_trimends([10]) == []\nassert op_oremptyzero_sorta_trimends([2, 4, 6]) == [4]\nassert op_oremptyzero_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_ages_first3_oremptyzero", "entry_point": "op_ages_first3_oremptyzero", "primitives": ["ages", "first3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then if empty, use a single zero.", "solution": "def op_ages_first3_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_first3_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_first3_oremptyzero([]) == [0]\nassert op_ages_first3_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_first3_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_pos_gt5_anyeven", "entry_point": "op_pos_gt5_anyeven", "primitives": ["pos", "gt5", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep values greater than five, then return whether any value is even.", "solution": "def op_pos_gt5_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_gt5_anyeven([1, 2, 3, 4]) == False\nassert op_pos_gt5_anyeven([]) == False\nassert op_pos_gt5_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_pos_gt5_anyeven([5, 5, 5]) == False\nassert op_pos_gt5_anyeven([3, 1, 2]) == False\nassert op_pos_gt5_anyeven([10]) == True\nassert op_pos_gt5_anyeven([2, 4, 6]) == True\nassert op_pos_gt5_anyeven([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_evens_uniq", "entry_point": "op_oremptyzero_evens_uniq", "primitives": ["oremptyzero", "evens", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_evens_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_evens_uniq([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_evens_uniq([]) == [0]\nassert op_oremptyzero_evens_uniq([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_oremptyzero_evens_uniq([5, 5, 5]) == []\nassert op_oremptyzero_evens_uniq([3, 1, 2]) == [2]\nassert op_oremptyzero_evens_uniq([10]) == [10]\nassert op_oremptyzero_evens_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens_uniq([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_absval_alldistinct", "entry_point": "op_sortabs_absval_alldistinct", "primitives": ["sortabs", "absval", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then return whether all values are distinct.", "solution": "def op_sortabs_absval_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_absval_alldistinct([]) == True\nassert op_sortabs_absval_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_absval_alldistinct([5, 5, 5]) == False\nassert op_sortabs_absval_alldistinct([3, 1, 2]) == True\nassert op_sortabs_absval_alldistinct([10]) == True\nassert op_sortabs_absval_alldistinct([2, 4, 6]) == True\nassert op_sortabs_absval_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_evens_div3", "entry_point": "op_dropzeros_evens_div3", "primitives": ["dropzeros", "evens", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then keep multiples of three.", "solution": "def op_dropzeros_evens_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropzeros_evens_div3([1, 2, 3, 4]) == []\nassert op_dropzeros_evens_div3([]) == []\nassert op_dropzeros_evens_div3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_evens_div3([5, 5, 5]) == []\nassert op_dropzeros_evens_div3([3, 1, 2]) == []\nassert op_dropzeros_evens_div3([10]) == []\nassert op_dropzeros_evens_div3([2, 4, 6]) == [6]\nassert op_dropzeros_evens_div3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_rev_oremptyzero", "entry_point": "op_gt5_rev_oremptyzero", "primitives": ["gt5", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then if empty, use a single zero.", "solution": "def op_gt5_rev_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_rev_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_rev_oremptyzero([]) == [0]\nassert op_gt5_rev_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_rev_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_rev_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_rev_oremptyzero([10]) == [10]\nassert op_gt5_rev_oremptyzero([2, 4, 6]) == [6]\nassert op_gt5_rev_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_sortabs_beforezero", "entry_point": "op_dropzeros_sortabs_beforezero", "primitives": ["dropzeros", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_dropzeros_sortabs_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_sortabs_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sortabs_beforezero([]) == []\nassert op_dropzeros_sortabs_beforezero([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_dropzeros_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sortabs_beforezero([10]) == [10]\nassert op_dropzeros_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sortabs_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_div3_negate_uniq", "entry_point": "op_div3_negate_uniq", "primitives": ["div3", "negate", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_div3_negate_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_negate_uniq([1, 2, 3, 4]) == [-3]\nassert op_div3_negate_uniq([]) == []\nassert op_div3_negate_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_negate_uniq([5, 5, 5]) == []\nassert op_div3_negate_uniq([3, 1, 2]) == [-3]\nassert op_div3_negate_uniq([10]) == []\nassert op_div3_negate_uniq([2, 4, 6]) == [-6]\nassert op_div3_negate_uniq([-7, 12, -7]) == [-12]"}
{"id": "op_div3_last3_uniq", "entry_point": "op_div3_last3_uniq", "primitives": ["div3", "last3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then drop duplicates keeping first occurrence.", "solution": "def op_div3_last3_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_last3_uniq([1, 2, 3, 4]) == [3]\nassert op_div3_last3_uniq([]) == []\nassert op_div3_last3_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_last3_uniq([5, 5, 5]) == []\nassert op_div3_last3_uniq([3, 1, 2]) == [3]\nassert op_div3_last3_uniq([10]) == []\nassert op_div3_last3_uniq([2, 4, 6]) == [6]\nassert op_div3_last3_uniq([-7, 12, -7]) == [12]"}
{"id": "op_nonempty_firstchar_dropshort", "entry_point": "op_nonempty_firstchar_dropshort", "primitives": ["nonempty", "firstchar", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then keep the first character of each (dropping empties), then drop strings shorter than three characters.", "solution": "def op_nonempty_firstchar_dropshort(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_nonempty_firstchar_dropshort(['Hello', 'world']) == []\nassert op_nonempty_firstchar_dropshort([]) == []\nassert op_nonempty_firstchar_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_nonempty_firstchar_dropshort(['one', 'one', 'Two']) == []\nassert op_nonempty_firstchar_dropshort(['x']) == []\nassert op_nonempty_firstchar_dropshort(['abc', 'de', '']) == []"}
{"id": "op_add10_dropfirst_double", "entry_point": "op_add10_dropfirst_double", "primitives": ["add10", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then double each.", "solution": "def op_add10_dropfirst_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_dropfirst_double([1, 2, 3, 4]) == [24, 26, 28]\nassert op_add10_dropfirst_double([]) == []\nassert op_add10_dropfirst_double([-2, -1, 0, 1, 2]) == [18, 20, 22, 24]\nassert op_add10_dropfirst_double([5, 5, 5]) == [30, 30]\nassert op_add10_dropfirst_double([3, 1, 2]) == [22, 24]\nassert op_add10_dropfirst_double([10]) == []\nassert op_add10_dropfirst_double([2, 4, 6]) == [28, 32]\nassert op_add10_dropfirst_double([-7, 12, -7]) == [44, 6]"}
{"id": "op_double_evens_sum", "entry_point": "op_double_evens_sum", "primitives": ["double", "evens", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then return their sum.", "solution": "def op_double_evens_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_double_evens_sum([1, 2, 3, 4]) == 20\nassert op_double_evens_sum([]) == 0\nassert op_double_evens_sum([-2, -1, 0, 1, 2]) == 0\nassert op_double_evens_sum([5, 5, 5]) == 30\nassert op_double_evens_sum([3, 1, 2]) == 12\nassert op_double_evens_sum([10]) == 20\nassert op_double_evens_sum([2, 4, 6]) == 24\nassert op_double_evens_sum([-7, 12, -7]) == -4"}
{"id": "op_uniq_square_negate", "entry_point": "op_uniq_square_negate", "primitives": ["uniq", "square", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then negate each.", "solution": "def op_uniq_square_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_square_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_uniq_square_negate([]) == []\nassert op_uniq_square_negate([-2, -1, 0, 1, 2]) == [-4, -1, 0, -1, -4]\nassert op_uniq_square_negate([5, 5, 5]) == [-25]\nassert op_uniq_square_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_uniq_square_negate([10]) == [-100]\nassert op_uniq_square_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_uniq_square_negate([-7, 12, -7]) == [-49, -144]"}
{"id": "op_clamp10_negate_absval", "entry_point": "op_clamp10_negate_absval", "primitives": ["clamp10", "negate", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then take the absolute value of each.", "solution": "def op_clamp10_negate_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_negate_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_negate_absval([]) == []\nassert op_clamp10_negate_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_negate_absval([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_negate_absval([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_negate_absval([10]) == [10]\nassert op_clamp10_negate_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_negate_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_dropzeros_beforezero_pos", "entry_point": "op_dropzeros_beforezero_pos", "primitives": ["dropzeros", "beforezero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_dropzeros_beforezero_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_beforezero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_beforezero_pos([]) == []\nassert op_dropzeros_beforezero_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_beforezero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_beforezero_pos([10]) == [10]\nassert op_dropzeros_beforezero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_first3_pos_absval", "entry_point": "op_first3_pos_absval", "primitives": ["first3", "pos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_first3_pos_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_pos_absval([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_pos_absval([]) == []\nassert op_first3_pos_absval([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_first3_pos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_first3_pos_absval([10]) == [10]\nassert op_first3_pos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_first3_pos_absval([-7, 12, -7]) == [12]"}
{"id": "op_padto3_dec_neg", "entry_point": "op_padto3_dec_neg", "primitives": ["padto3", "dec", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then keep the negative numbers.", "solution": "def op_padto3_dec_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_dec_neg([1, 2, 3, 4]) == []\nassert op_padto3_dec_neg([]) == [-1, -1, -1]\nassert op_padto3_dec_neg([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_padto3_dec_neg([5, 5, 5]) == []\nassert op_padto3_dec_neg([3, 1, 2]) == []\nassert op_padto3_dec_neg([10]) == [-1, -1]\nassert op_padto3_dec_neg([2, 4, 6]) == []\nassert op_padto3_dec_neg([-7, 12, -7]) == [-8, -8]"}
{"id": "op_evens_dropfirst_double", "entry_point": "op_evens_dropfirst_double", "primitives": ["evens", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then double each.", "solution": "def op_evens_dropfirst_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_dropfirst_double([1, 2, 3, 4]) == [8]\nassert op_evens_dropfirst_double([]) == []\nassert op_evens_dropfirst_double([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_evens_dropfirst_double([5, 5, 5]) == []\nassert op_evens_dropfirst_double([3, 1, 2]) == []\nassert op_evens_dropfirst_double([10]) == []\nassert op_evens_dropfirst_double([2, 4, 6]) == [8, 12]\nassert op_evens_dropfirst_double([-7, 12, -7]) == []"}
{"id": "op_negate_dec_allpos", "entry_point": "op_negate_dec_allpos", "primitives": ["negate", "dec", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then return whether all values are positive.", "solution": "def op_negate_dec_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_negate_dec_allpos([1, 2, 3, 4]) == False\nassert op_negate_dec_allpos([]) == True\nassert op_negate_dec_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_dec_allpos([5, 5, 5]) == False\nassert op_negate_dec_allpos([3, 1, 2]) == False\nassert op_negate_dec_allpos([10]) == False\nassert op_negate_dec_allpos([2, 4, 6]) == False\nassert op_negate_dec_allpos([-7, 12, -7]) == False"}
{"id": "op_add10_first3_max", "entry_point": "op_add10_first3_max", "primitives": ["add10", "first3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_add10_first3_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_add10_first3_max([1, 2, 3, 4]) == 13\nassert op_add10_first3_max([]) == 0\nassert op_add10_first3_max([-2, -1, 0, 1, 2]) == 10\nassert op_add10_first3_max([5, 5, 5]) == 15\nassert op_add10_first3_max([3, 1, 2]) == 13\nassert op_add10_first3_max([10]) == 20\nassert op_add10_first3_max([2, 4, 6]) == 16\nassert op_add10_first3_max([-7, 12, -7]) == 22"}
{"id": "op_takewhilepos_add10_anyeven", "entry_point": "op_takewhilepos_add10_anyeven", "primitives": ["takewhilepos", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then return whether any value is even.", "solution": "def op_takewhilepos_add10_anyeven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_takewhilepos_add10_anyeven([1, 2, 3, 4]) == True\nassert op_takewhilepos_add10_anyeven([]) == False\nassert op_takewhilepos_add10_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_add10_anyeven([5, 5, 5]) == False\nassert op_takewhilepos_add10_anyeven([3, 1, 2]) == True\nassert op_takewhilepos_add10_anyeven([10]) == True\nassert op_takewhilepos_add10_anyeven([2, 4, 6]) == True\nassert op_takewhilepos_add10_anyeven([-7, 12, -7]) == False"}
{"id": "op_inc_odds_takewhilepos", "entry_point": "op_inc_odds_takewhilepos", "primitives": ["inc", "odds", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then take values while they are positive.", "solution": "def op_inc_odds_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_odds_takewhilepos([1, 2, 3, 4]) == [3, 5]\nassert op_inc_odds_takewhilepos([]) == []\nassert op_inc_odds_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_odds_takewhilepos([5, 5, 5]) == []\nassert op_inc_odds_takewhilepos([3, 1, 2]) == [3]\nassert op_inc_odds_takewhilepos([10]) == [11]\nassert op_inc_odds_takewhilepos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_odds_takewhilepos([-7, 12, -7]) == [13]"}
{"id": "op_sortage_ages_anyeven", "entry_point": "op_sortage_ages_anyeven", "primitives": ["sortage", "ages", "anyeven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then return whether any value is even.", "solution": "def op_sortage_ages_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortage_ages_anyeven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_sortage_ages_anyeven([]) == False\nassert op_sortage_ages_anyeven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_sortage_ages_anyeven([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_dec_clamp10_dropzeros", "entry_point": "op_dec_clamp10_dropzeros", "primitives": ["dec", "clamp10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cap each value at 10, then drop the zeros.", "solution": "def op_dec_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_clamp10_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_clamp10_dropzeros([]) == []\nassert op_dec_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [-3, -2, -1, 1]\nassert op_dec_clamp10_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_clamp10_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dec_clamp10_dropzeros([10]) == [9]\nassert op_dec_clamp10_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_dec_clamp10_dropzeros([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_ages_oremptyzero_sorta", "entry_point": "op_ages_oremptyzero_sorta", "primitives": ["ages", "oremptyzero", "sorta"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then sort ascending.", "solution": "def op_ages_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_ages_oremptyzero_sorta([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_oremptyzero_sorta([]) == [0]\nassert op_ages_oremptyzero_sorta([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_oremptyzero_sorta([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_oremptyzero_sortabs_sorta", "entry_point": "op_oremptyzero_sortabs_sorta", "primitives": ["oremptyzero", "sortabs", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then sort ascending.", "solution": "def op_oremptyzero_sortabs_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_sortabs_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sortabs_sorta([]) == [0]\nassert op_oremptyzero_sortabs_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sortabs_sorta([10]) == [10]\nassert op_oremptyzero_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sortabs_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_pos_trimends_add10", "entry_point": "op_pos_trimends_add10", "primitives": ["pos", "trimends", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then add ten to each.", "solution": "def op_pos_trimends_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_trimends_add10([1, 2, 3, 4]) == [12, 13]\nassert op_pos_trimends_add10([]) == []\nassert op_pos_trimends_add10([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_add10([5, 5, 5]) == [15]\nassert op_pos_trimends_add10([3, 1, 2]) == [11]\nassert op_pos_trimends_add10([10]) == []\nassert op_pos_trimends_add10([2, 4, 6]) == [14]\nassert op_pos_trimends_add10([-7, 12, -7]) == []"}
{"id": "op_odds_dropwhileneg_gt5", "entry_point": "op_odds_dropwhileneg_gt5", "primitives": ["odds", "dropwhileneg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values, then keep values greater than five.", "solution": "def op_odds_dropwhileneg_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_dropwhileneg_gt5([1, 2, 3, 4]) == []\nassert op_odds_dropwhileneg_gt5([]) == []\nassert op_odds_dropwhileneg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_dropwhileneg_gt5([5, 5, 5]) == []\nassert op_odds_dropwhileneg_gt5([3, 1, 2]) == []\nassert op_odds_dropwhileneg_gt5([10]) == []\nassert op_odds_dropwhileneg_gt5([2, 4, 6]) == []\nassert op_odds_dropwhileneg_gt5([-7, 12, -7]) == []"}
{"id": "op_gt5_takewhilepos_padto3", "entry_point": "op_gt5_takewhilepos_padto3", "primitives": ["gt5", "takewhilepos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_gt5_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_gt5_takewhilepos_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_gt5_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_takewhilepos_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_takewhilepos_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_takewhilepos_padto3([10]) == [10, 0, 0]\nassert op_gt5_takewhilepos_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_gt5_takewhilepos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_ages_absval_div3", "entry_point": "op_ages_absval_div3", "primitives": ["ages", "absval", "div3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then keep multiples of three.", "solution": "def op_ages_absval_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_absval_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_absval_div3([]) == []\nassert op_ages_absval_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_absval_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_trimends_rev_gt5", "entry_point": "op_trimends_rev_gt5", "primitives": ["trimends", "rev", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then keep values greater than five.", "solution": "def op_trimends_rev_gt5(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_trimends_rev_gt5([1, 2, 3, 4]) == []\nassert op_trimends_rev_gt5([]) == []\nassert op_trimends_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_trimends_rev_gt5([5, 5, 5]) == []\nassert op_trimends_rev_gt5([3, 1, 2]) == []\nassert op_trimends_rev_gt5([10]) == []\nassert op_trimends_rev_gt5([2, 4, 6]) == []\nassert op_trimends_rev_gt5([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_dropfirst_takewhilepos", "entry_point": "op_beforezero_dropfirst_takewhilepos", "primitives": ["beforezero", "dropfirst", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then take values while they are positive.", "solution": "def op_beforezero_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_dropfirst_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_dropfirst_takewhilepos([]) == []\nassert op_beforezero_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_dropfirst_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_beforezero_dropfirst_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_beforezero_dropfirst_takewhilepos([10]) == []\nassert op_beforezero_dropfirst_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_beforezero_dropfirst_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dec_square_div3", "entry_point": "op_dec_square_div3", "primitives": ["dec", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then keep multiples of three.", "solution": "def op_dec_square_div3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dec_square_div3([1, 2, 3, 4]) == [0, 9]\nassert op_dec_square_div3([]) == []\nassert op_dec_square_div3([-2, -1, 0, 1, 2]) == [9, 0]\nassert op_dec_square_div3([5, 5, 5]) == []\nassert op_dec_square_div3([3, 1, 2]) == [0]\nassert op_dec_square_div3([10]) == [81]\nassert op_dec_square_div3([2, 4, 6]) == [9]\nassert op_dec_square_div3([-7, 12, -7]) == []"}
{"id": "op_odds_add10_double", "entry_point": "op_odds_add10_double", "primitives": ["odds", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then double each.", "solution": "def op_odds_add10_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_add10_double([1, 2, 3, 4]) == [22, 26]\nassert op_odds_add10_double([]) == []\nassert op_odds_add10_double([-2, -1, 0, 1, 2]) == [18, 22]\nassert op_odds_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_odds_add10_double([3, 1, 2]) == [26, 22]\nassert op_odds_add10_double([10]) == []\nassert op_odds_add10_double([2, 4, 6]) == []\nassert op_odds_add10_double([-7, 12, -7]) == [6, 6]"}
{"id": "op_sortd_odds_takewhilepos", "entry_point": "op_sortd_odds_takewhilepos", "primitives": ["sortd", "odds", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then take values while they are positive.", "solution": "def op_sortd_odds_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_odds_takewhilepos([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_odds_takewhilepos([]) == []\nassert op_sortd_odds_takewhilepos([-2, -1, 0, 1, 2]) == [1]\nassert op_sortd_odds_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_odds_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_sortd_odds_takewhilepos([10]) == []\nassert op_sortd_odds_takewhilepos([2, 4, 6]) == []\nassert op_sortd_odds_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_odds_trimends_dropwhileneg", "entry_point": "op_odds_trimends_dropwhileneg", "primitives": ["odds", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_odds_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_odds_trimends_dropwhileneg([1, 2, 3, 4]) == []\nassert op_odds_trimends_dropwhileneg([]) == []\nassert op_odds_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_odds_trimends_dropwhileneg([5, 5, 5]) == [5]\nassert op_odds_trimends_dropwhileneg([3, 1, 2]) == []\nassert op_odds_trimends_dropwhileneg([10]) == []\nassert op_odds_trimends_dropwhileneg([2, 4, 6]) == []\nassert op_odds_trimends_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_odds_dec_sortd", "entry_point": "op_odds_dec_sortd", "primitives": ["odds", "dec", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each, then sort descending.", "solution": "def op_odds_dec_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_dec_sortd([1, 2, 3, 4]) == [2, 0]\nassert op_odds_dec_sortd([]) == []\nassert op_odds_dec_sortd([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_odds_dec_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_odds_dec_sortd([3, 1, 2]) == [2, 0]\nassert op_odds_dec_sortd([10]) == []\nassert op_odds_dec_sortd([2, 4, 6]) == []\nassert op_odds_dec_sortd([-7, 12, -7]) == [-8, -8]"}
{"id": "op_dropwhileneg_dropfirst_double", "entry_point": "op_dropwhileneg_dropfirst_double", "primitives": ["dropwhileneg", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then double each.", "solution": "def op_dropwhileneg_dropfirst_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_dropfirst_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropwhileneg_dropfirst_double([]) == []\nassert op_dropwhileneg_dropfirst_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_dropwhileneg_dropfirst_double([5, 5, 5]) == [10, 10]\nassert op_dropwhileneg_dropfirst_double([3, 1, 2]) == [2, 4]\nassert op_dropwhileneg_dropfirst_double([10]) == []\nassert op_dropwhileneg_dropfirst_double([2, 4, 6]) == [8, 12]\nassert op_dropwhileneg_dropfirst_double([-7, 12, -7]) == [-14]"}
{"id": "op_rev_oremptyzero_prod", "entry_point": "op_rev_oremptyzero_prod", "primitives": ["rev", "oremptyzero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then return their product.", "solution": "def op_rev_oremptyzero_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_rev_oremptyzero_prod([1, 2, 3, 4]) == 24\nassert op_rev_oremptyzero_prod([]) == 0\nassert op_rev_oremptyzero_prod([-2, -1, 0, 1, 2]) == 0\nassert op_rev_oremptyzero_prod([5, 5, 5]) == 125\nassert op_rev_oremptyzero_prod([3, 1, 2]) == 6\nassert op_rev_oremptyzero_prod([10]) == 10\nassert op_rev_oremptyzero_prod([2, 4, 6]) == 48\nassert op_rev_oremptyzero_prod([-7, 12, -7]) == 588"}
{"id": "op_oremptyzero_beforezero_last3", "entry_point": "op_oremptyzero_beforezero_last3", "primitives": ["oremptyzero", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero, then keep only the last three.", "solution": "def op_oremptyzero_beforezero_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_beforezero_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_beforezero_last3([]) == []\nassert op_oremptyzero_beforezero_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_beforezero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_beforezero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_beforezero_last3([10]) == [10]\nassert op_oremptyzero_beforezero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_beforezero_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_padto3_takewhilepos_last3", "entry_point": "op_padto3_takewhilepos_last3", "primitives": ["padto3", "takewhilepos", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then keep only the last three.", "solution": "def op_padto3_takewhilepos_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_takewhilepos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_takewhilepos_last3([]) == []\nassert op_padto3_takewhilepos_last3([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_last3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos_last3([10]) == [10]\nassert op_padto3_takewhilepos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_last3([-7, 12, -7]) == []"}
{"id": "op_first3_double_rev", "entry_point": "op_first3_double_rev", "primitives": ["first3", "double", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then reverse the order.", "solution": "def op_first3_double_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_double_rev([1, 2, 3, 4]) == [6, 4, 2]\nassert op_first3_double_rev([]) == []\nassert op_first3_double_rev([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_first3_double_rev([5, 5, 5]) == [10, 10, 10]\nassert op_first3_double_rev([3, 1, 2]) == [4, 2, 6]\nassert op_first3_double_rev([10]) == [20]\nassert op_first3_double_rev([2, 4, 6]) == [12, 8, 4]\nassert op_first3_double_rev([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_trimends_padto3_uniq", "entry_point": "op_trimends_padto3_uniq", "primitives": ["trimends", "padto3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_trimends_padto3_uniq(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_trimends_padto3_uniq([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_padto3_uniq([]) == [0]\nassert op_trimends_padto3_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_padto3_uniq([5, 5, 5]) == [5, 0]\nassert op_trimends_padto3_uniq([3, 1, 2]) == [1, 0]\nassert op_trimends_padto3_uniq([10]) == [0]\nassert op_trimends_padto3_uniq([2, 4, 6]) == [4, 0]\nassert op_trimends_padto3_uniq([-7, 12, -7]) == [12, 0]"}
{"id": "op_neg_dec_rev", "entry_point": "op_neg_dec_rev", "primitives": ["neg", "dec", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then reverse the order.", "solution": "def op_neg_dec_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_neg_dec_rev([1, 2, 3, 4]) == []\nassert op_neg_dec_rev([]) == []\nassert op_neg_dec_rev([-2, -1, 0, 1, 2]) == [-2, -3]\nassert op_neg_dec_rev([5, 5, 5]) == []\nassert op_neg_dec_rev([3, 1, 2]) == []\nassert op_neg_dec_rev([10]) == []\nassert op_neg_dec_rev([2, 4, 6]) == []\nassert op_neg_dec_rev([-7, 12, -7]) == [-8, -8]"}
{"id": "op_div3_dropzeros_absval", "entry_point": "op_div3_dropzeros_absval", "primitives": ["div3", "dropzeros", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros, then take the absolute value of each.", "solution": "def op_div3_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_dropzeros_absval([1, 2, 3, 4]) == [3]\nassert op_div3_dropzeros_absval([]) == []\nassert op_div3_dropzeros_absval([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros_absval([5, 5, 5]) == []\nassert op_div3_dropzeros_absval([3, 1, 2]) == [3]\nassert op_div3_dropzeros_absval([10]) == []\nassert op_div3_dropzeros_absval([2, 4, 6]) == [6]\nassert op_div3_dropzeros_absval([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_dropwhileneg_counteven", "entry_point": "op_takewhilepos_dropwhileneg_counteven", "primitives": ["takewhilepos", "dropwhileneg", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then return how many values are even.", "solution": "def op_takewhilepos_dropwhileneg_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_dropwhileneg_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_dropwhileneg_counteven([]) == 0\nassert op_takewhilepos_dropwhileneg_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropwhileneg_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_dropwhileneg_counteven([3, 1, 2]) == 1\nassert op_takewhilepos_dropwhileneg_counteven([10]) == 1\nassert op_takewhilepos_dropwhileneg_counteven([2, 4, 6]) == 3\nassert op_takewhilepos_dropwhileneg_counteven([-7, 12, -7]) == 0"}
{"id": "op_dec_add10_odds", "entry_point": "op_dec_add10_odds", "primitives": ["dec", "add10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then keep the odd numbers.", "solution": "def op_dec_add10_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_add10_odds([1, 2, 3, 4]) == [11, 13]\nassert op_dec_add10_odds([]) == []\nassert op_dec_add10_odds([-2, -1, 0, 1, 2]) == [7, 9, 11]\nassert op_dec_add10_odds([5, 5, 5]) == []\nassert op_dec_add10_odds([3, 1, 2]) == [11]\nassert op_dec_add10_odds([10]) == [19]\nassert op_dec_add10_odds([2, 4, 6]) == [11, 13, 15]\nassert op_dec_add10_odds([-7, 12, -7]) == [21]"}
{"id": "op_ages_dec_prod", "entry_point": "op_ages_dec_prod", "primitives": ["ages", "dec", "prod"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then return their product.", "solution": "def op_ages_dec_prod(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_ages_dec_prod([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 385\nassert op_ages_dec_prod([]) == 1\nassert op_ages_dec_prod([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17408\nassert op_ages_dec_prod([{'name': 'Fi', 'age': 41}]) == 40"}
{"id": "op_clamp10_absval_double", "entry_point": "op_clamp10_absval_double", "primitives": ["clamp10", "absval", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then double each.", "solution": "def op_clamp10_absval_double(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_clamp10_absval_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_clamp10_absval_double([]) == []\nassert op_clamp10_absval_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_clamp10_absval_double([5, 5, 5]) == [10, 10, 10]\nassert op_clamp10_absval_double([3, 1, 2]) == [6, 2, 4]\nassert op_clamp10_absval_double([10]) == [20]\nassert op_clamp10_absval_double([2, 4, 6]) == [4, 8, 12]\nassert op_clamp10_absval_double([-7, 12, -7]) == [14, 20, 14]"}
{"id": "op_beforezero_div3_absval", "entry_point": "op_beforezero_div3_absval", "primitives": ["beforezero", "div3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three, then take the absolute value of each.", "solution": "def op_beforezero_div3_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_div3_absval([1, 2, 3, 4]) == [3]\nassert op_beforezero_div3_absval([]) == []\nassert op_beforezero_div3_absval([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_div3_absval([5, 5, 5]) == []\nassert op_beforezero_div3_absval([3, 1, 2]) == [3]\nassert op_beforezero_div3_absval([10]) == []\nassert op_beforezero_div3_absval([2, 4, 6]) == [6]\nassert op_beforezero_div3_absval([-7, 12, -7]) == [12]"}
{"id": "op_inc_sortabs_gt5", "entry_point": "op_inc_sortabs_gt5", "primitives": ["inc", "sortabs", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then keep values greater than five.", "solution": "def op_inc_sortabs_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_sortabs_gt5([1, 2, 3, 4]) == []\nassert op_inc_sortabs_gt5([]) == []\nassert op_inc_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_sortabs_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortabs_gt5([3, 1, 2]) == []\nassert op_inc_sortabs_gt5([10]) == [11]\nassert op_inc_sortabs_gt5([2, 4, 6]) == [7]\nassert op_inc_sortabs_gt5([-7, 12, -7]) == [13]"}
{"id": "op_uniq_div3_firsteven", "entry_point": "op_uniq_div3_firsteven", "primitives": ["uniq", "div3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then return the first even value (0 if none).", "solution": "def op_uniq_div3_firsteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_uniq_div3_firsteven([1, 2, 3, 4]) == 0\nassert op_uniq_div3_firsteven([]) == 0\nassert op_uniq_div3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_div3_firsteven([5, 5, 5]) == 0\nassert op_uniq_div3_firsteven([3, 1, 2]) == 0\nassert op_uniq_div3_firsteven([10]) == 0\nassert op_uniq_div3_firsteven([2, 4, 6]) == 6\nassert op_uniq_div3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_div3_gt5_absval", "entry_point": "op_div3_gt5_absval", "primitives": ["div3", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then take the absolute value of each.", "solution": "def op_div3_gt5_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_gt5_absval([1, 2, 3, 4]) == []\nassert op_div3_gt5_absval([]) == []\nassert op_div3_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_absval([5, 5, 5]) == []\nassert op_div3_gt5_absval([3, 1, 2]) == []\nassert op_div3_gt5_absval([10]) == []\nassert op_div3_gt5_absval([2, 4, 6]) == [6]\nassert op_div3_gt5_absval([-7, 12, -7]) == [12]"}
{"id": "op_negate_takewhilepos_dropzeros", "entry_point": "op_negate_takewhilepos_dropzeros", "primitives": ["negate", "takewhilepos", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then drop the zeros.", "solution": "def op_negate_takewhilepos_dropzeros(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_negate_takewhilepos_dropzeros([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos_dropzeros([]) == []\nassert op_negate_takewhilepos_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_takewhilepos_dropzeros([5, 5, 5]) == []\nassert op_negate_takewhilepos_dropzeros([3, 1, 2]) == []\nassert op_negate_takewhilepos_dropzeros([10]) == []\nassert op_negate_takewhilepos_dropzeros([2, 4, 6]) == []\nassert op_negate_takewhilepos_dropzeros([-7, 12, -7]) == [7]"}
{"id": "op_dropfirst_rev_dropzeros", "entry_point": "op_dropfirst_rev_dropzeros", "primitives": ["dropfirst", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then drop the zeros.", "solution": "def op_dropfirst_rev_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_rev_dropzeros([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev_dropzeros([]) == []\nassert op_dropfirst_rev_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_dropfirst_rev_dropzeros([5, 5, 5]) == [5, 5]\nassert op_dropfirst_rev_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev_dropzeros([10]) == []\nassert op_dropfirst_rev_dropzeros([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_last3_add10_evens", "entry_point": "op_last3_add10_evens", "primitives": ["last3", "add10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then keep the even numbers.", "solution": "def op_last3_add10_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_add10_evens([1, 2, 3, 4]) == [12, 14]\nassert op_last3_add10_evens([]) == []\nassert op_last3_add10_evens([-2, -1, 0, 1, 2]) == [10, 12]\nassert op_last3_add10_evens([5, 5, 5]) == []\nassert op_last3_add10_evens([3, 1, 2]) == [12]\nassert op_last3_add10_evens([10]) == [20]\nassert op_last3_add10_evens([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_evens([-7, 12, -7]) == [22]"}
{"id": "op_last3_clamp10_anyeven", "entry_point": "op_last3_clamp10_anyeven", "primitives": ["last3", "clamp10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then return whether any value is even.", "solution": "def op_last3_clamp10_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_clamp10_anyeven([1, 2, 3, 4]) == True\nassert op_last3_clamp10_anyeven([]) == False\nassert op_last3_clamp10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_clamp10_anyeven([5, 5, 5]) == False\nassert op_last3_clamp10_anyeven([3, 1, 2]) == True\nassert op_last3_clamp10_anyeven([10]) == True\nassert op_last3_clamp10_anyeven([2, 4, 6]) == True\nassert op_last3_clamp10_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_sortd_double", "entry_point": "op_absval_sortd_double", "primitives": ["absval", "sortd", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then double each.", "solution": "def op_absval_sortd_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_sortd_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_absval_sortd_double([]) == []\nassert op_absval_sortd_double([-2, -1, 0, 1, 2]) == [4, 4, 2, 2, 0]\nassert op_absval_sortd_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_sortd_double([3, 1, 2]) == [6, 4, 2]\nassert op_absval_sortd_double([10]) == [20]\nassert op_absval_sortd_double([2, 4, 6]) == [12, 8, 4]\nassert op_absval_sortd_double([-7, 12, -7]) == [24, 14, 14]"}
{"id": "op_dropfirst_padto3_haszero", "entry_point": "op_dropfirst_padto3_haszero", "primitives": ["dropfirst", "padto3", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then return whether the list contains a zero.", "solution": "def op_dropfirst_padto3_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return 0 in r", "tests": "assert op_dropfirst_padto3_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_padto3_haszero([]) == True\nassert op_dropfirst_padto3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_padto3_haszero([5, 5, 5]) == True\nassert op_dropfirst_padto3_haszero([3, 1, 2]) == True\nassert op_dropfirst_padto3_haszero([10]) == True\nassert op_dropfirst_padto3_haszero([2, 4, 6]) == True\nassert op_dropfirst_padto3_haszero([-7, 12, -7]) == True"}
{"id": "op_last3_add10_sortabs", "entry_point": "op_last3_add10_sortabs", "primitives": ["last3", "add10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then sort by absolute value.", "solution": "def op_last3_add10_sortabs(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_last3_add10_sortabs([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10_sortabs([]) == []\nassert op_last3_add10_sortabs([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_last3_add10_sortabs([10]) == [20]\nassert op_last3_add10_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_dec_first3_sorta", "entry_point": "op_dec_first3_sorta", "primitives": ["dec", "first3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then sort ascending.", "solution": "def op_dec_first3_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_first3_sorta([1, 2, 3, 4]) == [0, 1, 2]\nassert op_dec_first3_sorta([]) == []\nassert op_dec_first3_sorta([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_first3_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3_sorta([3, 1, 2]) == [0, 1, 2]\nassert op_dec_first3_sorta([10]) == [9]\nassert op_dec_first3_sorta([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3_sorta([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_dropwhileneg_square_gt5", "entry_point": "op_dropwhileneg_square_gt5", "primitives": ["dropwhileneg", "square", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then keep values greater than five.", "solution": "def op_dropwhileneg_square_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_square_gt5([1, 2, 3, 4]) == [9, 16]\nassert op_dropwhileneg_square_gt5([]) == []\nassert op_dropwhileneg_square_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_square_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_square_gt5([3, 1, 2]) == [9]\nassert op_dropwhileneg_square_gt5([10]) == [100]\nassert op_dropwhileneg_square_gt5([2, 4, 6]) == [16, 36]\nassert op_dropwhileneg_square_gt5([-7, 12, -7]) == [144, 49]"}
{"id": "op_sortlen_upper_lens", "entry_point": "op_sortlen_upper_lens", "primitives": ["sortlen", "upper", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then uppercase each string, then return the total number of characters.", "solution": "def op_sortlen_upper_lens(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_sortlen_upper_lens(['Hello', 'world']) == 10\nassert op_sortlen_upper_lens([]) == 0\nassert op_sortlen_upper_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_sortlen_upper_lens(['one', 'one', 'Two']) == 9\nassert op_sortlen_upper_lens(['x']) == 1\nassert op_sortlen_upper_lens(['abc', 'de', '']) == 5"}
{"id": "op_add10_trimends_square", "entry_point": "op_add10_trimends_square", "primitives": ["add10", "trimends", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then square each.", "solution": "def op_add10_trimends_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_trimends_square([1, 2, 3, 4]) == [144, 169]\nassert op_add10_trimends_square([]) == []\nassert op_add10_trimends_square([-2, -1, 0, 1, 2]) == [81, 100, 121]\nassert op_add10_trimends_square([5, 5, 5]) == [225]\nassert op_add10_trimends_square([3, 1, 2]) == [121]\nassert op_add10_trimends_square([10]) == []\nassert op_add10_trimends_square([2, 4, 6]) == [196]\nassert op_add10_trimends_square([-7, 12, -7]) == [484]"}
{"id": "op_strip_prefixup_sortalpha", "entry_point": "op_strip_prefixup_sortalpha", "primitives": ["strip", "prefixup", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash, then sort alphabetically.", "solution": "def op_strip_prefixup_sortalpha(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_strip_prefixup_sortalpha(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_prefixup_sortalpha([]) == []\nassert op_strip_prefixup_sortalpha(['  a ', '', 'BC', 'bc']) == ['#', '#BC', '#a', '#bc']\nassert op_strip_prefixup_sortalpha(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_strip_prefixup_sortalpha(['x']) == ['#x']\nassert op_strip_prefixup_sortalpha(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_pos_last3_inc", "entry_point": "op_pos_last3_inc", "primitives": ["pos", "last3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then add one to each.", "solution": "def op_pos_last3_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_pos_last3_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_pos_last3_inc([]) == []\nassert op_pos_last3_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_pos_last3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_pos_last3_inc([3, 1, 2]) == [4, 2, 3]\nassert op_pos_last3_inc([10]) == [11]\nassert op_pos_last3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_pos_last3_inc([-7, 12, -7]) == [13]"}
{"id": "op_pos_dropwhileneg_uniq", "entry_point": "op_pos_dropwhileneg_uniq", "primitives": ["pos", "dropwhileneg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_pos_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_dropwhileneg_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_dropwhileneg_uniq([]) == []\nassert op_pos_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_dropwhileneg_uniq([5, 5, 5]) == [5]\nassert op_pos_dropwhileneg_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_pos_dropwhileneg_uniq([10]) == [10]\nassert op_pos_dropwhileneg_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_pos_dropwhileneg_uniq([-7, 12, -7]) == [12]"}
{"id": "op_gt5_beforezero_oremptyzero", "entry_point": "op_gt5_beforezero_oremptyzero", "primitives": ["gt5", "beforezero", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_gt5_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_beforezero_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_beforezero_oremptyzero([]) == [0]\nassert op_gt5_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_beforezero_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_beforezero_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_beforezero_oremptyzero([10]) == [10]\nassert op_gt5_beforezero_oremptyzero([2, 4, 6]) == [6]\nassert op_gt5_beforezero_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_names_prefixup_counts", "entry_point": "op_names_prefixup_counts", "primitives": ["names", "prefixup", "counts"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then prefix each with a hash, then return how many strings remain.", "solution": "def op_names_prefixup_counts(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = ['#' + s for s in r]\n    return len(r)", "tests": "assert op_names_prefixup_counts([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_names_prefixup_counts([]) == 0\nassert op_names_prefixup_counts([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_names_prefixup_counts([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_neg_absval_pos", "entry_point": "op_neg_absval_pos", "primitives": ["neg", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_neg_absval_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_neg_absval_pos([1, 2, 3, 4]) == []\nassert op_neg_absval_pos([]) == []\nassert op_neg_absval_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_absval_pos([5, 5, 5]) == []\nassert op_neg_absval_pos([3, 1, 2]) == []\nassert op_neg_absval_pos([10]) == []\nassert op_neg_absval_pos([2, 4, 6]) == []\nassert op_neg_absval_pos([-7, 12, -7]) == [7, 7]"}
{"id": "op_gt5_beforezero_square", "entry_point": "op_gt5_beforezero_square", "primitives": ["gt5", "beforezero", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then square each.", "solution": "def op_gt5_beforezero_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_beforezero_square([1, 2, 3, 4]) == []\nassert op_gt5_beforezero_square([]) == []\nassert op_gt5_beforezero_square([-2, -1, 0, 1, 2]) == []\nassert op_gt5_beforezero_square([5, 5, 5]) == []\nassert op_gt5_beforezero_square([3, 1, 2]) == []\nassert op_gt5_beforezero_square([10]) == [100]\nassert op_gt5_beforezero_square([2, 4, 6]) == [36]\nassert op_gt5_beforezero_square([-7, 12, -7]) == [144]"}
{"id": "op_beforezero_oremptyzero_pos", "entry_point": "op_beforezero_oremptyzero_pos", "primitives": ["beforezero", "oremptyzero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_beforezero_oremptyzero_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_oremptyzero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_oremptyzero_pos([]) == []\nassert op_beforezero_oremptyzero_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_oremptyzero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_oremptyzero_pos([10]) == [10]\nassert op_beforezero_oremptyzero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_clamp10_uniq", "entry_point": "op_oremptyzero_clamp10_uniq", "primitives": ["oremptyzero", "clamp10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_clamp10_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_clamp10_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_clamp10_uniq([]) == [0]\nassert op_oremptyzero_clamp10_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_clamp10_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_clamp10_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_clamp10_uniq([10]) == [10]\nassert op_oremptyzero_clamp10_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_clamp10_rev_alldistinct", "entry_point": "op_clamp10_rev_alldistinct", "primitives": ["clamp10", "rev", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then return whether all values are distinct.", "solution": "def op_clamp10_rev_alldistinct(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_clamp10_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_clamp10_rev_alldistinct([]) == True\nassert op_clamp10_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_rev_alldistinct([5, 5, 5]) == False\nassert op_clamp10_rev_alldistinct([3, 1, 2]) == True\nassert op_clamp10_rev_alldistinct([10]) == True\nassert op_clamp10_rev_alldistinct([2, 4, 6]) == True\nassert op_clamp10_rev_alldistinct([-7, 12, -7]) == False"}
{"id": "op_trimends_inc_len", "entry_point": "op_trimends_inc_len", "primitives": ["trimends", "inc", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then return how many remain.", "solution": "def op_trimends_inc_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return len(r)", "tests": "assert op_trimends_inc_len([1, 2, 3, 4]) == 2\nassert op_trimends_inc_len([]) == 0\nassert op_trimends_inc_len([-2, -1, 0, 1, 2]) == 3\nassert op_trimends_inc_len([5, 5, 5]) == 1\nassert op_trimends_inc_len([3, 1, 2]) == 1\nassert op_trimends_inc_len([10]) == 0\nassert op_trimends_inc_len([2, 4, 6]) == 1\nassert op_trimends_inc_len([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_rev_evens", "entry_point": "op_dropfirst_rev_evens", "primitives": ["dropfirst", "rev", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then keep the even numbers.", "solution": "def op_dropfirst_rev_evens(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropfirst_rev_evens([1, 2, 3, 4]) == [4, 2]\nassert op_dropfirst_rev_evens([]) == []\nassert op_dropfirst_rev_evens([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dropfirst_rev_evens([5, 5, 5]) == []\nassert op_dropfirst_rev_evens([3, 1, 2]) == [2]\nassert op_dropfirst_rev_evens([10]) == []\nassert op_dropfirst_rev_evens([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_evens([-7, 12, -7]) == [12]"}
{"id": "op_dec_evens_absval", "entry_point": "op_dec_evens_absval", "primitives": ["dec", "evens", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then take the absolute value of each.", "solution": "def op_dec_evens_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_evens_absval([1, 2, 3, 4]) == [0, 2]\nassert op_dec_evens_absval([]) == []\nassert op_dec_evens_absval([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dec_evens_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_evens_absval([3, 1, 2]) == [2, 0]\nassert op_dec_evens_absval([10]) == []\nassert op_dec_evens_absval([2, 4, 6]) == []\nassert op_dec_evens_absval([-7, 12, -7]) == [8, 8]"}
{"id": "op_clamp10_trimends_square", "entry_point": "op_clamp10_trimends_square", "primitives": ["clamp10", "trimends", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then square each.", "solution": "def op_clamp10_trimends_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_trimends_square([1, 2, 3, 4]) == [4, 9]\nassert op_clamp10_trimends_square([]) == []\nassert op_clamp10_trimends_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_clamp10_trimends_square([5, 5, 5]) == [25]\nassert op_clamp10_trimends_square([3, 1, 2]) == [1]\nassert op_clamp10_trimends_square([10]) == []\nassert op_clamp10_trimends_square([2, 4, 6]) == [16]\nassert op_clamp10_trimends_square([-7, 12, -7]) == [100]"}
{"id": "op_names_nonempty_longest", "entry_point": "op_names_nonempty_longest", "primitives": ["names", "nonempty", "longest"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop empty strings, then return the longest string (empty if none).", "solution": "def op_names_nonempty_longest(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_names_nonempty_longest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada'\nassert op_names_nonempty_longest([]) == ''\nassert op_names_nonempty_longest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Dee'\nassert op_names_nonempty_longest([{'name': 'Fi', 'age': 41}]) == 'Fi'"}
{"id": "op_absval_uniq_inc", "entry_point": "op_absval_uniq_inc", "primitives": ["absval", "uniq", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_absval_uniq_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_uniq_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_uniq_inc([]) == []\nassert op_absval_uniq_inc([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_absval_uniq_inc([5, 5, 5]) == [6]\nassert op_absval_uniq_inc([3, 1, 2]) == [4, 2, 3]\nassert op_absval_uniq_inc([10]) == [11]\nassert op_absval_uniq_inc([2, 4, 6]) == [3, 5, 7]\nassert op_absval_uniq_inc([-7, 12, -7]) == [8, 13]"}
{"id": "op_absval_last3_alldistinct", "entry_point": "op_absval_last3_alldistinct", "primitives": ["absval", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then return whether all values are distinct.", "solution": "def op_absval_last3_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_absval_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_last3_alldistinct([]) == True\nassert op_absval_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_absval_last3_alldistinct([5, 5, 5]) == False\nassert op_absval_last3_alldistinct([3, 1, 2]) == True\nassert op_absval_last3_alldistinct([10]) == True\nassert op_absval_last3_alldistinct([2, 4, 6]) == True\nassert op_absval_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sortage_ages_square", "entry_point": "op_sortage_ages_square", "primitives": ["sortage", "ages", "square"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then square each.", "solution": "def op_sortage_ages_square(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortage_ages_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [144, 1296]\nassert op_sortage_ages_square([]) == []\nassert op_sortage_ages_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [289, 324, 4225]\nassert op_sortage_ages_square([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_sortalpha_dropshort_lens", "entry_point": "op_sortalpha_dropshort_lens", "primitives": ["sortalpha", "dropshort", "lens"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters, then return the total number of characters.", "solution": "def op_sortalpha_dropshort_lens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    return sum(len(s) for s in r)", "tests": "assert op_sortalpha_dropshort_lens(['Hello', 'world']) == 10\nassert op_sortalpha_dropshort_lens([]) == 0\nassert op_sortalpha_dropshort_lens(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_dropshort_lens(['one', 'one', 'Two']) == 9\nassert op_sortalpha_dropshort_lens(['x']) == 0\nassert op_sortalpha_dropshort_lens(['abc', 'de', '']) == 3"}
{"id": "op_square_sorta_anyeven", "entry_point": "op_square_sorta_anyeven", "primitives": ["square", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then return whether any value is even.", "solution": "def op_square_sorta_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_square_sorta_anyeven([]) == False\nassert op_square_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_sorta_anyeven([5, 5, 5]) == False\nassert op_square_sorta_anyeven([3, 1, 2]) == True\nassert op_square_sorta_anyeven([10]) == True\nassert op_square_sorta_anyeven([2, 4, 6]) == True\nassert op_square_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_beforezero_dropzeros", "entry_point": "op_sorta_beforezero_dropzeros", "primitives": ["sorta", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then drop the zeros.", "solution": "def op_sorta_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_beforezero_dropzeros([]) == []\nassert op_sorta_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_beforezero_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_beforezero_dropzeros([10]) == [10]\nassert op_sorta_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_beforezero_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropfirst_evens_pos", "entry_point": "op_dropfirst_evens_pos", "primitives": ["dropfirst", "evens", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then keep the positive numbers.", "solution": "def op_dropfirst_evens_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_evens_pos([1, 2, 3, 4]) == [2, 4]\nassert op_dropfirst_evens_pos([]) == []\nassert op_dropfirst_evens_pos([-2, -1, 0, 1, 2]) == [2]\nassert op_dropfirst_evens_pos([5, 5, 5]) == []\nassert op_dropfirst_evens_pos([3, 1, 2]) == [2]\nassert op_dropfirst_evens_pos([10]) == []\nassert op_dropfirst_evens_pos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_evens_pos([-7, 12, -7]) == [12]"}
{"id": "op_padto3_add10_anyeven", "entry_point": "op_padto3_add10_anyeven", "primitives": ["padto3", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then return whether any value is even.", "solution": "def op_padto3_add10_anyeven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_padto3_add10_anyeven([1, 2, 3, 4]) == True\nassert op_padto3_add10_anyeven([]) == True\nassert op_padto3_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_padto3_add10_anyeven([5, 5, 5]) == False\nassert op_padto3_add10_anyeven([3, 1, 2]) == True\nassert op_padto3_add10_anyeven([10]) == True\nassert op_padto3_add10_anyeven([2, 4, 6]) == True\nassert op_padto3_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortlen_upper_firstchar", "entry_point": "op_sortlen_upper_firstchar", "primitives": ["sortlen", "upper", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then uppercase each string, then keep the first character of each (dropping empties).", "solution": "def op_sortlen_upper_firstchar(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortlen_upper_firstchar(['Hello', 'world']) == ['H', 'W']\nassert op_sortlen_upper_firstchar([]) == []\nassert op_sortlen_upper_firstchar(['  a ', '', 'BC', 'bc']) == ['B', 'B', ' ']\nassert op_sortlen_upper_firstchar(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_sortlen_upper_firstchar(['x']) == ['X']\nassert op_sortlen_upper_firstchar(['abc', 'de', '']) == ['D', 'A']"}
{"id": "op_negate_sortabs_square", "entry_point": "op_negate_sortabs_square", "primitives": ["negate", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort by absolute value, then square each.", "solution": "def op_negate_sortabs_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_sortabs_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_sortabs_square([]) == []\nassert op_negate_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_negate_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_negate_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_negate_sortabs_square([10]) == [100]\nassert op_negate_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_negate_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_beforezero_pos_sum", "entry_point": "op_beforezero_pos_sum", "primitives": ["beforezero", "pos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then return their sum.", "solution": "def op_beforezero_pos_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return sum(r)", "tests": "assert op_beforezero_pos_sum([1, 2, 3, 4]) == 10\nassert op_beforezero_pos_sum([]) == 0\nassert op_beforezero_pos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_pos_sum([5, 5, 5]) == 15\nassert op_beforezero_pos_sum([3, 1, 2]) == 6\nassert op_beforezero_pos_sum([10]) == 10\nassert op_beforezero_pos_sum([2, 4, 6]) == 12\nassert op_beforezero_pos_sum([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_pos_allpos", "entry_point": "op_takewhilepos_pos_allpos", "primitives": ["takewhilepos", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_takewhilepos_pos_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_pos_allpos([1, 2, 3, 4]) == True\nassert op_takewhilepos_pos_allpos([]) == True\nassert op_takewhilepos_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_pos_allpos([5, 5, 5]) == True\nassert op_takewhilepos_pos_allpos([3, 1, 2]) == True\nassert op_takewhilepos_pos_allpos([10]) == True\nassert op_takewhilepos_pos_allpos([2, 4, 6]) == True\nassert op_takewhilepos_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_double_dec_padto3", "entry_point": "op_double_dec_padto3", "primitives": ["double", "dec", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_double_dec_padto3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_double_dec_padto3([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_double_dec_padto3([]) == [0, 0, 0]\nassert op_double_dec_padto3([-2, -1, 0, 1, 2]) == [-5, -3, -1, 1, 3]\nassert op_double_dec_padto3([5, 5, 5]) == [9, 9, 9]\nassert op_double_dec_padto3([3, 1, 2]) == [5, 1, 3]\nassert op_double_dec_padto3([10]) == [19, 0, 0]\nassert op_double_dec_padto3([2, 4, 6]) == [3, 7, 11]\nassert op_double_dec_padto3([-7, 12, -7]) == [-15, 23, -15]"}
{"id": "op_trimends_clamp10_firsteven", "entry_point": "op_trimends_clamp10_firsteven", "primitives": ["trimends", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_trimends_clamp10_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_trimends_clamp10_firsteven([]) == 0\nassert op_trimends_clamp10_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_clamp10_firsteven([5, 5, 5]) == 0\nassert op_trimends_clamp10_firsteven([3, 1, 2]) == 0\nassert op_trimends_clamp10_firsteven([10]) == 0\nassert op_trimends_clamp10_firsteven([2, 4, 6]) == 4\nassert op_trimends_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_last3_first3_square", "entry_point": "op_last3_first3_square", "primitives": ["last3", "first3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then square each.", "solution": "def op_last3_first3_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_first3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_first3_square([]) == []\nassert op_last3_first3_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_last3_first3_square([5, 5, 5]) == [25, 25, 25]\nassert op_last3_first3_square([3, 1, 2]) == [9, 1, 4]\nassert op_last3_first3_square([10]) == [100]\nassert op_last3_first3_square([2, 4, 6]) == [4, 16, 36]\nassert op_last3_first3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_names_firstchar_longest", "entry_point": "op_names_firstchar_longest", "primitives": ["names", "firstchar", "longest"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_names_firstchar_longest(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_names_firstchar_longest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'A'\nassert op_names_firstchar_longest([]) == ''\nassert op_names_firstchar_longest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'C'\nassert op_names_firstchar_longest([{'name': 'Fi', 'age': 41}]) == 'F'"}
{"id": "op_gt5_clamp10_trimends", "entry_point": "op_gt5_clamp10_trimends", "primitives": ["gt5", "clamp10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then drop the first and last elements.", "solution": "def op_gt5_clamp10_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_clamp10_trimends([1, 2, 3, 4]) == []\nassert op_gt5_clamp10_trimends([]) == []\nassert op_gt5_clamp10_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_clamp10_trimends([5, 5, 5]) == []\nassert op_gt5_clamp10_trimends([3, 1, 2]) == []\nassert op_gt5_clamp10_trimends([10]) == []\nassert op_gt5_clamp10_trimends([2, 4, 6]) == []\nassert op_gt5_clamp10_trimends([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_rev_double", "entry_point": "op_takewhilepos_rev_double", "primitives": ["takewhilepos", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then reverse the order, then double each.", "solution": "def op_takewhilepos_rev_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_takewhilepos_rev_double([]) == []\nassert op_takewhilepos_rev_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_takewhilepos_rev_double([10]) == [20]\nassert op_takewhilepos_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_takewhilepos_rev_double([-7, 12, -7]) == []"}
{"id": "op_div3_square_neg", "entry_point": "op_div3_square_neg", "primitives": ["div3", "square", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then keep the negative numbers.", "solution": "def op_div3_square_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_div3_square_neg([1, 2, 3, 4]) == []\nassert op_div3_square_neg([]) == []\nassert op_div3_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_div3_square_neg([5, 5, 5]) == []\nassert op_div3_square_neg([3, 1, 2]) == []\nassert op_div3_square_neg([10]) == []\nassert op_div3_square_neg([2, 4, 6]) == []\nassert op_div3_square_neg([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_dropwhileneg_max", "entry_point": "op_oremptyzero_dropwhileneg_max", "primitives": ["oremptyzero", "dropwhileneg", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_oremptyzero_dropwhileneg_max(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_oremptyzero_dropwhileneg_max([1, 2, 3, 4]) == 4\nassert op_oremptyzero_dropwhileneg_max([]) == 0\nassert op_oremptyzero_dropwhileneg_max([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_dropwhileneg_max([5, 5, 5]) == 5\nassert op_oremptyzero_dropwhileneg_max([3, 1, 2]) == 3\nassert op_oremptyzero_dropwhileneg_max([10]) == 10\nassert op_oremptyzero_dropwhileneg_max([2, 4, 6]) == 6\nassert op_oremptyzero_dropwhileneg_max([-7, 12, -7]) == 12"}
{"id": "op_uniq_sortabs_sortd", "entry_point": "op_uniq_sortabs_sortd", "primitives": ["uniq", "sortabs", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value, then sort descending.", "solution": "def op_uniq_sortabs_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_sortabs_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_sortabs_sortd([]) == []\nassert op_uniq_sortabs_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_sortabs_sortd([5, 5, 5]) == [5]\nassert op_uniq_sortabs_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_sortabs_sortd([10]) == [10]\nassert op_uniq_sortabs_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_sortabs_sortd([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_odds_oremptyzero", "entry_point": "op_dropfirst_odds_oremptyzero", "primitives": ["dropfirst", "odds", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the odd numbers, then if empty, use a single zero.", "solution": "def op_dropfirst_odds_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_odds_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_dropfirst_odds_oremptyzero([]) == [0]\nassert op_dropfirst_odds_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_odds_oremptyzero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_odds_oremptyzero([3, 1, 2]) == [1]\nassert op_dropfirst_odds_oremptyzero([10]) == [0]\nassert op_dropfirst_odds_oremptyzero([2, 4, 6]) == [0]\nassert op_dropfirst_odds_oremptyzero([-7, 12, -7]) == [-7]"}
{"id": "op_negate_oremptyzero_haszero", "entry_point": "op_negate_oremptyzero_haszero", "primitives": ["negate", "oremptyzero", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_negate_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_negate_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_negate_oremptyzero_haszero([]) == True\nassert op_negate_oremptyzero_haszero([-2, -1, 0, 1, 2]) == True\nassert op_negate_oremptyzero_haszero([5, 5, 5]) == False\nassert op_negate_oremptyzero_haszero([3, 1, 2]) == False\nassert op_negate_oremptyzero_haszero([10]) == False\nassert op_negate_oremptyzero_haszero([2, 4, 6]) == False\nassert op_negate_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_first3_len", "entry_point": "op_odds_first3_len", "primitives": ["odds", "first3", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three, then return how many remain.", "solution": "def op_odds_first3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    return len(r)", "tests": "assert op_odds_first3_len([1, 2, 3, 4]) == 2\nassert op_odds_first3_len([]) == 0\nassert op_odds_first3_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_first3_len([5, 5, 5]) == 3\nassert op_odds_first3_len([3, 1, 2]) == 2\nassert op_odds_first3_len([10]) == 0\nassert op_odds_first3_len([2, 4, 6]) == 0\nassert op_odds_first3_len([-7, 12, -7]) == 2"}
{"id": "op_ages_sorta_last3", "entry_point": "op_ages_sorta_last3", "primitives": ["ages", "sorta", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then keep only the last three.", "solution": "def op_ages_sorta_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    r = r[-3:]\n    return r", "tests": "assert op_ages_sorta_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sorta_last3([]) == []\nassert op_ages_sorta_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sorta_last3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_square_uniq_beforezero", "entry_point": "op_square_uniq_beforezero", "primitives": ["square", "uniq", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then keep everything before the first zero.", "solution": "def op_square_uniq_beforezero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_square_uniq_beforezero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_uniq_beforezero([]) == []\nassert op_square_uniq_beforezero([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_uniq_beforezero([5, 5, 5]) == [25]\nassert op_square_uniq_beforezero([3, 1, 2]) == [9, 1, 4]\nassert op_square_uniq_beforezero([10]) == [100]\nassert op_square_uniq_beforezero([2, 4, 6]) == [4, 16, 36]\nassert op_square_uniq_beforezero([-7, 12, -7]) == [49, 144]"}
{"id": "op_padto3_first3_dropfirst", "entry_point": "op_padto3_first3_dropfirst", "primitives": ["padto3", "first3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then drop the first element.", "solution": "def op_padto3_first3_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_first3_dropfirst([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_first3_dropfirst([]) == [0, 0]\nassert op_padto3_first3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_padto3_first3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_first3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_padto3_first3_dropfirst([10]) == [0, 0]\nassert op_padto3_first3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_first3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_oremptyzero_sortabs_odds", "entry_point": "op_oremptyzero_sortabs_odds", "primitives": ["oremptyzero", "sortabs", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then keep the odd numbers.", "solution": "def op_oremptyzero_sortabs_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_sortabs_odds([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_sortabs_odds([]) == []\nassert op_oremptyzero_sortabs_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_sortabs_odds([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortabs_odds([3, 1, 2]) == [1, 3]\nassert op_oremptyzero_sortabs_odds([10]) == []\nassert op_oremptyzero_sortabs_odds([2, 4, 6]) == []\nassert op_oremptyzero_sortabs_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_beforezero_prod", "entry_point": "op_padto3_beforezero_prod", "primitives": ["padto3", "beforezero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then return their product.", "solution": "def op_padto3_beforezero_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_padto3_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_padto3_beforezero_prod([]) == 1\nassert op_padto3_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_beforezero_prod([5, 5, 5]) == 125\nassert op_padto3_beforezero_prod([3, 1, 2]) == 6\nassert op_padto3_beforezero_prod([10]) == 10\nassert op_padto3_beforezero_prod([2, 4, 6]) == 48\nassert op_padto3_beforezero_prod([-7, 12, -7]) == 588"}
{"id": "op_dec_neg_firsteven", "entry_point": "op_dec_neg_firsteven", "primitives": ["dec", "neg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then return the first even value (0 if none).", "solution": "def op_dec_neg_firsteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dec_neg_firsteven([1, 2, 3, 4]) == 0\nassert op_dec_neg_firsteven([]) == 0\nassert op_dec_neg_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dec_neg_firsteven([5, 5, 5]) == 0\nassert op_dec_neg_firsteven([3, 1, 2]) == 0\nassert op_dec_neg_firsteven([10]) == 0\nassert op_dec_neg_firsteven([2, 4, 6]) == 0\nassert op_dec_neg_firsteven([-7, 12, -7]) == -8"}
{"id": "op_rev_sortabs_alldistinct", "entry_point": "op_rev_sortabs_alldistinct", "primitives": ["rev", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_rev_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_rev_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_rev_sortabs_alldistinct([]) == True\nassert op_rev_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_rev_sortabs_alldistinct([5, 5, 5]) == False\nassert op_rev_sortabs_alldistinct([3, 1, 2]) == True\nassert op_rev_sortabs_alldistinct([10]) == True\nassert op_rev_sortabs_alldistinct([2, 4, 6]) == True\nassert op_rev_sortabs_alldistinct([-7, 12, -7]) == False"}
{"id": "op_padto3_trimends_last3", "entry_point": "op_padto3_trimends_last3", "primitives": ["padto3", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then keep only the last three.", "solution": "def op_padto3_trimends_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_trimends_last3([1, 2, 3, 4]) == [2, 3]\nassert op_padto3_trimends_last3([]) == [0]\nassert op_padto3_trimends_last3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_trimends_last3([5, 5, 5]) == [5]\nassert op_padto3_trimends_last3([3, 1, 2]) == [1]\nassert op_padto3_trimends_last3([10]) == [0]\nassert op_padto3_trimends_last3([2, 4, 6]) == [4]\nassert op_padto3_trimends_last3([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortabs_allpos", "entry_point": "op_rev_sortabs_allpos", "primitives": ["rev", "sortabs", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then return whether all values are positive.", "solution": "def op_rev_sortabs_allpos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_rev_sortabs_allpos([1, 2, 3, 4]) == True\nassert op_rev_sortabs_allpos([]) == True\nassert op_rev_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_rev_sortabs_allpos([5, 5, 5]) == True\nassert op_rev_sortabs_allpos([3, 1, 2]) == True\nassert op_rev_sortabs_allpos([10]) == True\nassert op_rev_sortabs_allpos([2, 4, 6]) == True\nassert op_rev_sortabs_allpos([-7, 12, -7]) == False"}
{"id": "op_square_first3_div3", "entry_point": "op_square_first3_div3", "primitives": ["square", "first3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then keep multiples of three.", "solution": "def op_square_first3_div3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_square_first3_div3([1, 2, 3, 4]) == [9]\nassert op_square_first3_div3([]) == []\nassert op_square_first3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_square_first3_div3([5, 5, 5]) == []\nassert op_square_first3_div3([3, 1, 2]) == [9]\nassert op_square_first3_div3([10]) == []\nassert op_square_first3_div3([2, 4, 6]) == [36]\nassert op_square_first3_div3([-7, 12, -7]) == [144]"}
{"id": "op_sorta_absval_padto3", "entry_point": "op_sorta_absval_padto3", "primitives": ["sorta", "absval", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_sorta_absval_padto3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sorta_absval_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_absval_padto3([]) == [0, 0, 0]\nassert op_sorta_absval_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_absval_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_absval_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_absval_padto3([10]) == [10, 0, 0]\nassert op_sorta_absval_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_absval_padto3([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_ages_dropfirst_uniq", "entry_point": "op_ages_dropfirst_uniq", "primitives": ["ages", "dropfirst", "uniq"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then drop duplicates keeping first occurrence.", "solution": "def op_ages_dropfirst_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_dropfirst_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst_uniq([]) == []\nassert op_ages_dropfirst_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropfirst_uniq([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_trimends_absval_dropzeros", "entry_point": "op_trimends_absval_dropzeros", "primitives": ["trimends", "absval", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then drop the zeros.", "solution": "def op_trimends_absval_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_absval_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_absval_dropzeros([]) == []\nassert op_trimends_absval_dropzeros([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_trimends_absval_dropzeros([5, 5, 5]) == [5]\nassert op_trimends_absval_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_absval_dropzeros([10]) == []\nassert op_trimends_absval_dropzeros([2, 4, 6]) == [4]\nassert op_trimends_absval_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_negate_dropwhileneg_trimends", "entry_point": "op_negate_dropwhileneg_trimends", "primitives": ["negate", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_negate_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_dropwhileneg_trimends([1, 2, 3, 4]) == []\nassert op_negate_dropwhileneg_trimends([]) == []\nassert op_negate_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_negate_dropwhileneg_trimends([5, 5, 5]) == []\nassert op_negate_dropwhileneg_trimends([3, 1, 2]) == []\nassert op_negate_dropwhileneg_trimends([10]) == []\nassert op_negate_dropwhileneg_trimends([2, 4, 6]) == []\nassert op_negate_dropwhileneg_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_inc_neg_first3", "entry_point": "op_inc_neg_first3", "primitives": ["inc", "neg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then keep only the first three.", "solution": "def op_inc_neg_first3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_inc_neg_first3([1, 2, 3, 4]) == []\nassert op_inc_neg_first3([]) == []\nassert op_inc_neg_first3([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_first3([5, 5, 5]) == []\nassert op_inc_neg_first3([3, 1, 2]) == []\nassert op_inc_neg_first3([10]) == []\nassert op_inc_neg_first3([2, 4, 6]) == []\nassert op_inc_neg_first3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_square_rev_firsteven", "entry_point": "op_square_rev_firsteven", "primitives": ["square", "rev", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then reverse the order, then return the first even value (0 if none).", "solution": "def op_square_rev_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_rev_firsteven([1, 2, 3, 4]) == 16\nassert op_square_rev_firsteven([]) == 0\nassert op_square_rev_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_square_rev_firsteven([5, 5, 5]) == 0\nassert op_square_rev_firsteven([3, 1, 2]) == 4\nassert op_square_rev_firsteven([10]) == 100\nassert op_square_rev_firsteven([2, 4, 6]) == 36\nassert op_square_rev_firsteven([-7, 12, -7]) == 144"}
{"id": "op_first3_rev_anyeven", "entry_point": "op_first3_rev_anyeven", "primitives": ["first3", "rev", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then return whether any value is even.", "solution": "def op_first3_rev_anyeven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_first3_rev_anyeven([1, 2, 3, 4]) == True\nassert op_first3_rev_anyeven([]) == False\nassert op_first3_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_first3_rev_anyeven([5, 5, 5]) == False\nassert op_first3_rev_anyeven([3, 1, 2]) == True\nassert op_first3_rev_anyeven([10]) == True\nassert op_first3_rev_anyeven([2, 4, 6]) == True\nassert op_first3_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_inc_rev_firsteven", "entry_point": "op_inc_rev_firsteven", "primitives": ["inc", "rev", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then return the first even value (0 if none).", "solution": "def op_inc_rev_firsteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_inc_rev_firsteven([1, 2, 3, 4]) == 4\nassert op_inc_rev_firsteven([]) == 0\nassert op_inc_rev_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_inc_rev_firsteven([5, 5, 5]) == 6\nassert op_inc_rev_firsteven([3, 1, 2]) == 2\nassert op_inc_rev_firsteven([10]) == 0\nassert op_inc_rev_firsteven([2, 4, 6]) == 0\nassert op_inc_rev_firsteven([-7, 12, -7]) == -6"}
{"id": "op_ages_oremptyzero_square", "entry_point": "op_ages_oremptyzero_square", "primitives": ["ages", "oremptyzero", "square"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then square each.", "solution": "def op_ages_oremptyzero_square(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_ages_oremptyzero_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1296, 144]\nassert op_ages_oremptyzero_square([]) == [0]\nassert op_ages_oremptyzero_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [324, 4225, 289]\nassert op_ages_oremptyzero_square([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_evens_inc_sortd", "entry_point": "op_evens_inc_sortd", "primitives": ["evens", "inc", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then sort descending.", "solution": "def op_evens_inc_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_evens_inc_sortd([1, 2, 3, 4]) == [5, 3]\nassert op_evens_inc_sortd([]) == []\nassert op_evens_inc_sortd([-2, -1, 0, 1, 2]) == [3, 1, -1]\nassert op_evens_inc_sortd([5, 5, 5]) == []\nassert op_evens_inc_sortd([3, 1, 2]) == [3]\nassert op_evens_inc_sortd([10]) == [11]\nassert op_evens_inc_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_evens_inc_sortd([-7, 12, -7]) == [13]"}
{"id": "op_inc_negate_anyeven", "entry_point": "op_inc_negate_anyeven", "primitives": ["inc", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then negate each, then return whether any value is even.", "solution": "def op_inc_negate_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_negate_anyeven([1, 2, 3, 4]) == True\nassert op_inc_negate_anyeven([]) == False\nassert op_inc_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_negate_anyeven([5, 5, 5]) == True\nassert op_inc_negate_anyeven([3, 1, 2]) == True\nassert op_inc_negate_anyeven([10]) == False\nassert op_inc_negate_anyeven([2, 4, 6]) == False\nassert op_inc_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_sortabs_oremptyzero", "entry_point": "op_sortd_sortabs_oremptyzero", "primitives": ["sortd", "sortabs", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_sortd_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sortabs_oremptyzero([]) == [0]\nassert op_sortd_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortd_sortabs_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sortabs_oremptyzero([10]) == [10]\nassert op_sortd_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sortabs_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_padto3_last3_uniq", "entry_point": "op_padto3_last3_uniq", "primitives": ["padto3", "last3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then drop duplicates keeping first occurrence.", "solution": "def op_padto3_last3_uniq(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_padto3_last3_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_last3_uniq([]) == [0]\nassert op_padto3_last3_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_last3_uniq([5, 5, 5]) == [5]\nassert op_padto3_last3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_last3_uniq([10]) == [10, 0]\nassert op_padto3_last3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_neg_takewhilepos_firsteven", "entry_point": "op_neg_takewhilepos_firsteven", "primitives": ["neg", "takewhilepos", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_neg_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_takewhilepos_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_takewhilepos_firsteven([]) == 0\nassert op_neg_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_neg_takewhilepos_firsteven([3, 1, 2]) == 0\nassert op_neg_takewhilepos_firsteven([10]) == 0\nassert op_neg_takewhilepos_firsteven([2, 4, 6]) == 0\nassert op_neg_takewhilepos_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_neg_last3", "entry_point": "op_dropzeros_neg_last3", "primitives": ["dropzeros", "neg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then keep only the last three.", "solution": "def op_dropzeros_neg_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_neg_last3([1, 2, 3, 4]) == []\nassert op_dropzeros_neg_last3([]) == []\nassert op_dropzeros_neg_last3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_dropzeros_neg_last3([5, 5, 5]) == []\nassert op_dropzeros_neg_last3([3, 1, 2]) == []\nassert op_dropzeros_neg_last3([10]) == []\nassert op_dropzeros_neg_last3([2, 4, 6]) == []\nassert op_dropzeros_neg_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_padto3_dropwhileneg", "entry_point": "op_beforezero_padto3_dropwhileneg", "primitives": ["beforezero", "padto3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_beforezero_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_padto3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_beforezero_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_beforezero_padto3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_padto3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_padto3_dropwhileneg([10]) == [10, 0, 0]\nassert op_beforezero_padto3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_padto3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_last3_odds", "entry_point": "op_absval_last3_odds", "primitives": ["absval", "last3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then keep the odd numbers.", "solution": "def op_absval_last3_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_last3_odds([1, 2, 3, 4]) == [3]\nassert op_absval_last3_odds([]) == []\nassert op_absval_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_absval_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_last3_odds([3, 1, 2]) == [3, 1]\nassert op_absval_last3_odds([10]) == []\nassert op_absval_last3_odds([2, 4, 6]) == []\nassert op_absval_last3_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_inc_div3_issorted", "entry_point": "op_inc_div3_issorted", "primitives": ["inc", "div3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_inc_div3_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_inc_div3_issorted([1, 2, 3, 4]) == True\nassert op_inc_div3_issorted([]) == True\nassert op_inc_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_div3_issorted([5, 5, 5]) == True\nassert op_inc_div3_issorted([3, 1, 2]) == True\nassert op_inc_div3_issorted([10]) == True\nassert op_inc_div3_issorted([2, 4, 6]) == True\nassert op_inc_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_sortabs_clamp10_issorted", "entry_point": "op_sortabs_clamp10_issorted", "primitives": ["sortabs", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_sortabs_clamp10_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_sortabs_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_clamp10_issorted([]) == True\nassert op_sortabs_clamp10_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_clamp10_issorted([5, 5, 5]) == True\nassert op_sortabs_clamp10_issorted([3, 1, 2]) == True\nassert op_sortabs_clamp10_issorted([10]) == True\nassert op_sortabs_clamp10_issorted([2, 4, 6]) == True\nassert op_sortabs_clamp10_issorted([-7, 12, -7]) == True"}
{"id": "op_beforezero_pos_padto3", "entry_point": "op_beforezero_pos_padto3", "primitives": ["beforezero", "pos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then pad with zeros to at least three elements.", "solution": "def op_beforezero_pos_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_pos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_pos_padto3([]) == [0, 0, 0]\nassert op_beforezero_pos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_beforezero_pos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_pos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_pos_padto3([10]) == [10, 0, 0]\nassert op_beforezero_pos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_pos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_rev_double_sortd", "entry_point": "op_rev_double_sortd", "primitives": ["rev", "double", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then sort descending.", "solution": "def op_rev_double_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_sortd([]) == []\nassert op_rev_double_sortd([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_rev_double_sortd([10]) == [20]\nassert op_rev_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_inc_square_anyeven", "entry_point": "op_inc_square_anyeven", "primitives": ["inc", "square", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each, then return whether any value is even.", "solution": "def op_inc_square_anyeven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_inc_square_anyeven([1, 2, 3, 4]) == True\nassert op_inc_square_anyeven([]) == False\nassert op_inc_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_inc_square_anyeven([5, 5, 5]) == True\nassert op_inc_square_anyeven([3, 1, 2]) == True\nassert op_inc_square_anyeven([10]) == False\nassert op_inc_square_anyeven([2, 4, 6]) == False\nassert op_inc_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_pos_allpos", "entry_point": "op_uniq_pos_allpos", "primitives": ["uniq", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_uniq_pos_allpos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_uniq_pos_allpos([1, 2, 3, 4]) == True\nassert op_uniq_pos_allpos([]) == True\nassert op_uniq_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_uniq_pos_allpos([5, 5, 5]) == True\nassert op_uniq_pos_allpos([3, 1, 2]) == True\nassert op_uniq_pos_allpos([10]) == True\nassert op_uniq_pos_allpos([2, 4, 6]) == True\nassert op_uniq_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_sortd_trimends_padto3", "entry_point": "op_sortd_trimends_padto3", "primitives": ["sortd", "trimends", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_sortd_trimends_padto3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortd_trimends_padto3([1, 2, 3, 4]) == [3, 2, 0]\nassert op_sortd_trimends_padto3([]) == [0, 0, 0]\nassert op_sortd_trimends_padto3([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortd_trimends_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_sortd_trimends_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_sortd_trimends_padto3([10]) == [0, 0, 0]\nassert op_sortd_trimends_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_sortd_trimends_padto3([-7, 12, -7]) == [-7, 0, 0]"}
{"id": "op_dropwhileneg_last3_takewhilepos", "entry_point": "op_dropwhileneg_last3_takewhilepos", "primitives": ["dropwhileneg", "last3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then take values while they are positive.", "solution": "def op_dropwhileneg_last3_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_last3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_last3_takewhilepos([]) == []\nassert op_dropwhileneg_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_last3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_last3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_last3_takewhilepos([10]) == [10]\nassert op_dropwhileneg_last3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_last3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_absval_dropzeros_odds", "entry_point": "op_absval_dropzeros_odds", "primitives": ["absval", "dropzeros", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then keep the odd numbers.", "solution": "def op_absval_dropzeros_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_dropzeros_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_dropzeros_odds([]) == []\nassert op_absval_dropzeros_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_dropzeros_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropzeros_odds([3, 1, 2]) == [3, 1]\nassert op_absval_dropzeros_odds([10]) == []\nassert op_absval_dropzeros_odds([2, 4, 6]) == []\nassert op_absval_dropzeros_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_absval_div3_sorta", "entry_point": "op_absval_div3_sorta", "primitives": ["absval", "div3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then sort ascending.", "solution": "def op_absval_div3_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_absval_div3_sorta([1, 2, 3, 4]) == [3]\nassert op_absval_div3_sorta([]) == []\nassert op_absval_div3_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_absval_div3_sorta([5, 5, 5]) == []\nassert op_absval_div3_sorta([3, 1, 2]) == [3]\nassert op_absval_div3_sorta([10]) == []\nassert op_absval_div3_sorta([2, 4, 6]) == [6]\nassert op_absval_div3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_uniq_oremptyzero", "entry_point": "op_dropfirst_uniq_oremptyzero", "primitives": ["dropfirst", "uniq", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then if empty, use a single zero.", "solution": "def op_dropfirst_uniq_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_uniq_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_uniq_oremptyzero([]) == [0]\nassert op_dropfirst_uniq_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_uniq_oremptyzero([5, 5, 5]) == [5]\nassert op_dropfirst_uniq_oremptyzero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_uniq_oremptyzero([10]) == [0]\nassert op_dropfirst_uniq_oremptyzero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_uniq_oremptyzero([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_clamp10_len", "entry_point": "op_dropfirst_clamp10_len", "primitives": ["dropfirst", "clamp10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then return how many remain.", "solution": "def op_dropfirst_clamp10_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_dropfirst_clamp10_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_clamp10_len([]) == 0\nassert op_dropfirst_clamp10_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_clamp10_len([5, 5, 5]) == 2\nassert op_dropfirst_clamp10_len([3, 1, 2]) == 2\nassert op_dropfirst_clamp10_len([10]) == 0\nassert op_dropfirst_clamp10_len([2, 4, 6]) == 2\nassert op_dropfirst_clamp10_len([-7, 12, -7]) == 2"}
{"id": "op_uniqs_lower_anyempty", "entry_point": "op_uniqs_lower_anyempty", "primitives": ["uniqs", "lower", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then lowercase each string, then return whether any string is empty.", "solution": "def op_uniqs_lower_anyempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_uniqs_lower_anyempty(['Hello', 'world']) == False\nassert op_uniqs_lower_anyempty([]) == False\nassert op_uniqs_lower_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_uniqs_lower_anyempty(['one', 'one', 'Two']) == False\nassert op_uniqs_lower_anyempty(['x']) == False\nassert op_uniqs_lower_anyempty(['abc', 'de', '']) == True"}
{"id": "op_inc_uniq_dec", "entry_point": "op_inc_uniq_dec", "primitives": ["inc", "uniq", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then subtract one from each.", "solution": "def op_inc_uniq_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_uniq_dec([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_uniq_dec([]) == []\nassert op_inc_uniq_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_uniq_dec([5, 5, 5]) == [5]\nassert op_inc_uniq_dec([3, 1, 2]) == [3, 1, 2]\nassert op_inc_uniq_dec([10]) == [10]\nassert op_inc_uniq_dec([2, 4, 6]) == [2, 4, 6]\nassert op_inc_uniq_dec([-7, 12, -7]) == [-7, 12]"}
{"id": "op_rev_oremptyzero_beforezero", "entry_point": "op_rev_oremptyzero_beforezero", "primitives": ["rev", "oremptyzero", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then keep everything before the first zero.", "solution": "def op_rev_oremptyzero_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_oremptyzero_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_beforezero([]) == []\nassert op_rev_oremptyzero_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_oremptyzero_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_beforezero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_beforezero([10]) == [10]\nassert op_rev_oremptyzero_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_inc_pos_absval", "entry_point": "op_inc_pos_absval", "primitives": ["inc", "pos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_inc_pos_absval(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_inc_pos_absval([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_pos_absval([]) == []\nassert op_inc_pos_absval([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_pos_absval([5, 5, 5]) == [6, 6, 6]\nassert op_inc_pos_absval([3, 1, 2]) == [4, 2, 3]\nassert op_inc_pos_absval([10]) == [11]\nassert op_inc_pos_absval([2, 4, 6]) == [3, 5, 7]\nassert op_inc_pos_absval([-7, 12, -7]) == [13]"}
{"id": "op_pos_inc_square", "entry_point": "op_pos_inc_square", "primitives": ["pos", "inc", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then square each.", "solution": "def op_pos_inc_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_inc_square([1, 2, 3, 4]) == [4, 9, 16, 25]\nassert op_pos_inc_square([]) == []\nassert op_pos_inc_square([-2, -1, 0, 1, 2]) == [4, 9]\nassert op_pos_inc_square([5, 5, 5]) == [36, 36, 36]\nassert op_pos_inc_square([3, 1, 2]) == [16, 4, 9]\nassert op_pos_inc_square([10]) == [121]\nassert op_pos_inc_square([2, 4, 6]) == [9, 25, 49]\nassert op_pos_inc_square([-7, 12, -7]) == [169]"}
{"id": "op_dropwhileneg_pos_sorta", "entry_point": "op_dropwhileneg_pos_sorta", "primitives": ["dropwhileneg", "pos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the positive numbers, then sort ascending.", "solution": "def op_dropwhileneg_pos_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_pos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_pos_sorta([]) == []\nassert op_dropwhileneg_pos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_pos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_pos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_pos_sorta([10]) == [10]\nassert op_dropwhileneg_pos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_pos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_last3_clamp10_takewhilepos", "entry_point": "op_last3_clamp10_takewhilepos", "primitives": ["last3", "clamp10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then take values while they are positive.", "solution": "def op_last3_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_clamp10_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_clamp10_takewhilepos([]) == []\nassert op_last3_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_last3_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_clamp10_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_clamp10_takewhilepos([10]) == [10]\nassert op_last3_clamp10_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_clamp10_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_negate_dec_oremptyzero", "entry_point": "op_negate_dec_oremptyzero", "primitives": ["negate", "dec", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then if empty, use a single zero.", "solution": "def op_negate_dec_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_dec_oremptyzero([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_negate_dec_oremptyzero([]) == [0]\nassert op_negate_dec_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_negate_dec_oremptyzero([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_dec_oremptyzero([3, 1, 2]) == [-4, -2, -3]\nassert op_negate_dec_oremptyzero([10]) == [-11]\nassert op_negate_dec_oremptyzero([2, 4, 6]) == [-3, -5, -7]\nassert op_negate_dec_oremptyzero([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_ages_odds_evens", "entry_point": "op_ages_odds_evens", "primitives": ["ages", "odds", "evens"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then keep the even numbers.", "solution": "def op_ages_odds_evens(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_ages_odds_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_odds_evens([]) == []\nassert op_ages_odds_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_odds_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_pos_double_sorta", "entry_point": "op_pos_double_sorta", "primitives": ["pos", "double", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then sort ascending.", "solution": "def op_pos_double_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_pos_double_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_double_sorta([]) == []\nassert op_pos_double_sorta([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_double_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_pos_double_sorta([10]) == [20]\nassert op_pos_double_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_pos_double_sorta([-7, 12, -7]) == [24]"}
{"id": "op_gt5_neg_trimends", "entry_point": "op_gt5_neg_trimends", "primitives": ["gt5", "neg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_gt5_neg_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_neg_trimends([1, 2, 3, 4]) == []\nassert op_gt5_neg_trimends([]) == []\nassert op_gt5_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg_trimends([5, 5, 5]) == []\nassert op_gt5_neg_trimends([3, 1, 2]) == []\nassert op_gt5_neg_trimends([10]) == []\nassert op_gt5_neg_trimends([2, 4, 6]) == []\nassert op_gt5_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_sortalpha_uniqs_lower", "entry_point": "op_sortalpha_uniqs_lower", "primitives": ["sortalpha", "uniqs", "lower"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then lowercase each string.", "solution": "def op_sortalpha_uniqs_lower(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_sortalpha_uniqs_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_sortalpha_uniqs_lower([]) == []\nassert op_sortalpha_uniqs_lower(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc', 'bc']\nassert op_sortalpha_uniqs_lower(['one', 'one', 'Two']) == ['two', 'one']\nassert op_sortalpha_uniqs_lower(['x']) == ['x']\nassert op_sortalpha_uniqs_lower(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_clamp10_neg_sum", "entry_point": "op_clamp10_neg_sum", "primitives": ["clamp10", "neg", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then return their sum.", "solution": "def op_clamp10_neg_sum(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_clamp10_neg_sum([1, 2, 3, 4]) == 0\nassert op_clamp10_neg_sum([]) == 0\nassert op_clamp10_neg_sum([-2, -1, 0, 1, 2]) == -3\nassert op_clamp10_neg_sum([5, 5, 5]) == 0\nassert op_clamp10_neg_sum([3, 1, 2]) == 0\nassert op_clamp10_neg_sum([10]) == 0\nassert op_clamp10_neg_sum([2, 4, 6]) == 0\nassert op_clamp10_neg_sum([-7, 12, -7]) == -14"}
{"id": "op_odds_uniq_min", "entry_point": "op_odds_uniq_min", "primitives": ["odds", "uniq", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_odds_uniq_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_odds_uniq_min([1, 2, 3, 4]) == 1\nassert op_odds_uniq_min([]) == 0\nassert op_odds_uniq_min([-2, -1, 0, 1, 2]) == -1\nassert op_odds_uniq_min([5, 5, 5]) == 5\nassert op_odds_uniq_min([3, 1, 2]) == 1\nassert op_odds_uniq_min([10]) == 0\nassert op_odds_uniq_min([2, 4, 6]) == 0\nassert op_odds_uniq_min([-7, 12, -7]) == -7"}
{"id": "op_pos_first3_anyeven", "entry_point": "op_pos_first3_anyeven", "primitives": ["pos", "first3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then return whether any value is even.", "solution": "def op_pos_first3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_first3_anyeven([1, 2, 3, 4]) == True\nassert op_pos_first3_anyeven([]) == False\nassert op_pos_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_pos_first3_anyeven([5, 5, 5]) == False\nassert op_pos_first3_anyeven([3, 1, 2]) == True\nassert op_pos_first3_anyeven([10]) == True\nassert op_pos_first3_anyeven([2, 4, 6]) == True\nassert op_pos_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_pos_dropfirst", "entry_point": "op_absval_pos_dropfirst", "primitives": ["absval", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then drop the first element.", "solution": "def op_absval_pos_dropfirst(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_absval_pos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_pos_dropfirst([]) == []\nassert op_absval_pos_dropfirst([-2, -1, 0, 1, 2]) == [1, 1, 2]\nassert op_absval_pos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_absval_pos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_absval_pos_dropfirst([10]) == []\nassert op_absval_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_absval_pos_dropfirst([-7, 12, -7]) == [12, 7]"}
{"id": "op_nonempty_upper_sortlen", "entry_point": "op_nonempty_upper_sortlen", "primitives": ["nonempty", "upper", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then uppercase each string, then sort by length, shortest first.", "solution": "def op_nonempty_upper_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.upper() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_nonempty_upper_sortlen(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_nonempty_upper_sortlen([]) == []\nassert op_nonempty_upper_sortlen(['  a ', '', 'BC', 'bc']) == ['BC', 'BC', '  A ']\nassert op_nonempty_upper_sortlen(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_nonempty_upper_sortlen(['x']) == ['X']\nassert op_nonempty_upper_sortlen(['abc', 'de', '']) == ['DE', 'ABC']"}
{"id": "op_oremptyzero_beforezero_prod", "entry_point": "op_oremptyzero_beforezero_prod", "primitives": ["oremptyzero", "beforezero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero, then return their product.", "solution": "def op_oremptyzero_beforezero_prod(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_oremptyzero_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_oremptyzero_beforezero_prod([]) == 1\nassert op_oremptyzero_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_beforezero_prod([5, 5, 5]) == 125\nassert op_oremptyzero_beforezero_prod([3, 1, 2]) == 6\nassert op_oremptyzero_beforezero_prod([10]) == 10\nassert op_oremptyzero_beforezero_prod([2, 4, 6]) == 48\nassert op_oremptyzero_beforezero_prod([-7, 12, -7]) == 588"}
{"id": "op_oremptyzero_evens_clamp10", "entry_point": "op_oremptyzero_evens_clamp10", "primitives": ["oremptyzero", "evens", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then cap each value at 10.", "solution": "def op_oremptyzero_evens_clamp10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_oremptyzero_evens_clamp10([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_evens_clamp10([]) == [0]\nassert op_oremptyzero_evens_clamp10([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_oremptyzero_evens_clamp10([5, 5, 5]) == []\nassert op_oremptyzero_evens_clamp10([3, 1, 2]) == [2]\nassert op_oremptyzero_evens_clamp10([10]) == [10]\nassert op_oremptyzero_evens_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_trimends_beforezero_len", "entry_point": "op_trimends_beforezero_len", "primitives": ["trimends", "beforezero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then return how many remain.", "solution": "def op_trimends_beforezero_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r)", "tests": "assert op_trimends_beforezero_len([1, 2, 3, 4]) == 2\nassert op_trimends_beforezero_len([]) == 0\nassert op_trimends_beforezero_len([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_beforezero_len([5, 5, 5]) == 1\nassert op_trimends_beforezero_len([3, 1, 2]) == 1\nassert op_trimends_beforezero_len([10]) == 0\nassert op_trimends_beforezero_len([2, 4, 6]) == 1\nassert op_trimends_beforezero_len([-7, 12, -7]) == 1"}
{"id": "op_dropwhileneg_neg_issorted", "entry_point": "op_dropwhileneg_neg_issorted", "primitives": ["dropwhileneg", "neg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_neg_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_neg_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_neg_issorted([]) == True\nassert op_dropwhileneg_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_neg_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_neg_issorted([3, 1, 2]) == True\nassert op_dropwhileneg_neg_issorted([10]) == True\nassert op_dropwhileneg_neg_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_add10_sorta", "entry_point": "op_gt5_add10_sorta", "primitives": ["gt5", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then sort ascending.", "solution": "def op_gt5_add10_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_add10_sorta([1, 2, 3, 4]) == []\nassert op_gt5_add10_sorta([]) == []\nassert op_gt5_add10_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_sorta([5, 5, 5]) == []\nassert op_gt5_add10_sorta([3, 1, 2]) == []\nassert op_gt5_add10_sorta([10]) == [20]\nassert op_gt5_add10_sorta([2, 4, 6]) == [16]\nassert op_gt5_add10_sorta([-7, 12, -7]) == [22]"}
{"id": "op_oremptyzero_gt5_dec", "entry_point": "op_oremptyzero_gt5_dec", "primitives": ["oremptyzero", "gt5", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then subtract one from each.", "solution": "def op_oremptyzero_gt5_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_gt5_dec([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_dec([]) == []\nassert op_oremptyzero_gt5_dec([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_dec([5, 5, 5]) == []\nassert op_oremptyzero_gt5_dec([3, 1, 2]) == []\nassert op_oremptyzero_gt5_dec([10]) == [9]\nassert op_oremptyzero_gt5_dec([2, 4, 6]) == [5]\nassert op_oremptyzero_gt5_dec([-7, 12, -7]) == [11]"}
{"id": "op_div3_odds_square", "entry_point": "op_div3_odds_square", "primitives": ["div3", "odds", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then square each.", "solution": "def op_div3_odds_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_div3_odds_square([1, 2, 3, 4]) == [9]\nassert op_div3_odds_square([]) == []\nassert op_div3_odds_square([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_square([5, 5, 5]) == []\nassert op_div3_odds_square([3, 1, 2]) == [9]\nassert op_div3_odds_square([10]) == []\nassert op_div3_odds_square([2, 4, 6]) == []\nassert op_div3_odds_square([-7, 12, -7]) == []"}
{"id": "op_trimends_absval_sortd", "entry_point": "op_trimends_absval_sortd", "primitives": ["trimends", "absval", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then sort descending.", "solution": "def op_trimends_absval_sortd(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_trimends_absval_sortd([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_absval_sortd([]) == []\nassert op_trimends_absval_sortd([-2, -1, 0, 1, 2]) == [1, 1, 0]\nassert op_trimends_absval_sortd([5, 5, 5]) == [5]\nassert op_trimends_absval_sortd([3, 1, 2]) == [1]\nassert op_trimends_absval_sortd([10]) == []\nassert op_trimends_absval_sortd([2, 4, 6]) == [4]\nassert op_trimends_absval_sortd([-7, 12, -7]) == [12]"}
{"id": "op_double_square_firsteven", "entry_point": "op_double_square_firsteven", "primitives": ["double", "square", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then return the first even value (0 if none).", "solution": "def op_double_square_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_square_firsteven([1, 2, 3, 4]) == 4\nassert op_double_square_firsteven([]) == 0\nassert op_double_square_firsteven([-2, -1, 0, 1, 2]) == 16\nassert op_double_square_firsteven([5, 5, 5]) == 100\nassert op_double_square_firsteven([3, 1, 2]) == 36\nassert op_double_square_firsteven([10]) == 400\nassert op_double_square_firsteven([2, 4, 6]) == 16\nassert op_double_square_firsteven([-7, 12, -7]) == 196"}
{"id": "op_last3_div3_neg", "entry_point": "op_last3_div3_neg", "primitives": ["last3", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then keep the negative numbers.", "solution": "def op_last3_div3_neg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_last3_div3_neg([1, 2, 3, 4]) == []\nassert op_last3_div3_neg([]) == []\nassert op_last3_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_last3_div3_neg([5, 5, 5]) == []\nassert op_last3_div3_neg([3, 1, 2]) == []\nassert op_last3_div3_neg([10]) == []\nassert op_last3_div3_neg([2, 4, 6]) == []\nassert op_last3_div3_neg([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dropwhileneg_sortd", "entry_point": "op_takewhilepos_dropwhileneg_sortd", "primitives": ["takewhilepos", "dropwhileneg", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then sort descending.", "solution": "def op_takewhilepos_dropwhileneg_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_dropwhileneg_sortd([]) == []\nassert op_takewhilepos_dropwhileneg_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropwhileneg_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_dropwhileneg_sortd([10]) == [10]\nassert op_takewhilepos_dropwhileneg_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_dropwhileneg_sortd([-7, 12, -7]) == []"}
{"id": "op_sortabs_neg_alldistinct", "entry_point": "op_sortabs_neg_alldistinct", "primitives": ["sortabs", "neg", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then return whether all values are distinct.", "solution": "def op_sortabs_neg_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_neg_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_neg_alldistinct([]) == True\nassert op_sortabs_neg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_neg_alldistinct([5, 5, 5]) == True\nassert op_sortabs_neg_alldistinct([3, 1, 2]) == True\nassert op_sortabs_neg_alldistinct([10]) == True\nassert op_sortabs_neg_alldistinct([2, 4, 6]) == True\nassert op_sortabs_neg_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_first3_sortd", "entry_point": "op_dropzeros_first3_sortd", "primitives": ["dropzeros", "first3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then sort descending.", "solution": "def op_dropzeros_first3_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_first3_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dropzeros_first3_sortd([]) == []\nassert op_dropzeros_first3_sortd([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_dropzeros_first3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_first3_sortd([10]) == [10]\nassert op_dropzeros_first3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_first3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_square_first3_negate", "entry_point": "op_square_first3_negate", "primitives": ["square", "first3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then negate each.", "solution": "def op_square_first3_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_first3_negate([1, 2, 3, 4]) == [-1, -4, -9]\nassert op_square_first3_negate([]) == []\nassert op_square_first3_negate([-2, -1, 0, 1, 2]) == [-4, -1, 0]\nassert op_square_first3_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_first3_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_square_first3_negate([10]) == [-100]\nassert op_square_first3_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_first3_negate([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_evens_odds_len", "entry_point": "op_evens_odds_len", "primitives": ["evens", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then return how many remain.", "solution": "def op_evens_odds_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_evens_odds_len([1, 2, 3, 4]) == 0\nassert op_evens_odds_len([]) == 0\nassert op_evens_odds_len([-2, -1, 0, 1, 2]) == 0\nassert op_evens_odds_len([5, 5, 5]) == 0\nassert op_evens_odds_len([3, 1, 2]) == 0\nassert op_evens_odds_len([10]) == 0\nassert op_evens_odds_len([2, 4, 6]) == 0\nassert op_evens_odds_len([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_add10_pos", "entry_point": "op_dropwhileneg_add10_pos", "primitives": ["dropwhileneg", "add10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then keep the positive numbers.", "solution": "def op_dropwhileneg_add10_pos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropwhileneg_add10_pos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_add10_pos([]) == []\nassert op_dropwhileneg_add10_pos([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_add10_pos([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_add10_pos([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_add10_pos([10]) == [20]\nassert op_dropwhileneg_add10_pos([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_add10_pos([-7, 12, -7]) == [22, 3]"}
{"id": "op_double_square_takewhilepos", "entry_point": "op_double_square_takewhilepos", "primitives": ["double", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then take values while they are positive.", "solution": "def op_double_square_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_square_takewhilepos([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_double_square_takewhilepos([]) == []\nassert op_double_square_takewhilepos([-2, -1, 0, 1, 2]) == [16, 4]\nassert op_double_square_takewhilepos([5, 5, 5]) == [100, 100, 100]\nassert op_double_square_takewhilepos([3, 1, 2]) == [36, 4, 16]\nassert op_double_square_takewhilepos([10]) == [400]\nassert op_double_square_takewhilepos([2, 4, 6]) == [16, 64, 144]\nassert op_double_square_takewhilepos([-7, 12, -7]) == [196, 576, 196]"}
{"id": "op_dropwhileneg_evens_alldistinct", "entry_point": "op_dropwhileneg_evens_alldistinct", "primitives": ["dropwhileneg", "evens", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_dropwhileneg_evens_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_evens_alldistinct([]) == True\nassert op_dropwhileneg_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_evens_alldistinct([5, 5, 5]) == True\nassert op_dropwhileneg_evens_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_evens_alldistinct([10]) == True\nassert op_dropwhileneg_evens_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_ages_div3_inc", "entry_point": "op_ages_div3_inc", "primitives": ["ages", "div3", "inc"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three, then add one to each.", "solution": "def op_ages_div3_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_div3_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [37, 13]\nassert op_ages_div3_inc([]) == []\nassert op_ages_div3_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [19]\nassert op_ages_div3_inc([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_padto3_sortabs_takewhilepos", "entry_point": "op_padto3_sortabs_takewhilepos", "primitives": ["padto3", "sortabs", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then take values while they are positive.", "solution": "def op_padto3_sortabs_takewhilepos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_padto3_sortabs_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sortabs_takewhilepos([]) == []\nassert op_padto3_sortabs_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_padto3_sortabs_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortabs_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sortabs_takewhilepos([10]) == []\nassert op_padto3_sortabs_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sortabs_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_absval_trimends_alldistinct", "entry_point": "op_absval_trimends_alldistinct", "primitives": ["absval", "trimends", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_absval_trimends_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_absval_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_trimends_alldistinct([]) == True\nassert op_absval_trimends_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_absval_trimends_alldistinct([5, 5, 5]) == True\nassert op_absval_trimends_alldistinct([3, 1, 2]) == True\nassert op_absval_trimends_alldistinct([10]) == True\nassert op_absval_trimends_alldistinct([2, 4, 6]) == True\nassert op_absval_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_evens_beforezero_negate", "entry_point": "op_evens_beforezero_negate", "primitives": ["evens", "beforezero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then negate each.", "solution": "def op_evens_beforezero_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_beforezero_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_evens_beforezero_negate([]) == []\nassert op_evens_beforezero_negate([-2, -1, 0, 1, 2]) == [2]\nassert op_evens_beforezero_negate([5, 5, 5]) == []\nassert op_evens_beforezero_negate([3, 1, 2]) == [-2]\nassert op_evens_beforezero_negate([10]) == [-10]\nassert op_evens_beforezero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_evens_beforezero_negate([-7, 12, -7]) == [-12]"}
{"id": "op_oremptyzero_dec_negate", "entry_point": "op_oremptyzero_dec_negate", "primitives": ["oremptyzero", "dec", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then negate each.", "solution": "def op_oremptyzero_dec_negate(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_oremptyzero_dec_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_oremptyzero_dec_negate([]) == [1]\nassert op_oremptyzero_dec_negate([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_oremptyzero_dec_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_oremptyzero_dec_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_oremptyzero_dec_negate([10]) == [-9]\nassert op_oremptyzero_dec_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_oremptyzero_dec_negate([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_dropwhileneg_uniq_issorted", "entry_point": "op_dropwhileneg_uniq_issorted", "primitives": ["dropwhileneg", "uniq", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_uniq_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_uniq_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_uniq_issorted([]) == True\nassert op_dropwhileneg_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_uniq_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_uniq_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_uniq_issorted([10]) == True\nassert op_dropwhileneg_uniq_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_uniq_issorted([-7, 12, -7]) == False"}
{"id": "op_gt5_negate_haszero", "entry_point": "op_gt5_negate_haszero", "primitives": ["gt5", "negate", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then return whether the list contains a zero.", "solution": "def op_gt5_negate_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return 0 in r", "tests": "assert op_gt5_negate_haszero([1, 2, 3, 4]) == False\nassert op_gt5_negate_haszero([]) == False\nassert op_gt5_negate_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_negate_haszero([5, 5, 5]) == False\nassert op_gt5_negate_haszero([3, 1, 2]) == False\nassert op_gt5_negate_haszero([10]) == False\nassert op_gt5_negate_haszero([2, 4, 6]) == False\nassert op_gt5_negate_haszero([-7, 12, -7]) == False"}
{"id": "op_pos_absval_double", "entry_point": "op_pos_absval_double", "primitives": ["pos", "absval", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then double each.", "solution": "def op_pos_absval_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_absval_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_absval_double([]) == []\nassert op_pos_absval_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_absval_double([5, 5, 5]) == [10, 10, 10]\nassert op_pos_absval_double([3, 1, 2]) == [6, 2, 4]\nassert op_pos_absval_double([10]) == [20]\nassert op_pos_absval_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_absval_double([-7, 12, -7]) == [24]"}
{"id": "op_first3_trimends_alldistinct", "entry_point": "op_first3_trimends_alldistinct", "primitives": ["first3", "trimends", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_first3_trimends_alldistinct(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_first3_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_first3_trimends_alldistinct([]) == True\nassert op_first3_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_first3_trimends_alldistinct([5, 5, 5]) == True\nassert op_first3_trimends_alldistinct([3, 1, 2]) == True\nassert op_first3_trimends_alldistinct([10]) == True\nassert op_first3_trimends_alldistinct([2, 4, 6]) == True\nassert op_first3_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_beforezero_trimends_counteven", "entry_point": "op_beforezero_trimends_counteven", "primitives": ["beforezero", "trimends", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then return how many values are even.", "solution": "def op_beforezero_trimends_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_beforezero_trimends_counteven([]) == 0\nassert op_beforezero_trimends_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_trimends_counteven([5, 5, 5]) == 0\nassert op_beforezero_trimends_counteven([3, 1, 2]) == 0\nassert op_beforezero_trimends_counteven([10]) == 0\nassert op_beforezero_trimends_counteven([2, 4, 6]) == 1\nassert op_beforezero_trimends_counteven([-7, 12, -7]) == 1"}
{"id": "op_double_evens_alldistinct", "entry_point": "op_double_evens_alldistinct", "primitives": ["double", "evens", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_double_evens_alldistinct(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_double_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_double_evens_alldistinct([]) == True\nassert op_double_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_double_evens_alldistinct([5, 5, 5]) == False\nassert op_double_evens_alldistinct([3, 1, 2]) == True\nassert op_double_evens_alldistinct([10]) == True\nassert op_double_evens_alldistinct([2, 4, 6]) == True\nassert op_double_evens_alldistinct([-7, 12, -7]) == False"}
{"id": "op_padto3_inc_neg", "entry_point": "op_padto3_inc_neg", "primitives": ["padto3", "inc", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then keep the negative numbers.", "solution": "def op_padto3_inc_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_inc_neg([1, 2, 3, 4]) == []\nassert op_padto3_inc_neg([]) == []\nassert op_padto3_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_padto3_inc_neg([5, 5, 5]) == []\nassert op_padto3_inc_neg([3, 1, 2]) == []\nassert op_padto3_inc_neg([10]) == []\nassert op_padto3_inc_neg([2, 4, 6]) == []\nassert op_padto3_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_square_div3_dropfirst", "entry_point": "op_square_div3_dropfirst", "primitives": ["square", "div3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then drop the first element.", "solution": "def op_square_div3_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_square_div3_dropfirst([1, 2, 3, 4]) == []\nassert op_square_div3_dropfirst([]) == []\nassert op_square_div3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_square_div3_dropfirst([5, 5, 5]) == []\nassert op_square_div3_dropfirst([3, 1, 2]) == []\nassert op_square_div3_dropfirst([10]) == []\nassert op_square_div3_dropfirst([2, 4, 6]) == []\nassert op_square_div3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_ages_oremptyzero_div3", "entry_point": "op_ages_oremptyzero_div3", "primitives": ["ages", "oremptyzero", "div3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then keep multiples of three.", "solution": "def op_ages_oremptyzero_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_oremptyzero_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_oremptyzero_div3([]) == [0]\nassert op_ages_oremptyzero_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_oremptyzero_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_negate_neg_first3", "entry_point": "op_negate_neg_first3", "primitives": ["negate", "neg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then keep only the first three.", "solution": "def op_negate_neg_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_negate_neg_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_neg_first3([]) == []\nassert op_negate_neg_first3([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_negate_neg_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_neg_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_neg_first3([10]) == [-10]\nassert op_negate_neg_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_neg_first3([-7, 12, -7]) == [-12]"}
{"id": "op_sorta_gt5_odds", "entry_point": "op_sorta_gt5_odds", "primitives": ["sorta", "gt5", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five, then keep the odd numbers.", "solution": "def op_sorta_gt5_odds(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sorta_gt5_odds([1, 2, 3, 4]) == []\nassert op_sorta_gt5_odds([]) == []\nassert op_sorta_gt5_odds([-2, -1, 0, 1, 2]) == []\nassert op_sorta_gt5_odds([5, 5, 5]) == []\nassert op_sorta_gt5_odds([3, 1, 2]) == []\nassert op_sorta_gt5_odds([10]) == []\nassert op_sorta_gt5_odds([2, 4, 6]) == []\nassert op_sorta_gt5_odds([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_dec_absval", "entry_point": "op_dropwhileneg_dec_absval", "primitives": ["dropwhileneg", "dec", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then subtract one from each, then take the absolute value of each.", "solution": "def op_dropwhileneg_dec_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_dec_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropwhileneg_dec_absval([]) == []\nassert op_dropwhileneg_dec_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_dropwhileneg_dec_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dropwhileneg_dec_absval([3, 1, 2]) == [2, 0, 1]\nassert op_dropwhileneg_dec_absval([10]) == [9]\nassert op_dropwhileneg_dec_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dropwhileneg_dec_absval([-7, 12, -7]) == [11, 8]"}
{"id": "op_dropzeros_rev_absval", "entry_point": "op_dropzeros_rev_absval", "primitives": ["dropzeros", "rev", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then take the absolute value of each.", "solution": "def op_dropzeros_rev_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_rev_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_rev_absval([]) == []\nassert op_dropzeros_rev_absval([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_rev_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_rev_absval([3, 1, 2]) == [2, 1, 3]\nassert op_dropzeros_rev_absval([10]) == [10]\nassert op_dropzeros_rev_absval([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_rev_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_uniq_dropzeros_max", "entry_point": "op_uniq_dropzeros_max", "primitives": ["uniq", "dropzeros", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then return the maximum (0 if empty).", "solution": "def op_uniq_dropzeros_max(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return max(r) if r else 0", "tests": "assert op_uniq_dropzeros_max([1, 2, 3, 4]) == 4\nassert op_uniq_dropzeros_max([]) == 0\nassert op_uniq_dropzeros_max([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_dropzeros_max([5, 5, 5]) == 5\nassert op_uniq_dropzeros_max([3, 1, 2]) == 3\nassert op_uniq_dropzeros_max([10]) == 10\nassert op_uniq_dropzeros_max([2, 4, 6]) == 6\nassert op_uniq_dropzeros_max([-7, 12, -7]) == 12"}
{"id": "op_last3_absval_dropfirst", "entry_point": "op_last3_absval_dropfirst", "primitives": ["last3", "absval", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then drop the first element.", "solution": "def op_last3_absval_dropfirst(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_last3_absval_dropfirst([1, 2, 3, 4]) == [3, 4]\nassert op_last3_absval_dropfirst([]) == []\nassert op_last3_absval_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_absval_dropfirst([5, 5, 5]) == [5, 5]\nassert op_last3_absval_dropfirst([3, 1, 2]) == [1, 2]\nassert op_last3_absval_dropfirst([10]) == []\nassert op_last3_absval_dropfirst([2, 4, 6]) == [4, 6]\nassert op_last3_absval_dropfirst([-7, 12, -7]) == [12, 7]"}
{"id": "op_sortd_dropwhileneg_absval", "entry_point": "op_sortd_dropwhileneg_absval", "primitives": ["sortd", "dropwhileneg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then take the absolute value of each.", "solution": "def op_sortd_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortd_dropwhileneg_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_dropwhileneg_absval([]) == []\nassert op_sortd_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sortd_dropwhileneg_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropwhileneg_absval([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropwhileneg_absval([10]) == [10]\nassert op_sortd_dropwhileneg_absval([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropwhileneg_absval([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_div3_last3_firsteven", "entry_point": "op_div3_last3_firsteven", "primitives": ["div3", "last3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then return the first even value (0 if none).", "solution": "def op_div3_last3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_last3_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_last3_firsteven([]) == 0\nassert op_div3_last3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_last3_firsteven([5, 5, 5]) == 0\nassert op_div3_last3_firsteven([3, 1, 2]) == 0\nassert op_div3_last3_firsteven([10]) == 0\nassert op_div3_last3_firsteven([2, 4, 6]) == 6\nassert op_div3_last3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_first3_negate_counteven", "entry_point": "op_first3_negate_counteven", "primitives": ["first3", "negate", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then negate each, then return how many values are even.", "solution": "def op_first3_negate_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_negate_counteven([1, 2, 3, 4]) == 1\nassert op_first3_negate_counteven([]) == 0\nassert op_first3_negate_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_negate_counteven([5, 5, 5]) == 0\nassert op_first3_negate_counteven([3, 1, 2]) == 1\nassert op_first3_negate_counteven([10]) == 1\nassert op_first3_negate_counteven([2, 4, 6]) == 3\nassert op_first3_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_trimends_absval_dec", "entry_point": "op_trimends_absval_dec", "primitives": ["trimends", "absval", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then subtract one from each.", "solution": "def op_trimends_absval_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_absval_dec([1, 2, 3, 4]) == [1, 2]\nassert op_trimends_absval_dec([]) == []\nassert op_trimends_absval_dec([-2, -1, 0, 1, 2]) == [0, -1, 0]\nassert op_trimends_absval_dec([5, 5, 5]) == [4]\nassert op_trimends_absval_dec([3, 1, 2]) == [0]\nassert op_trimends_absval_dec([10]) == []\nassert op_trimends_absval_dec([2, 4, 6]) == [3]\nassert op_trimends_absval_dec([-7, 12, -7]) == [11]"}
{"id": "op_gt5_oremptyzero_pos", "entry_point": "op_gt5_oremptyzero_pos", "primitives": ["gt5", "oremptyzero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_gt5_oremptyzero_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_oremptyzero_pos([1, 2, 3, 4]) == []\nassert op_gt5_oremptyzero_pos([]) == []\nassert op_gt5_oremptyzero_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_oremptyzero_pos([5, 5, 5]) == []\nassert op_gt5_oremptyzero_pos([3, 1, 2]) == []\nassert op_gt5_oremptyzero_pos([10]) == [10]\nassert op_gt5_oremptyzero_pos([2, 4, 6]) == [6]\nassert op_gt5_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_rev_absval_beforezero", "entry_point": "op_rev_absval_beforezero", "primitives": ["rev", "absval", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then keep everything before the first zero.", "solution": "def op_rev_absval_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_absval_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_absval_beforezero([]) == []\nassert op_rev_absval_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_absval_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_absval_beforezero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_absval_beforezero([10]) == [10]\nassert op_rev_absval_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_absval_beforezero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_beforezero_padto3_oremptyzero", "entry_point": "op_beforezero_padto3_oremptyzero", "primitives": ["beforezero", "padto3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_beforezero_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_beforezero_padto3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_beforezero_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_beforezero_padto3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_padto3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_padto3_oremptyzero([10]) == [10, 0, 0]\nassert op_beforezero_padto3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_padto3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sortabs_neg_first3", "entry_point": "op_sortabs_neg_first3", "primitives": ["sortabs", "neg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then keep only the first three.", "solution": "def op_sortabs_neg_first3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_sortabs_neg_first3([1, 2, 3, 4]) == []\nassert op_sortabs_neg_first3([]) == []\nassert op_sortabs_neg_first3([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_neg_first3([5, 5, 5]) == []\nassert op_sortabs_neg_first3([3, 1, 2]) == []\nassert op_sortabs_neg_first3([10]) == []\nassert op_sortabs_neg_first3([2, 4, 6]) == []\nassert op_sortabs_neg_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_sortd_counteven", "entry_point": "op_last3_sortd_counteven", "primitives": ["last3", "sortd", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then return how many values are even.", "solution": "def op_last3_sortd_counteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_last3_sortd_counteven([1, 2, 3, 4]) == 2\nassert op_last3_sortd_counteven([]) == 0\nassert op_last3_sortd_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_last3_sortd_counteven([5, 5, 5]) == 0\nassert op_last3_sortd_counteven([3, 1, 2]) == 1\nassert op_last3_sortd_counteven([10]) == 1\nassert op_last3_sortd_counteven([2, 4, 6]) == 3\nassert op_last3_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_sorta_rev_counteven", "entry_point": "op_sorta_rev_counteven", "primitives": ["sorta", "rev", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then return how many values are even.", "solution": "def op_sorta_rev_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_rev_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_rev_counteven([]) == 0\nassert op_sorta_rev_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_rev_counteven([5, 5, 5]) == 0\nassert op_sorta_rev_counteven([3, 1, 2]) == 1\nassert op_sorta_rev_counteven([10]) == 1\nassert op_sorta_rev_counteven([2, 4, 6]) == 3\nassert op_sorta_rev_counteven([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_square_absval", "entry_point": "op_oremptyzero_square_absval", "primitives": ["oremptyzero", "square", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then take the absolute value of each.", "solution": "def op_oremptyzero_square_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_square_absval([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_oremptyzero_square_absval([]) == [0]\nassert op_oremptyzero_square_absval([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_oremptyzero_square_absval([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_square_absval([3, 1, 2]) == [9, 1, 4]\nassert op_oremptyzero_square_absval([10]) == [100]\nassert op_oremptyzero_square_absval([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_square_absval([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_square_sortabs_len", "entry_point": "op_square_sortabs_len", "primitives": ["square", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then return how many remain.", "solution": "def op_square_sortabs_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_square_sortabs_len([1, 2, 3, 4]) == 4\nassert op_square_sortabs_len([]) == 0\nassert op_square_sortabs_len([-2, -1, 0, 1, 2]) == 5\nassert op_square_sortabs_len([5, 5, 5]) == 3\nassert op_square_sortabs_len([3, 1, 2]) == 3\nassert op_square_sortabs_len([10]) == 1\nassert op_square_sortabs_len([2, 4, 6]) == 3\nassert op_square_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_sortalpha_dropshort_uniqs", "entry_point": "op_sortalpha_dropshort_uniqs", "primitives": ["sortalpha", "dropshort", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters, then drop duplicate strings keeping the first.", "solution": "def op_sortalpha_dropshort_uniqs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortalpha_dropshort_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_dropshort_uniqs([]) == []\nassert op_sortalpha_dropshort_uniqs(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_sortalpha_dropshort_uniqs(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_sortalpha_dropshort_uniqs(['x']) == []\nassert op_sortalpha_dropshort_uniqs(['abc', 'de', '']) == ['abc']"}
{"id": "op_uniq_double_clamp10", "entry_point": "op_uniq_double_clamp10", "primitives": ["uniq", "double", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then cap each value at 10.", "solution": "def op_uniq_double_clamp10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_uniq_double_clamp10([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_double_clamp10([]) == []\nassert op_uniq_double_clamp10([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_uniq_double_clamp10([5, 5, 5]) == [10]\nassert op_uniq_double_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_double_clamp10([10]) == [10]\nassert op_uniq_double_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_uniq_double_clamp10([-7, 12, -7]) == [-14, 10]"}
{"id": "op_double_negate_oremptyzero", "entry_point": "op_double_negate_oremptyzero", "primitives": ["double", "negate", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then if empty, use a single zero.", "solution": "def op_double_negate_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_negate_oremptyzero([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_negate_oremptyzero([]) == [0]\nassert op_double_negate_oremptyzero([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_negate_oremptyzero([5, 5, 5]) == [-10, -10, -10]\nassert op_double_negate_oremptyzero([3, 1, 2]) == [-6, -2, -4]\nassert op_double_negate_oremptyzero([10]) == [-20]\nassert op_double_negate_oremptyzero([2, 4, 6]) == [-4, -8, -12]\nassert op_double_negate_oremptyzero([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_dropwhileneg_absval_trimends", "entry_point": "op_dropwhileneg_absval_trimends", "primitives": ["dropwhileneg", "absval", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_dropwhileneg_absval_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_absval_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_dropwhileneg_absval_trimends([]) == []\nassert op_dropwhileneg_absval_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_absval_trimends([5, 5, 5]) == [5]\nassert op_dropwhileneg_absval_trimends([3, 1, 2]) == [1]\nassert op_dropwhileneg_absval_trimends([10]) == []\nassert op_dropwhileneg_absval_trimends([2, 4, 6]) == [4]\nassert op_dropwhileneg_absval_trimends([-7, 12, -7]) == []"}
{"id": "op_div3_clamp10_oremptyzero", "entry_point": "op_div3_clamp10_oremptyzero", "primitives": ["div3", "clamp10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_div3_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_clamp10_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_div3_clamp10_oremptyzero([]) == [0]\nassert op_div3_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_clamp10_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_clamp10_oremptyzero([3, 1, 2]) == [3]\nassert op_div3_clamp10_oremptyzero([10]) == [0]\nassert op_div3_clamp10_oremptyzero([2, 4, 6]) == [6]\nassert op_div3_clamp10_oremptyzero([-7, 12, -7]) == [10]"}
{"id": "op_takewhilepos_dropwhileneg_clamp10", "entry_point": "op_takewhilepos_dropwhileneg_clamp10", "primitives": ["takewhilepos", "dropwhileneg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then cap each value at 10.", "solution": "def op_takewhilepos_dropwhileneg_clamp10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_dropwhileneg_clamp10([]) == []\nassert op_takewhilepos_dropwhileneg_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropwhileneg_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropwhileneg_clamp10([10]) == [10]\nassert op_takewhilepos_dropwhileneg_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropwhileneg_clamp10([-7, 12, -7]) == []"}
{"id": "op_pos_clamp10_alldistinct", "entry_point": "op_pos_clamp10_alldistinct", "primitives": ["pos", "clamp10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_pos_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_pos_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_pos_clamp10_alldistinct([]) == True\nassert op_pos_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_pos_clamp10_alldistinct([5, 5, 5]) == False\nassert op_pos_clamp10_alldistinct([3, 1, 2]) == True\nassert op_pos_clamp10_alldistinct([10]) == True\nassert op_pos_clamp10_alldistinct([2, 4, 6]) == True\nassert op_pos_clamp10_alldistinct([-7, 12, -7]) == True"}
{"id": "op_gt5_beforezero_trimends", "entry_point": "op_gt5_beforezero_trimends", "primitives": ["gt5", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_gt5_beforezero_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_beforezero_trimends([1, 2, 3, 4]) == []\nassert op_gt5_beforezero_trimends([]) == []\nassert op_gt5_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_beforezero_trimends([5, 5, 5]) == []\nassert op_gt5_beforezero_trimends([3, 1, 2]) == []\nassert op_gt5_beforezero_trimends([10]) == []\nassert op_gt5_beforezero_trimends([2, 4, 6]) == []\nassert op_gt5_beforezero_trimends([-7, 12, -7]) == []"}
{"id": "op_padto3_oremptyzero_min", "entry_point": "op_padto3_oremptyzero_min", "primitives": ["padto3", "oremptyzero", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_padto3_oremptyzero_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_padto3_oremptyzero_min([1, 2, 3, 4]) == 1\nassert op_padto3_oremptyzero_min([]) == 0\nassert op_padto3_oremptyzero_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_oremptyzero_min([5, 5, 5]) == 5\nassert op_padto3_oremptyzero_min([3, 1, 2]) == 1\nassert op_padto3_oremptyzero_min([10]) == 0\nassert op_padto3_oremptyzero_min([2, 4, 6]) == 2\nassert op_padto3_oremptyzero_min([-7, 12, -7]) == -7"}
{"id": "op_pos_odds_uniq", "entry_point": "op_pos_odds_uniq", "primitives": ["pos", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_pos_odds_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_pos_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_pos_odds_uniq([]) == []\nassert op_pos_odds_uniq([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_odds_uniq([5, 5, 5]) == [5]\nassert op_pos_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_pos_odds_uniq([10]) == []\nassert op_pos_odds_uniq([2, 4, 6]) == []\nassert op_pos_odds_uniq([-7, 12, -7]) == []"}
{"id": "op_padto3_first3_negate", "entry_point": "op_padto3_first3_negate", "primitives": ["padto3", "first3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then negate each.", "solution": "def op_padto3_first3_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_first3_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_padto3_first3_negate([]) == [0, 0, 0]\nassert op_padto3_first3_negate([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_padto3_first3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_first3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_first3_negate([10]) == [-10, 0, 0]\nassert op_padto3_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_first3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sorta_odds_div3", "entry_point": "op_sorta_odds_div3", "primitives": ["sorta", "odds", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers, then keep multiples of three.", "solution": "def op_sorta_odds_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_odds_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_odds_div3([]) == []\nassert op_sorta_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_sorta_odds_div3([5, 5, 5]) == []\nassert op_sorta_odds_div3([3, 1, 2]) == [3]\nassert op_sorta_odds_div3([10]) == []\nassert op_sorta_odds_div3([2, 4, 6]) == []\nassert op_sorta_odds_div3([-7, 12, -7]) == []"}
{"id": "op_double_dropzeros_sortabs", "entry_point": "op_double_dropzeros_sortabs", "primitives": ["double", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then sort by absolute value.", "solution": "def op_double_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_dropzeros_sortabs([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropzeros_sortabs([]) == []\nassert op_double_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-2, 2, -4, 4]\nassert op_double_dropzeros_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropzeros_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_double_dropzeros_sortabs([10]) == [20]\nassert op_double_dropzeros_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropzeros_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropfirst_uniq_gt5", "entry_point": "op_dropfirst_uniq_gt5", "primitives": ["dropfirst", "uniq", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_dropfirst_uniq_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_uniq_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_uniq_gt5([]) == []\nassert op_dropfirst_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_uniq_gt5([5, 5, 5]) == []\nassert op_dropfirst_uniq_gt5([3, 1, 2]) == []\nassert op_dropfirst_uniq_gt5([10]) == []\nassert op_dropfirst_uniq_gt5([2, 4, 6]) == [6]\nassert op_dropfirst_uniq_gt5([-7, 12, -7]) == [12]"}
{"id": "op_inc_trimends_padto3", "entry_point": "op_inc_trimends_padto3", "primitives": ["inc", "trimends", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_inc_trimends_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_trimends_padto3([1, 2, 3, 4]) == [3, 4, 0]\nassert op_inc_trimends_padto3([]) == [0, 0, 0]\nassert op_inc_trimends_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends_padto3([5, 5, 5]) == [6, 0, 0]\nassert op_inc_trimends_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_inc_trimends_padto3([10]) == [0, 0, 0]\nassert op_inc_trimends_padto3([2, 4, 6]) == [5, 0, 0]\nassert op_inc_trimends_padto3([-7, 12, -7]) == [13, 0, 0]"}
{"id": "op_dec_uniq_odds", "entry_point": "op_dec_uniq_odds", "primitives": ["dec", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_dec_uniq_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dec_uniq_odds([]) == []\nassert op_dec_uniq_odds([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_dec_uniq_odds([5, 5, 5]) == []\nassert op_dec_uniq_odds([3, 1, 2]) == [1]\nassert op_dec_uniq_odds([10]) == [9]\nassert op_dec_uniq_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_uniq_odds([-7, 12, -7]) == [11]"}
{"id": "op_dec_padto3_min", "entry_point": "op_dec_padto3_min", "primitives": ["dec", "padto3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_dec_padto3_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_dec_padto3_min([1, 2, 3, 4]) == 0\nassert op_dec_padto3_min([]) == 0\nassert op_dec_padto3_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_padto3_min([5, 5, 5]) == 4\nassert op_dec_padto3_min([3, 1, 2]) == 0\nassert op_dec_padto3_min([10]) == 0\nassert op_dec_padto3_min([2, 4, 6]) == 1\nassert op_dec_padto3_min([-7, 12, -7]) == -8"}
{"id": "op_beforezero_dropfirst_len", "entry_point": "op_beforezero_dropfirst_len", "primitives": ["beforezero", "dropfirst", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then return how many remain.", "solution": "def op_beforezero_dropfirst_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return len(r)", "tests": "assert op_beforezero_dropfirst_len([1, 2, 3, 4]) == 3\nassert op_beforezero_dropfirst_len([]) == 0\nassert op_beforezero_dropfirst_len([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_dropfirst_len([5, 5, 5]) == 2\nassert op_beforezero_dropfirst_len([3, 1, 2]) == 2\nassert op_beforezero_dropfirst_len([10]) == 0\nassert op_beforezero_dropfirst_len([2, 4, 6]) == 2\nassert op_beforezero_dropfirst_len([-7, 12, -7]) == 2"}
{"id": "op_sortlen_strip_prefixup", "entry_point": "op_sortlen_strip_prefixup", "primitives": ["sortlen", "strip", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then trim whitespace from each, then prefix each with a hash.", "solution": "def op_sortlen_strip_prefixup(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_sortlen_strip_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortlen_strip_prefixup([]) == []\nassert op_sortlen_strip_prefixup(['  a ', '', 'BC', 'bc']) == ['#', '#BC', '#bc', '#a']\nassert op_sortlen_strip_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_sortlen_strip_prefixup(['x']) == ['#x']\nassert op_sortlen_strip_prefixup(['abc', 'de', '']) == ['#', '#de', '#abc']"}
{"id": "op_takewhilepos_inc_negate", "entry_point": "op_takewhilepos_inc_negate", "primitives": ["takewhilepos", "inc", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then negate each.", "solution": "def op_takewhilepos_inc_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_inc_negate([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_takewhilepos_inc_negate([]) == []\nassert op_takewhilepos_inc_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_inc_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_takewhilepos_inc_negate([3, 1, 2]) == [-4, -2, -3]\nassert op_takewhilepos_inc_negate([10]) == [-11]\nassert op_takewhilepos_inc_negate([2, 4, 6]) == [-3, -5, -7]\nassert op_takewhilepos_inc_negate([-7, 12, -7]) == []"}
{"id": "op_last3_square_absval", "entry_point": "op_last3_square_absval", "primitives": ["last3", "square", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then take the absolute value of each.", "solution": "def op_last3_square_absval(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_last3_square_absval([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_square_absval([]) == []\nassert op_last3_square_absval([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_last3_square_absval([5, 5, 5]) == [25, 25, 25]\nassert op_last3_square_absval([3, 1, 2]) == [9, 1, 4]\nassert op_last3_square_absval([10]) == [100]\nassert op_last3_square_absval([2, 4, 6]) == [4, 16, 36]\nassert op_last3_square_absval([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_neg_trimends_sortabs", "entry_point": "op_neg_trimends_sortabs", "primitives": ["neg", "trimends", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then sort by absolute value.", "solution": "def op_neg_trimends_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_trimends_sortabs([1, 2, 3, 4]) == []\nassert op_neg_trimends_sortabs([]) == []\nassert op_neg_trimends_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_sortabs([5, 5, 5]) == []\nassert op_neg_trimends_sortabs([3, 1, 2]) == []\nassert op_neg_trimends_sortabs([10]) == []\nassert op_neg_trimends_sortabs([2, 4, 6]) == []\nassert op_neg_trimends_sortabs([-7, 12, -7]) == []"}
{"id": "op_pos_absval_dropzeros", "entry_point": "op_pos_absval_dropzeros", "primitives": ["pos", "absval", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take the absolute value of each, then drop the zeros.", "solution": "def op_pos_absval_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_absval_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_absval_dropzeros([]) == []\nassert op_pos_absval_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_absval_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_absval_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_absval_dropzeros([10]) == [10]\nassert op_pos_absval_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_absval_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_pos_double_square", "entry_point": "op_pos_double_square", "primitives": ["pos", "double", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then square each.", "solution": "def op_pos_double_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_double_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_pos_double_square([]) == []\nassert op_pos_double_square([-2, -1, 0, 1, 2]) == [4, 16]\nassert op_pos_double_square([5, 5, 5]) == [100, 100, 100]\nassert op_pos_double_square([3, 1, 2]) == [36, 4, 16]\nassert op_pos_double_square([10]) == [400]\nassert op_pos_double_square([2, 4, 6]) == [16, 64, 144]\nassert op_pos_double_square([-7, 12, -7]) == [576]"}
{"id": "op_padto3_evens_takewhilepos", "entry_point": "op_padto3_evens_takewhilepos", "primitives": ["padto3", "evens", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then take values while they are positive.", "solution": "def op_padto3_evens_takewhilepos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_padto3_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_evens_takewhilepos([]) == []\nassert op_padto3_evens_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_padto3_evens_takewhilepos([5, 5, 5]) == []\nassert op_padto3_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_padto3_evens_takewhilepos([10]) == [10]\nassert op_padto3_evens_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dec_counteven", "entry_point": "op_oremptyzero_dec_counteven", "primitives": ["oremptyzero", "dec", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then return how many values are even.", "solution": "def op_oremptyzero_dec_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_dec_counteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_dec_counteven([]) == 0\nassert op_oremptyzero_dec_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_dec_counteven([5, 5, 5]) == 3\nassert op_oremptyzero_dec_counteven([3, 1, 2]) == 2\nassert op_oremptyzero_dec_counteven([10]) == 0\nassert op_oremptyzero_dec_counteven([2, 4, 6]) == 0\nassert op_oremptyzero_dec_counteven([-7, 12, -7]) == 2"}
{"id": "op_uniq_absval_max", "entry_point": "op_uniq_absval_max", "primitives": ["uniq", "absval", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_uniq_absval_max(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_uniq_absval_max([1, 2, 3, 4]) == 4\nassert op_uniq_absval_max([]) == 0\nassert op_uniq_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_absval_max([5, 5, 5]) == 5\nassert op_uniq_absval_max([3, 1, 2]) == 3\nassert op_uniq_absval_max([10]) == 10\nassert op_uniq_absval_max([2, 4, 6]) == 6\nassert op_uniq_absval_max([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_negate_min", "entry_point": "op_oremptyzero_negate_min", "primitives": ["oremptyzero", "negate", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then return the minimum (0 if empty).", "solution": "def op_oremptyzero_negate_min(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    return min(r) if r else 0", "tests": "assert op_oremptyzero_negate_min([1, 2, 3, 4]) == -4\nassert op_oremptyzero_negate_min([]) == 0\nassert op_oremptyzero_negate_min([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_negate_min([5, 5, 5]) == -5\nassert op_oremptyzero_negate_min([3, 1, 2]) == -3\nassert op_oremptyzero_negate_min([10]) == -10\nassert op_oremptyzero_negate_min([2, 4, 6]) == -6\nassert op_oremptyzero_negate_min([-7, 12, -7]) == -12"}
{"id": "op_div3_last3_negate", "entry_point": "op_div3_last3_negate", "primitives": ["div3", "last3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then negate each.", "solution": "def op_div3_last3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_div3_last3_negate([1, 2, 3, 4]) == [-3]\nassert op_div3_last3_negate([]) == []\nassert op_div3_last3_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_last3_negate([5, 5, 5]) == []\nassert op_div3_last3_negate([3, 1, 2]) == [-3]\nassert op_div3_last3_negate([10]) == []\nassert op_div3_last3_negate([2, 4, 6]) == [-6]\nassert op_div3_last3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_dropfirst_sortabs_dropzeros", "entry_point": "op_dropfirst_sortabs_dropzeros", "primitives": ["dropfirst", "sortabs", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then drop the zeros.", "solution": "def op_dropfirst_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_sortabs_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sortabs_dropzeros([]) == []\nassert op_dropfirst_sortabs_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropfirst_sortabs_dropzeros([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortabs_dropzeros([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sortabs_dropzeros([10]) == []\nassert op_dropfirst_sortabs_dropzeros([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sortabs_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropzeros_div3_beforezero", "entry_point": "op_dropzeros_div3_beforezero", "primitives": ["dropzeros", "div3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_dropzeros_div3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_div3_beforezero([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_beforezero([]) == []\nassert op_dropzeros_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_beforezero([5, 5, 5]) == []\nassert op_dropzeros_div3_beforezero([3, 1, 2]) == [3]\nassert op_dropzeros_div3_beforezero([10]) == []\nassert op_dropzeros_div3_beforezero([2, 4, 6]) == [6]\nassert op_dropzeros_div3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_absval_div3_sortabs", "entry_point": "op_absval_div3_sortabs", "primitives": ["absval", "div3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then sort by absolute value.", "solution": "def op_absval_div3_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_div3_sortabs([1, 2, 3, 4]) == [3]\nassert op_absval_div3_sortabs([]) == []\nassert op_absval_div3_sortabs([-2, -1, 0, 1, 2]) == [0]\nassert op_absval_div3_sortabs([5, 5, 5]) == []\nassert op_absval_div3_sortabs([3, 1, 2]) == [3]\nassert op_absval_div3_sortabs([10]) == []\nassert op_absval_div3_sortabs([2, 4, 6]) == [6]\nassert op_absval_div3_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_neg_double_alldistinct", "entry_point": "op_neg_double_alldistinct", "primitives": ["neg", "double", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then double each, then return whether all values are distinct.", "solution": "def op_neg_double_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_neg_double_alldistinct([1, 2, 3, 4]) == True\nassert op_neg_double_alldistinct([]) == True\nassert op_neg_double_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_neg_double_alldistinct([5, 5, 5]) == True\nassert op_neg_double_alldistinct([3, 1, 2]) == True\nassert op_neg_double_alldistinct([10]) == True\nassert op_neg_double_alldistinct([2, 4, 6]) == True\nassert op_neg_double_alldistinct([-7, 12, -7]) == False"}
{"id": "op_evens_gt5_trimends", "entry_point": "op_evens_gt5_trimends", "primitives": ["evens", "gt5", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then drop the first and last elements.", "solution": "def op_evens_gt5_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_evens_gt5_trimends([1, 2, 3, 4]) == []\nassert op_evens_gt5_trimends([]) == []\nassert op_evens_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5_trimends([5, 5, 5]) == []\nassert op_evens_gt5_trimends([3, 1, 2]) == []\nassert op_evens_gt5_trimends([10]) == []\nassert op_evens_gt5_trimends([2, 4, 6]) == []\nassert op_evens_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_square_padto3_sorta", "entry_point": "op_square_padto3_sorta", "primitives": ["square", "padto3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then sort ascending.", "solution": "def op_square_padto3_sorta(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_square_padto3_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_padto3_sorta([]) == [0, 0, 0]\nassert op_square_padto3_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_square_padto3_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_square_padto3_sorta([10]) == [0, 0, 100]\nassert op_square_padto3_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_square_padto3_sorta([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_beforezero_dec_rev", "entry_point": "op_beforezero_dec_rev", "primitives": ["beforezero", "dec", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then reverse the order.", "solution": "def op_beforezero_dec_rev(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_beforezero_dec_rev([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_beforezero_dec_rev([]) == []\nassert op_beforezero_dec_rev([-2, -1, 0, 1, 2]) == [-2, -3]\nassert op_beforezero_dec_rev([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dec_rev([3, 1, 2]) == [1, 0, 2]\nassert op_beforezero_dec_rev([10]) == [9]\nassert op_beforezero_dec_rev([2, 4, 6]) == [5, 3, 1]\nassert op_beforezero_dec_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dec_beforezero_trimends", "entry_point": "op_dec_beforezero_trimends", "primitives": ["dec", "beforezero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_dec_beforezero_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_beforezero_trimends([1, 2, 3, 4]) == []\nassert op_dec_beforezero_trimends([]) == []\nassert op_dec_beforezero_trimends([-2, -1, 0, 1, 2]) == [-2]\nassert op_dec_beforezero_trimends([5, 5, 5]) == [4]\nassert op_dec_beforezero_trimends([3, 1, 2]) == []\nassert op_dec_beforezero_trimends([10]) == []\nassert op_dec_beforezero_trimends([2, 4, 6]) == [3]\nassert op_dec_beforezero_trimends([-7, 12, -7]) == [11]"}
{"id": "op_ages_padto3_trimends", "entry_point": "op_ages_padto3_trimends", "primitives": ["ages", "padto3", "trimends"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_ages_padto3_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_padto3_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_padto3_trimends([]) == [0]\nassert op_ages_padto3_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_padto3_trimends([{'name': 'Fi', 'age': 41}]) == [0]"}
{"id": "op_sortabs_neg_absval", "entry_point": "op_sortabs_neg_absval", "primitives": ["sortabs", "neg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then take the absolute value of each.", "solution": "def op_sortabs_neg_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_neg_absval([1, 2, 3, 4]) == []\nassert op_sortabs_neg_absval([]) == []\nassert op_sortabs_neg_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_neg_absval([5, 5, 5]) == []\nassert op_sortabs_neg_absval([3, 1, 2]) == []\nassert op_sortabs_neg_absval([10]) == []\nassert op_sortabs_neg_absval([2, 4, 6]) == []\nassert op_sortabs_neg_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_dropfirst_dropwhileneg", "entry_point": "op_ages_dropfirst_dropwhileneg", "primitives": ["ages", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then drop the leading negative values.", "solution": "def op_ages_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_dropfirst_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst_dropwhileneg([]) == []\nassert op_ages_dropfirst_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropfirst_dropwhileneg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_oremptyzero_first3_sorta", "entry_point": "op_oremptyzero_first3_sorta", "primitives": ["oremptyzero", "first3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the first three, then sort ascending.", "solution": "def op_oremptyzero_first3_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_first3_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_first3_sorta([]) == [0]\nassert op_oremptyzero_first3_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_oremptyzero_first3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_first3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_first3_sorta([10]) == [10]\nassert op_oremptyzero_first3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_first3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_negate_sortd_first3", "entry_point": "op_negate_sortd_first3", "primitives": ["negate", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending, then keep only the first three.", "solution": "def op_negate_sortd_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_negate_sortd_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_sortd_first3([]) == []\nassert op_negate_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_negate_sortd_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_sortd_first3([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_sortd_first3([10]) == [-10]\nassert op_negate_sortd_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_sortd_first3([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_uniq_rev_dropwhileneg", "entry_point": "op_uniq_rev_dropwhileneg", "primitives": ["uniq", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order, then drop the leading negative values.", "solution": "def op_uniq_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_uniq_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_rev_dropwhileneg([]) == []\nassert op_uniq_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_rev_dropwhileneg([5, 5, 5]) == [5]\nassert op_uniq_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_uniq_rev_dropwhileneg([10]) == [10]\nassert op_uniq_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_rev_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_add10_clamp10_dropfirst", "entry_point": "op_add10_clamp10_dropfirst", "primitives": ["add10", "clamp10", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then drop the first element.", "solution": "def op_add10_clamp10_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_add10_clamp10_dropfirst([1, 2, 3, 4]) == [10, 10, 10]\nassert op_add10_clamp10_dropfirst([]) == []\nassert op_add10_clamp10_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 10, 10]\nassert op_add10_clamp10_dropfirst([5, 5, 5]) == [10, 10]\nassert op_add10_clamp10_dropfirst([3, 1, 2]) == [10, 10]\nassert op_add10_clamp10_dropfirst([10]) == []\nassert op_add10_clamp10_dropfirst([2, 4, 6]) == [10, 10]\nassert op_add10_clamp10_dropfirst([-7, 12, -7]) == [10, 3]"}
{"id": "op_double_pos_div3", "entry_point": "op_double_pos_div3", "primitives": ["double", "pos", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then keep multiples of three.", "solution": "def op_double_pos_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_pos_div3([1, 2, 3, 4]) == [6]\nassert op_double_pos_div3([]) == []\nassert op_double_pos_div3([-2, -1, 0, 1, 2]) == []\nassert op_double_pos_div3([5, 5, 5]) == []\nassert op_double_pos_div3([3, 1, 2]) == [6]\nassert op_double_pos_div3([10]) == []\nassert op_double_pos_div3([2, 4, 6]) == [12]\nassert op_double_pos_div3([-7, 12, -7]) == [24]"}
{"id": "op_trimends_last3_inc", "entry_point": "op_trimends_last3_inc", "primitives": ["trimends", "last3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then add one to each.", "solution": "def op_trimends_last3_inc(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_trimends_last3_inc([1, 2, 3, 4]) == [3, 4]\nassert op_trimends_last3_inc([]) == []\nassert op_trimends_last3_inc([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_trimends_last3_inc([5, 5, 5]) == [6]\nassert op_trimends_last3_inc([3, 1, 2]) == [2]\nassert op_trimends_last3_inc([10]) == []\nassert op_trimends_last3_inc([2, 4, 6]) == [5]\nassert op_trimends_last3_inc([-7, 12, -7]) == [13]"}
{"id": "op_dropzeros_sorta_anyeven", "entry_point": "op_dropzeros_sorta_anyeven", "primitives": ["dropzeros", "sorta", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then return whether any value is even.", "solution": "def op_dropzeros_sorta_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_sorta_anyeven([]) == False\nassert op_dropzeros_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_sorta_anyeven([5, 5, 5]) == False\nassert op_dropzeros_sorta_anyeven([3, 1, 2]) == True\nassert op_dropzeros_sorta_anyeven([10]) == True\nassert op_dropzeros_sorta_anyeven([2, 4, 6]) == True\nassert op_dropzeros_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_dec_div3_neg", "entry_point": "op_dec_div3_neg", "primitives": ["dec", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three, then keep the negative numbers.", "solution": "def op_dec_div3_neg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dec_div3_neg([1, 2, 3, 4]) == []\nassert op_dec_div3_neg([]) == []\nassert op_dec_div3_neg([-2, -1, 0, 1, 2]) == [-3]\nassert op_dec_div3_neg([5, 5, 5]) == []\nassert op_dec_div3_neg([3, 1, 2]) == []\nassert op_dec_div3_neg([10]) == []\nassert op_dec_div3_neg([2, 4, 6]) == []\nassert op_dec_div3_neg([-7, 12, -7]) == []"}
{"id": "op_odds_pos_sortd", "entry_point": "op_odds_pos_sortd", "primitives": ["odds", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then sort descending.", "solution": "def op_odds_pos_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_pos_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_odds_pos_sortd([]) == []\nassert op_odds_pos_sortd([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_odds_pos_sortd([3, 1, 2]) == [3, 1]\nassert op_odds_pos_sortd([10]) == []\nassert op_odds_pos_sortd([2, 4, 6]) == []\nassert op_odds_pos_sortd([-7, 12, -7]) == []"}
{"id": "op_first3_evens_add10", "entry_point": "op_first3_evens_add10", "primitives": ["first3", "evens", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the even numbers, then add ten to each.", "solution": "def op_first3_evens_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_evens_add10([1, 2, 3, 4]) == [12]\nassert op_first3_evens_add10([]) == []\nassert op_first3_evens_add10([-2, -1, 0, 1, 2]) == [8, 10]\nassert op_first3_evens_add10([5, 5, 5]) == []\nassert op_first3_evens_add10([3, 1, 2]) == [12]\nassert op_first3_evens_add10([10]) == [20]\nassert op_first3_evens_add10([2, 4, 6]) == [12, 14, 16]\nassert op_first3_evens_add10([-7, 12, -7]) == [22]"}
{"id": "op_beforezero_dropzeros_negate", "entry_point": "op_beforezero_dropzeros_negate", "primitives": ["beforezero", "dropzeros", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then negate each.", "solution": "def op_beforezero_dropzeros_negate(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_beforezero_dropzeros_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_beforezero_dropzeros_negate([]) == []\nassert op_beforezero_dropzeros_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_dropzeros_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_beforezero_dropzeros_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_beforezero_dropzeros_negate([10]) == [-10]\nassert op_beforezero_dropzeros_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_beforezero_dropzeros_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_ages_sortabs_dropwhileneg", "entry_point": "op_ages_sortabs_dropwhileneg", "primitives": ["ages", "sortabs", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value, then drop the leading negative values.", "solution": "def op_ages_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_sortabs_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sortabs_dropwhileneg([]) == []\nassert op_ages_sortabs_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sortabs_dropwhileneg([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_first3_trimends_inc", "entry_point": "op_first3_trimends_inc", "primitives": ["first3", "trimends", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then add one to each.", "solution": "def op_first3_trimends_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_trimends_inc([1, 2, 3, 4]) == [3]\nassert op_first3_trimends_inc([]) == []\nassert op_first3_trimends_inc([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_trimends_inc([5, 5, 5]) == [6]\nassert op_first3_trimends_inc([3, 1, 2]) == [2]\nassert op_first3_trimends_inc([10]) == []\nassert op_first3_trimends_inc([2, 4, 6]) == [5]\nassert op_first3_trimends_inc([-7, 12, -7]) == [13]"}
{"id": "op_ages_add10_min", "entry_point": "op_ages_add10_min", "primitives": ["ages", "add10", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_ages_add10_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_ages_add10_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 22\nassert op_ages_add10_min([]) == 0\nassert op_ages_add10_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 27\nassert op_ages_add10_min([{'name': 'Fi', 'age': 41}]) == 51"}
{"id": "op_oremptyzero_absval_add10", "entry_point": "op_oremptyzero_absval_add10", "primitives": ["oremptyzero", "absval", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take the absolute value of each, then add ten to each.", "solution": "def op_oremptyzero_absval_add10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_oremptyzero_absval_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_oremptyzero_absval_add10([]) == [10]\nassert op_oremptyzero_absval_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 11, 12]\nassert op_oremptyzero_absval_add10([5, 5, 5]) == [15, 15, 15]\nassert op_oremptyzero_absval_add10([3, 1, 2]) == [13, 11, 12]\nassert op_oremptyzero_absval_add10([10]) == [20]\nassert op_oremptyzero_absval_add10([2, 4, 6]) == [12, 14, 16]\nassert op_oremptyzero_absval_add10([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_inc_evens_square", "entry_point": "op_inc_evens_square", "primitives": ["inc", "evens", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then square each.", "solution": "def op_inc_evens_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_inc_evens_square([]) == []\nassert op_inc_evens_square([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_inc_evens_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_evens_square([3, 1, 2]) == [16, 4]\nassert op_inc_evens_square([10]) == []\nassert op_inc_evens_square([2, 4, 6]) == []\nassert op_inc_evens_square([-7, 12, -7]) == [36, 36]"}
{"id": "op_add10_rev_last3", "entry_point": "op_add10_rev_last3", "primitives": ["add10", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then keep only the last three.", "solution": "def op_add10_rev_last3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_add10_rev_last3([1, 2, 3, 4]) == [13, 12, 11]\nassert op_add10_rev_last3([]) == []\nassert op_add10_rev_last3([-2, -1, 0, 1, 2]) == [10, 9, 8]\nassert op_add10_rev_last3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_rev_last3([3, 1, 2]) == [12, 11, 13]\nassert op_add10_rev_last3([10]) == [20]\nassert op_add10_rev_last3([2, 4, 6]) == [16, 14, 12]\nassert op_add10_rev_last3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_negate_takewhilepos_max", "entry_point": "op_negate_takewhilepos_max", "primitives": ["negate", "takewhilepos", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_negate_takewhilepos_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_negate_takewhilepos_max([1, 2, 3, 4]) == 0\nassert op_negate_takewhilepos_max([]) == 0\nassert op_negate_takewhilepos_max([-2, -1, 0, 1, 2]) == 2\nassert op_negate_takewhilepos_max([5, 5, 5]) == 0\nassert op_negate_takewhilepos_max([3, 1, 2]) == 0\nassert op_negate_takewhilepos_max([10]) == 0\nassert op_negate_takewhilepos_max([2, 4, 6]) == 0\nassert op_negate_takewhilepos_max([-7, 12, -7]) == 7"}
{"id": "op_sortabs_takewhilepos_issorted", "entry_point": "op_sortabs_takewhilepos_issorted", "primitives": ["sortabs", "takewhilepos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_sortabs_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_sortabs_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_takewhilepos_issorted([]) == True\nassert op_sortabs_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_takewhilepos_issorted([5, 5, 5]) == True\nassert op_sortabs_takewhilepos_issorted([3, 1, 2]) == True\nassert op_sortabs_takewhilepos_issorted([10]) == True\nassert op_sortabs_takewhilepos_issorted([2, 4, 6]) == True\nassert op_sortabs_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_sorta_pos", "entry_point": "op_oremptyzero_sorta_pos", "primitives": ["oremptyzero", "sorta", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then keep the positive numbers.", "solution": "def op_oremptyzero_sorta_pos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_oremptyzero_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sorta_pos([]) == []\nassert op_oremptyzero_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_oremptyzero_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sorta_pos([10]) == [10]\nassert op_oremptyzero_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_double_rev_min", "entry_point": "op_double_rev_min", "primitives": ["double", "rev", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_double_rev_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_double_rev_min([1, 2, 3, 4]) == 2\nassert op_double_rev_min([]) == 0\nassert op_double_rev_min([-2, -1, 0, 1, 2]) == -4\nassert op_double_rev_min([5, 5, 5]) == 10\nassert op_double_rev_min([3, 1, 2]) == 2\nassert op_double_rev_min([10]) == 20\nassert op_double_rev_min([2, 4, 6]) == 4\nassert op_double_rev_min([-7, 12, -7]) == -14"}
{"id": "op_beforezero_gt5_last3", "entry_point": "op_beforezero_gt5_last3", "primitives": ["beforezero", "gt5", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then keep only the last three.", "solution": "def op_beforezero_gt5_last3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    return r", "tests": "assert op_beforezero_gt5_last3([1, 2, 3, 4]) == []\nassert op_beforezero_gt5_last3([]) == []\nassert op_beforezero_gt5_last3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5_last3([5, 5, 5]) == []\nassert op_beforezero_gt5_last3([3, 1, 2]) == []\nassert op_beforezero_gt5_last3([10]) == [10]\nassert op_beforezero_gt5_last3([2, 4, 6]) == [6]\nassert op_beforezero_gt5_last3([-7, 12, -7]) == [12]"}
{"id": "op_neg_absval_oremptyzero", "entry_point": "op_neg_absval_oremptyzero", "primitives": ["neg", "absval", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_neg_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_neg_absval_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_neg_absval_oremptyzero([]) == [0]\nassert op_neg_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_absval_oremptyzero([5, 5, 5]) == [0]\nassert op_neg_absval_oremptyzero([3, 1, 2]) == [0]\nassert op_neg_absval_oremptyzero([10]) == [0]\nassert op_neg_absval_oremptyzero([2, 4, 6]) == [0]\nassert op_neg_absval_oremptyzero([-7, 12, -7]) == [7, 7]"}
{"id": "op_sortd_dropzeros_first3", "entry_point": "op_sortd_dropzeros_first3", "primitives": ["sortd", "dropzeros", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then keep only the first three.", "solution": "def op_sortd_dropzeros_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_sortd_dropzeros_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortd_dropzeros_first3([]) == []\nassert op_sortd_dropzeros_first3([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_sortd_dropzeros_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropzeros_first3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropzeros_first3([10]) == [10]\nassert op_sortd_dropzeros_first3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropzeros_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_nonempty_firstchar_joinc", "entry_point": "op_nonempty_firstchar_joinc", "primitives": ["nonempty", "firstchar", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then keep the first character of each (dropping empties), then join them with commas.", "solution": "def op_nonempty_firstchar_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    return ','.join(r)", "tests": "assert op_nonempty_firstchar_joinc(['Hello', 'world']) == 'H,w'\nassert op_nonempty_firstchar_joinc([]) == ''\nassert op_nonempty_firstchar_joinc(['  a ', '', 'BC', 'bc']) == ' ,B,b'\nassert op_nonempty_firstchar_joinc(['one', 'one', 'Two']) == 'o,o,T'\nassert op_nonempty_firstchar_joinc(['x']) == 'x'\nassert op_nonempty_firstchar_joinc(['abc', 'de', '']) == 'a,d'"}
{"id": "op_inc_neg_counteven", "entry_point": "op_inc_neg_counteven", "primitives": ["inc", "neg", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then return how many values are even.", "solution": "def op_inc_neg_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_neg_counteven([1, 2, 3, 4]) == 0\nassert op_inc_neg_counteven([]) == 0\nassert op_inc_neg_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_inc_neg_counteven([5, 5, 5]) == 0\nassert op_inc_neg_counteven([3, 1, 2]) == 0\nassert op_inc_neg_counteven([10]) == 0\nassert op_inc_neg_counteven([2, 4, 6]) == 0\nassert op_inc_neg_counteven([-7, 12, -7]) == 2"}
{"id": "op_sorta_trimends_first3", "entry_point": "op_sorta_trimends_first3", "primitives": ["sorta", "trimends", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then keep only the first three.", "solution": "def op_sorta_trimends_first3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_sorta_trimends_first3([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_trimends_first3([]) == []\nassert op_sorta_trimends_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sorta_trimends_first3([5, 5, 5]) == [5]\nassert op_sorta_trimends_first3([3, 1, 2]) == [2]\nassert op_sorta_trimends_first3([10]) == []\nassert op_sorta_trimends_first3([2, 4, 6]) == [4]\nassert op_sorta_trimends_first3([-7, 12, -7]) == [-7]"}
{"id": "op_oremptyzero_negate_double", "entry_point": "op_oremptyzero_negate_double", "primitives": ["oremptyzero", "negate", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then double each.", "solution": "def op_oremptyzero_negate_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_negate_double([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_oremptyzero_negate_double([]) == [0]\nassert op_oremptyzero_negate_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_oremptyzero_negate_double([5, 5, 5]) == [-10, -10, -10]\nassert op_oremptyzero_negate_double([3, 1, 2]) == [-6, -2, -4]\nassert op_oremptyzero_negate_double([10]) == [-20]\nassert op_oremptyzero_negate_double([2, 4, 6]) == [-4, -8, -12]\nassert op_oremptyzero_negate_double([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_pos_dropwhileneg_gt5", "entry_point": "op_pos_dropwhileneg_gt5", "primitives": ["pos", "dropwhileneg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then keep values greater than five.", "solution": "def op_pos_dropwhileneg_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_pos_dropwhileneg_gt5([1, 2, 3, 4]) == []\nassert op_pos_dropwhileneg_gt5([]) == []\nassert op_pos_dropwhileneg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_pos_dropwhileneg_gt5([5, 5, 5]) == []\nassert op_pos_dropwhileneg_gt5([3, 1, 2]) == []\nassert op_pos_dropwhileneg_gt5([10]) == [10]\nassert op_pos_dropwhileneg_gt5([2, 4, 6]) == [6]\nassert op_pos_dropwhileneg_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dec_dropzeros_clamp10", "entry_point": "op_dec_dropzeros_clamp10", "primitives": ["dec", "dropzeros", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then cap each value at 10.", "solution": "def op_dec_dropzeros_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_dropzeros_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_dropzeros_clamp10([]) == []\nassert op_dec_dropzeros_clamp10([-2, -1, 0, 1, 2]) == [-3, -2, -1, 1]\nassert op_dec_dropzeros_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropzeros_clamp10([3, 1, 2]) == [2, 1]\nassert op_dec_dropzeros_clamp10([10]) == [9]\nassert op_dec_dropzeros_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dec_dropzeros_clamp10([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_dropzeros_sorta_negate", "entry_point": "op_dropzeros_sorta_negate", "primitives": ["dropzeros", "sorta", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then negate each.", "solution": "def op_dropzeros_sorta_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropzeros_sorta_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropzeros_sorta_negate([]) == []\nassert op_dropzeros_sorta_negate([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_sorta_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_sorta_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_dropzeros_sorta_negate([10]) == [-10]\nassert op_dropzeros_sorta_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_sorta_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_odds_dropfirst_trimends", "entry_point": "op_odds_dropfirst_trimends", "primitives": ["odds", "dropfirst", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element, then drop the first and last elements.", "solution": "def op_odds_dropfirst_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_dropfirst_trimends([1, 2, 3, 4]) == []\nassert op_odds_dropfirst_trimends([]) == []\nassert op_odds_dropfirst_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_dropfirst_trimends([5, 5, 5]) == []\nassert op_odds_dropfirst_trimends([3, 1, 2]) == []\nassert op_odds_dropfirst_trimends([10]) == []\nassert op_odds_dropfirst_trimends([2, 4, 6]) == []\nassert op_odds_dropfirst_trimends([-7, 12, -7]) == []"}
{"id": "op_dropzeros_dropwhileneg_double", "entry_point": "op_dropzeros_dropwhileneg_double", "primitives": ["dropzeros", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then double each.", "solution": "def op_dropzeros_dropwhileneg_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_dropwhileneg_double([]) == []\nassert op_dropzeros_dropwhileneg_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_dropzeros_dropwhileneg_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_dropwhileneg_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_dropwhileneg_double([10]) == [20]\nassert op_dropzeros_dropwhileneg_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_dropwhileneg_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_oremptyzero_inc_trimends", "entry_point": "op_oremptyzero_inc_trimends", "primitives": ["oremptyzero", "inc", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each, then drop the first and last elements.", "solution": "def op_oremptyzero_inc_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_inc_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_oremptyzero_inc_trimends([]) == []\nassert op_oremptyzero_inc_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_inc_trimends([5, 5, 5]) == [6]\nassert op_oremptyzero_inc_trimends([3, 1, 2]) == [2]\nassert op_oremptyzero_inc_trimends([10]) == []\nassert op_oremptyzero_inc_trimends([2, 4, 6]) == [5]\nassert op_oremptyzero_inc_trimends([-7, 12, -7]) == [13]"}
{"id": "op_ages_add10_counteven", "entry_point": "op_ages_add10_counteven", "primitives": ["ages", "add10", "counteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then return how many values are even.", "solution": "def op_ages_add10_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_add10_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_add10_counteven([]) == 0\nassert op_ages_add10_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_ages_add10_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_trimends_add10_counteven", "entry_point": "op_trimends_add10_counteven", "primitives": ["trimends", "add10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then return how many values are even.", "solution": "def op_trimends_add10_counteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_trimends_add10_counteven([1, 2, 3, 4]) == 1\nassert op_trimends_add10_counteven([]) == 0\nassert op_trimends_add10_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_add10_counteven([5, 5, 5]) == 0\nassert op_trimends_add10_counteven([3, 1, 2]) == 0\nassert op_trimends_add10_counteven([10]) == 0\nassert op_trimends_add10_counteven([2, 4, 6]) == 1\nassert op_trimends_add10_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_uniq_haszero", "entry_point": "op_rev_uniq_haszero", "primitives": ["rev", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_rev_uniq_haszero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_rev_uniq_haszero([1, 2, 3, 4]) == False\nassert op_rev_uniq_haszero([]) == False\nassert op_rev_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_rev_uniq_haszero([5, 5, 5]) == False\nassert op_rev_uniq_haszero([3, 1, 2]) == False\nassert op_rev_uniq_haszero([10]) == False\nassert op_rev_uniq_haszero([2, 4, 6]) == False\nassert op_rev_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_ages_absval_add10", "entry_point": "op_ages_absval_add10", "primitives": ["ages", "absval", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then add ten to each.", "solution": "def op_ages_absval_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_absval_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_absval_add10([]) == []\nassert op_ages_absval_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_absval_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_strip_sortlen_longest", "entry_point": "op_strip_sortlen_longest", "primitives": ["strip", "sortlen", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first, then return the longest string (empty if none).", "solution": "def op_strip_sortlen_longest(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return max(r, key=len) if r else ''", "tests": "assert op_strip_sortlen_longest(['Hello', 'world']) == 'Hello'\nassert op_strip_sortlen_longest([]) == ''\nassert op_strip_sortlen_longest(['  a ', '', 'BC', 'bc']) == 'BC'\nassert op_strip_sortlen_longest(['one', 'one', 'Two']) == 'one'\nassert op_strip_sortlen_longest(['x']) == 'x'\nassert op_strip_sortlen_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_dropzeros_rev_issorted", "entry_point": "op_dropzeros_rev_issorted", "primitives": ["dropzeros", "rev", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_rev_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r == sorted(r)", "tests": "assert op_dropzeros_rev_issorted([1, 2, 3, 4]) == False\nassert op_dropzeros_rev_issorted([]) == True\nassert op_dropzeros_rev_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_rev_issorted([5, 5, 5]) == True\nassert op_dropzeros_rev_issorted([3, 1, 2]) == False\nassert op_dropzeros_rev_issorted([10]) == True\nassert op_dropzeros_rev_issorted([2, 4, 6]) == False\nassert op_dropzeros_rev_issorted([-7, 12, -7]) == False"}
{"id": "op_padto3_rev_allpos", "entry_point": "op_padto3_rev_allpos", "primitives": ["padto3", "rev", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order, then return whether all values are positive.", "solution": "def op_padto3_rev_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_rev_allpos([1, 2, 3, 4]) == True\nassert op_padto3_rev_allpos([]) == False\nassert op_padto3_rev_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_rev_allpos([5, 5, 5]) == True\nassert op_padto3_rev_allpos([3, 1, 2]) == True\nassert op_padto3_rev_allpos([10]) == False\nassert op_padto3_rev_allpos([2, 4, 6]) == True\nassert op_padto3_rev_allpos([-7, 12, -7]) == False"}
{"id": "op_negate_oremptyzero_len", "entry_point": "op_negate_oremptyzero_len", "primitives": ["negate", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then return how many remain.", "solution": "def op_negate_oremptyzero_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_negate_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_negate_oremptyzero_len([]) == 1\nassert op_negate_oremptyzero_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_oremptyzero_len([5, 5, 5]) == 3\nassert op_negate_oremptyzero_len([3, 1, 2]) == 3\nassert op_negate_oremptyzero_len([10]) == 1\nassert op_negate_oremptyzero_len([2, 4, 6]) == 3\nassert op_negate_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_padto3_uniq_prod", "entry_point": "op_padto3_uniq_prod", "primitives": ["padto3", "uniq", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return their product.", "solution": "def op_padto3_uniq_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_padto3_uniq_prod([1, 2, 3, 4]) == 24\nassert op_padto3_uniq_prod([]) == 0\nassert op_padto3_uniq_prod([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_uniq_prod([5, 5, 5]) == 5\nassert op_padto3_uniq_prod([3, 1, 2]) == 6\nassert op_padto3_uniq_prod([10]) == 0\nassert op_padto3_uniq_prod([2, 4, 6]) == 48\nassert op_padto3_uniq_prod([-7, 12, -7]) == -84"}
{"id": "op_inc_double_padto3", "entry_point": "op_inc_double_padto3", "primitives": ["inc", "double", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then pad with zeros to at least three elements.", "solution": "def op_inc_double_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_double_padto3([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_double_padto3([]) == [0, 0, 0]\nassert op_inc_double_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4, 6]\nassert op_inc_double_padto3([5, 5, 5]) == [12, 12, 12]\nassert op_inc_double_padto3([3, 1, 2]) == [8, 4, 6]\nassert op_inc_double_padto3([10]) == [22, 0, 0]\nassert op_inc_double_padto3([2, 4, 6]) == [6, 10, 14]\nassert op_inc_double_padto3([-7, 12, -7]) == [-12, 26, -12]"}
{"id": "op_negate_absval_clamp10", "entry_point": "op_negate_absval_clamp10", "primitives": ["negate", "absval", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then cap each value at 10.", "solution": "def op_negate_absval_clamp10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_negate_absval_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval_clamp10([]) == []\nassert op_negate_absval_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_negate_absval_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval_clamp10([10]) == [10]\nassert op_negate_absval_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_sortabs_evens_square", "entry_point": "op_sortabs_evens_square", "primitives": ["sortabs", "evens", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then square each.", "solution": "def op_sortabs_evens_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_sortabs_evens_square([]) == []\nassert op_sortabs_evens_square([-2, -1, 0, 1, 2]) == [0, 4, 4]\nassert op_sortabs_evens_square([5, 5, 5]) == []\nassert op_sortabs_evens_square([3, 1, 2]) == [4]\nassert op_sortabs_evens_square([10]) == [100]\nassert op_sortabs_evens_square([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_dropfirst_double_min", "entry_point": "op_dropfirst_double_min", "primitives": ["dropfirst", "double", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then double each, then return the minimum (0 if empty).", "solution": "def op_dropfirst_double_min(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dropfirst_double_min([1, 2, 3, 4]) == 4\nassert op_dropfirst_double_min([]) == 0\nassert op_dropfirst_double_min([-2, -1, 0, 1, 2]) == -2\nassert op_dropfirst_double_min([5, 5, 5]) == 10\nassert op_dropfirst_double_min([3, 1, 2]) == 2\nassert op_dropfirst_double_min([10]) == 0\nassert op_dropfirst_double_min([2, 4, 6]) == 8\nassert op_dropfirst_double_min([-7, 12, -7]) == -14"}
{"id": "op_add10_square_max", "entry_point": "op_add10_square_max", "primitives": ["add10", "square", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then return the maximum (0 if empty).", "solution": "def op_add10_square_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_add10_square_max([1, 2, 3, 4]) == 196\nassert op_add10_square_max([]) == 0\nassert op_add10_square_max([-2, -1, 0, 1, 2]) == 144\nassert op_add10_square_max([5, 5, 5]) == 225\nassert op_add10_square_max([3, 1, 2]) == 169\nassert op_add10_square_max([10]) == 400\nassert op_add10_square_max([2, 4, 6]) == 256\nassert op_add10_square_max([-7, 12, -7]) == 484"}
{"id": "op_rev_neg_prod", "entry_point": "op_rev_neg_prod", "primitives": ["rev", "neg", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers, then return their product.", "solution": "def op_rev_neg_prod(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_rev_neg_prod([1, 2, 3, 4]) == 1\nassert op_rev_neg_prod([]) == 1\nassert op_rev_neg_prod([-2, -1, 0, 1, 2]) == 2\nassert op_rev_neg_prod([5, 5, 5]) == 1\nassert op_rev_neg_prod([3, 1, 2]) == 1\nassert op_rev_neg_prod([10]) == 1\nassert op_rev_neg_prod([2, 4, 6]) == 1\nassert op_rev_neg_prod([-7, 12, -7]) == 49"}
{"id": "op_square_div3_neg", "entry_point": "op_square_div3_neg", "primitives": ["square", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then keep the negative numbers.", "solution": "def op_square_div3_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_div3_neg([1, 2, 3, 4]) == []\nassert op_square_div3_neg([]) == []\nassert op_square_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_div3_neg([5, 5, 5]) == []\nassert op_square_div3_neg([3, 1, 2]) == []\nassert op_square_div3_neg([10]) == []\nassert op_square_div3_neg([2, 4, 6]) == []\nassert op_square_div3_neg([-7, 12, -7]) == []"}
{"id": "op_first3_absval_issorted", "entry_point": "op_first3_absval_issorted", "primitives": ["first3", "absval", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take the absolute value of each, then return whether the list is sorted ascending.", "solution": "def op_first3_absval_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r == sorted(r)", "tests": "assert op_first3_absval_issorted([1, 2, 3, 4]) == True\nassert op_first3_absval_issorted([]) == True\nassert op_first3_absval_issorted([-2, -1, 0, 1, 2]) == False\nassert op_first3_absval_issorted([5, 5, 5]) == True\nassert op_first3_absval_issorted([3, 1, 2]) == False\nassert op_first3_absval_issorted([10]) == True\nassert op_first3_absval_issorted([2, 4, 6]) == True\nassert op_first3_absval_issorted([-7, 12, -7]) == False"}
{"id": "op_add10_takewhilepos_len", "entry_point": "op_add10_takewhilepos_len", "primitives": ["add10", "takewhilepos", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then return how many remain.", "solution": "def op_add10_takewhilepos_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_add10_takewhilepos_len([1, 2, 3, 4]) == 4\nassert op_add10_takewhilepos_len([]) == 0\nassert op_add10_takewhilepos_len([-2, -1, 0, 1, 2]) == 5\nassert op_add10_takewhilepos_len([5, 5, 5]) == 3\nassert op_add10_takewhilepos_len([3, 1, 2]) == 3\nassert op_add10_takewhilepos_len([10]) == 1\nassert op_add10_takewhilepos_len([2, 4, 6]) == 3\nassert op_add10_takewhilepos_len([-7, 12, -7]) == 3"}
{"id": "op_padto3_double_allpos", "entry_point": "op_padto3_double_allpos", "primitives": ["padto3", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then return whether all values are positive.", "solution": "def op_padto3_double_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_double_allpos([1, 2, 3, 4]) == True\nassert op_padto3_double_allpos([]) == False\nassert op_padto3_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_double_allpos([5, 5, 5]) == True\nassert op_padto3_double_allpos([3, 1, 2]) == True\nassert op_padto3_double_allpos([10]) == False\nassert op_padto3_double_allpos([2, 4, 6]) == True\nassert op_padto3_double_allpos([-7, 12, -7]) == False"}
{"id": "op_ages_add10_dec", "entry_point": "op_ages_add10_dec", "primitives": ["ages", "add10", "dec"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then subtract one from each.", "solution": "def op_ages_add10_dec(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_ages_add10_dec([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [45, 21]\nassert op_ages_add10_dec([]) == []\nassert op_ages_add10_dec([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [27, 74, 26]\nassert op_ages_add10_dec([{'name': 'Fi', 'age': 41}]) == [50]"}
{"id": "op_sortabs_sortd_pos", "entry_point": "op_sortabs_sortd_pos", "primitives": ["sortabs", "sortd", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort descending, then keep the positive numbers.", "solution": "def op_sortabs_sortd_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_sortd_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_sortd_pos([]) == []\nassert op_sortabs_sortd_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortabs_sortd_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sortd_pos([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_sortd_pos([10]) == [10]\nassert op_sortabs_sortd_pos([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_sortd_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_square_neg", "entry_point": "op_dropwhileneg_square_neg", "primitives": ["dropwhileneg", "square", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then keep the negative numbers.", "solution": "def op_dropwhileneg_square_neg(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropwhileneg_square_neg([1, 2, 3, 4]) == []\nassert op_dropwhileneg_square_neg([]) == []\nassert op_dropwhileneg_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_square_neg([5, 5, 5]) == []\nassert op_dropwhileneg_square_neg([3, 1, 2]) == []\nassert op_dropwhileneg_square_neg([10]) == []\nassert op_dropwhileneg_square_neg([2, 4, 6]) == []\nassert op_dropwhileneg_square_neg([-7, 12, -7]) == []"}
{"id": "op_uniq_odds_absval", "entry_point": "op_uniq_odds_absval", "primitives": ["uniq", "odds", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then take the absolute value of each.", "solution": "def op_uniq_odds_absval(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_uniq_odds_absval([1, 2, 3, 4]) == [1, 3]\nassert op_uniq_odds_absval([]) == []\nassert op_uniq_odds_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_uniq_odds_absval([5, 5, 5]) == [5]\nassert op_uniq_odds_absval([3, 1, 2]) == [3, 1]\nassert op_uniq_odds_absval([10]) == []\nassert op_uniq_odds_absval([2, 4, 6]) == []\nassert op_uniq_odds_absval([-7, 12, -7]) == [7]"}
{"id": "op_dropfirst_clamp10_rev", "entry_point": "op_dropfirst_clamp10_rev", "primitives": ["dropfirst", "clamp10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then reverse the order.", "solution": "def op_dropfirst_clamp10_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_clamp10_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_clamp10_rev([]) == []\nassert op_dropfirst_clamp10_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_clamp10_rev([5, 5, 5]) == [5, 5]\nassert op_dropfirst_clamp10_rev([3, 1, 2]) == [2, 1]\nassert op_dropfirst_clamp10_rev([10]) == []\nassert op_dropfirst_clamp10_rev([2, 4, 6]) == [6, 4]\nassert op_dropfirst_clamp10_rev([-7, 12, -7]) == [-7, 10]"}
{"id": "op_dropfirst_evens_counteven", "entry_point": "op_dropfirst_evens_counteven", "primitives": ["dropfirst", "evens", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then return how many values are even.", "solution": "def op_dropfirst_evens_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_evens_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_evens_counteven([]) == 0\nassert op_dropfirst_evens_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_evens_counteven([5, 5, 5]) == 0\nassert op_dropfirst_evens_counteven([3, 1, 2]) == 1\nassert op_dropfirst_evens_counteven([10]) == 0\nassert op_dropfirst_evens_counteven([2, 4, 6]) == 2\nassert op_dropfirst_evens_counteven([-7, 12, -7]) == 1"}
{"id": "op_absval_dropfirst_padto3", "entry_point": "op_absval_dropfirst_padto3", "primitives": ["absval", "dropfirst", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_absval_dropfirst_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_dropfirst_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_dropfirst_padto3([]) == [0, 0, 0]\nassert op_absval_dropfirst_padto3([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_absval_dropfirst_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_absval_dropfirst_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_absval_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_absval_dropfirst_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_absval_dropfirst_padto3([-7, 12, -7]) == [12, 7, 0]"}
{"id": "op_clamp10_negate_oremptyzero", "entry_point": "op_clamp10_negate_oremptyzero", "primitives": ["clamp10", "negate", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then if empty, use a single zero.", "solution": "def op_clamp10_negate_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_negate_oremptyzero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_clamp10_negate_oremptyzero([]) == [0]\nassert op_clamp10_negate_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_negate_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_clamp10_negate_oremptyzero([3, 1, 2]) == [-3, -1, -2]\nassert op_clamp10_negate_oremptyzero([10]) == [-10]\nassert op_clamp10_negate_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_clamp10_negate_oremptyzero([-7, 12, -7]) == [7, -10, 7]"}
{"id": "op_sortabs_dropzeros_beforezero", "entry_point": "op_sortabs_dropzeros_beforezero", "primitives": ["sortabs", "dropzeros", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then keep everything before the first zero.", "solution": "def op_sortabs_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortabs_dropzeros_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_dropzeros_beforezero([]) == []\nassert op_sortabs_dropzeros_beforezero([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_dropzeros_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_dropzeros_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_dropzeros_beforezero([10]) == [10]\nassert op_sortabs_dropzeros_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropzeros_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_negate_oremptyzero_odds", "entry_point": "op_negate_oremptyzero_odds", "primitives": ["negate", "oremptyzero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then keep the odd numbers.", "solution": "def op_negate_oremptyzero_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_oremptyzero_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_oremptyzero_odds([]) == []\nassert op_negate_oremptyzero_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_oremptyzero_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_oremptyzero_odds([3, 1, 2]) == [-3, -1]\nassert op_negate_oremptyzero_odds([10]) == []\nassert op_negate_oremptyzero_odds([2, 4, 6]) == []\nassert op_negate_oremptyzero_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropzeros_evens_beforezero", "entry_point": "op_dropzeros_evens_beforezero", "primitives": ["dropzeros", "evens", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_dropzeros_evens_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropzeros_evens_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_dropzeros_evens_beforezero([]) == []\nassert op_dropzeros_evens_beforezero([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_dropzeros_evens_beforezero([5, 5, 5]) == []\nassert op_dropzeros_evens_beforezero([3, 1, 2]) == [2]\nassert op_dropzeros_evens_beforezero([10]) == [10]\nassert op_dropzeros_evens_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_square_padto3_dropfirst", "entry_point": "op_square_padto3_dropfirst", "primitives": ["square", "padto3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_square_padto3_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_square_padto3_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_padto3_dropfirst([]) == [0, 0]\nassert op_square_padto3_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_square_padto3_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_padto3_dropfirst([3, 1, 2]) == [1, 4]\nassert op_square_padto3_dropfirst([10]) == [0, 0]\nassert op_square_padto3_dropfirst([2, 4, 6]) == [16, 36]\nassert op_square_padto3_dropfirst([-7, 12, -7]) == [144, 49]"}
{"id": "op_first3_oremptyzero_sortd", "entry_point": "op_first3_oremptyzero_sortd", "primitives": ["first3", "oremptyzero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then sort descending.", "solution": "def op_first3_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_oremptyzero_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_oremptyzero_sortd([]) == [0]\nassert op_first3_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_oremptyzero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_first3_oremptyzero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_first3_oremptyzero_sortd([10]) == [10]\nassert op_first3_oremptyzero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_first3_oremptyzero_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_inc_dropzeros_allpos", "entry_point": "op_inc_dropzeros_allpos", "primitives": ["inc", "dropzeros", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then return whether all values are positive.", "solution": "def op_inc_dropzeros_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_inc_dropzeros_allpos([]) == True\nassert op_inc_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_dropzeros_allpos([5, 5, 5]) == True\nassert op_inc_dropzeros_allpos([3, 1, 2]) == True\nassert op_inc_dropzeros_allpos([10]) == True\nassert op_inc_dropzeros_allpos([2, 4, 6]) == True\nassert op_inc_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_rev_anyeven", "entry_point": "op_div3_rev_anyeven", "primitives": ["div3", "rev", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then return whether any value is even.", "solution": "def op_div3_rev_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_rev_anyeven([1, 2, 3, 4]) == False\nassert op_div3_rev_anyeven([]) == False\nassert op_div3_rev_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_div3_rev_anyeven([5, 5, 5]) == False\nassert op_div3_rev_anyeven([3, 1, 2]) == False\nassert op_div3_rev_anyeven([10]) == False\nassert op_div3_rev_anyeven([2, 4, 6]) == True\nassert op_div3_rev_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_sortabs_alldistinct", "entry_point": "op_trimends_sortabs_alldistinct", "primitives": ["trimends", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_trimends_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_trimends_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_sortabs_alldistinct([]) == True\nassert op_trimends_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_sortabs_alldistinct([5, 5, 5]) == True\nassert op_trimends_sortabs_alldistinct([3, 1, 2]) == True\nassert op_trimends_sortabs_alldistinct([10]) == True\nassert op_trimends_sortabs_alldistinct([2, 4, 6]) == True\nassert op_trimends_sortabs_alldistinct([-7, 12, -7]) == True"}
{"id": "op_inc_padto3_div3", "entry_point": "op_inc_padto3_div3", "primitives": ["inc", "padto3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then keep multiples of three.", "solution": "def op_inc_padto3_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_padto3_div3([1, 2, 3, 4]) == [3]\nassert op_inc_padto3_div3([]) == [0, 0, 0]\nassert op_inc_padto3_div3([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_inc_padto3_div3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_padto3_div3([3, 1, 2]) == [3]\nassert op_inc_padto3_div3([10]) == [0, 0]\nassert op_inc_padto3_div3([2, 4, 6]) == [3]\nassert op_inc_padto3_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dropfirst_dropwhileneg_sorta", "entry_point": "op_dropfirst_dropwhileneg_sorta", "primitives": ["dropfirst", "dropwhileneg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then sort ascending.", "solution": "def op_dropfirst_dropwhileneg_sorta(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    return r", "tests": "assert op_dropfirst_dropwhileneg_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropwhileneg_sorta([]) == []\nassert op_dropfirst_dropwhileneg_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_dropwhileneg_sorta([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dropwhileneg_sorta([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dropwhileneg_sorta([10]) == []\nassert op_dropfirst_dropwhileneg_sorta([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dropwhileneg_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_add10_gt5_absval", "entry_point": "op_add10_gt5_absval", "primitives": ["add10", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then take the absolute value of each.", "solution": "def op_add10_gt5_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_gt5_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_gt5_absval([]) == []\nassert op_add10_gt5_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_gt5_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5_absval([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5_absval([10]) == [20]\nassert op_add10_gt5_absval([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5_absval([-7, 12, -7]) == [22]"}
{"id": "op_negate_add10_inc", "entry_point": "op_negate_add10_inc", "primitives": ["negate", "add10", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then add one to each.", "solution": "def op_negate_add10_inc(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_negate_add10_inc([1, 2, 3, 4]) == [10, 9, 8, 7]\nassert op_negate_add10_inc([]) == []\nassert op_negate_add10_inc([-2, -1, 0, 1, 2]) == [13, 12, 11, 10, 9]\nassert op_negate_add10_inc([5, 5, 5]) == [6, 6, 6]\nassert op_negate_add10_inc([3, 1, 2]) == [8, 10, 9]\nassert op_negate_add10_inc([10]) == [1]\nassert op_negate_add10_inc([2, 4, 6]) == [9, 7, 5]\nassert op_negate_add10_inc([-7, 12, -7]) == [18, -1, 18]"}
{"id": "op_trimends_sortd_min", "entry_point": "op_trimends_sortd_min", "primitives": ["trimends", "sortd", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending, then return the minimum (0 if empty).", "solution": "def op_trimends_sortd_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_trimends_sortd_min([1, 2, 3, 4]) == 2\nassert op_trimends_sortd_min([]) == 0\nassert op_trimends_sortd_min([-2, -1, 0, 1, 2]) == -1\nassert op_trimends_sortd_min([5, 5, 5]) == 5\nassert op_trimends_sortd_min([3, 1, 2]) == 1\nassert op_trimends_sortd_min([10]) == 0\nassert op_trimends_sortd_min([2, 4, 6]) == 4\nassert op_trimends_sortd_min([-7, 12, -7]) == 12"}
{"id": "op_absval_padto3_neg", "entry_point": "op_absval_padto3_neg", "primitives": ["absval", "padto3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_absval_padto3_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_padto3_neg([1, 2, 3, 4]) == []\nassert op_absval_padto3_neg([]) == []\nassert op_absval_padto3_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_padto3_neg([5, 5, 5]) == []\nassert op_absval_padto3_neg([3, 1, 2]) == []\nassert op_absval_padto3_neg([10]) == []\nassert op_absval_padto3_neg([2, 4, 6]) == []\nassert op_absval_padto3_neg([-7, 12, -7]) == []"}
{"id": "op_gt5_sortabs_dropwhileneg", "entry_point": "op_gt5_sortabs_dropwhileneg", "primitives": ["gt5", "sortabs", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then drop the leading negative values.", "solution": "def op_gt5_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_gt5_sortabs_dropwhileneg([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_dropwhileneg([]) == []\nassert op_gt5_sortabs_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_dropwhileneg([5, 5, 5]) == []\nassert op_gt5_sortabs_dropwhileneg([3, 1, 2]) == []\nassert op_gt5_sortabs_dropwhileneg([10]) == [10]\nassert op_gt5_sortabs_dropwhileneg([2, 4, 6]) == [6]\nassert op_gt5_sortabs_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_ages_oremptyzero_first3", "entry_point": "op_ages_oremptyzero_first3", "primitives": ["ages", "oremptyzero", "first3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then keep only the first three.", "solution": "def op_ages_oremptyzero_first3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = r[:3]\n    return r", "tests": "assert op_ages_oremptyzero_first3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_oremptyzero_first3([]) == [0]\nassert op_ages_oremptyzero_first3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_oremptyzero_first3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_negate_padto3_neg", "entry_point": "op_negate_padto3_neg", "primitives": ["negate", "padto3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_negate_padto3_neg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_negate_padto3_neg([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_padto3_neg([]) == []\nassert op_negate_padto3_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_negate_padto3_neg([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_padto3_neg([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_padto3_neg([10]) == [-10]\nassert op_negate_padto3_neg([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_padto3_neg([-7, 12, -7]) == [-12]"}
{"id": "op_gt5_add10_last3", "entry_point": "op_gt5_add10_last3", "primitives": ["gt5", "add10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then keep only the last three.", "solution": "def op_gt5_add10_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_gt5_add10_last3([1, 2, 3, 4]) == []\nassert op_gt5_add10_last3([]) == []\nassert op_gt5_add10_last3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_last3([5, 5, 5]) == []\nassert op_gt5_add10_last3([3, 1, 2]) == []\nassert op_gt5_add10_last3([10]) == [20]\nassert op_gt5_add10_last3([2, 4, 6]) == [16]\nassert op_gt5_add10_last3([-7, 12, -7]) == [22]"}
{"id": "op_padto3_negate_first3", "entry_point": "op_padto3_negate_first3", "primitives": ["padto3", "negate", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then negate each, then keep only the first three.", "solution": "def op_padto3_negate_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_negate_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_padto3_negate_first3([]) == [0, 0, 0]\nassert op_padto3_negate_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_padto3_negate_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_negate_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_negate_first3([10]) == [-10, 0, 0]\nassert op_padto3_negate_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_negate_first3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sorta_clamp10_takewhilepos", "entry_point": "op_sorta_clamp10_takewhilepos", "primitives": ["sorta", "clamp10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then take values while they are positive.", "solution": "def op_sorta_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sorta_clamp10_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10_takewhilepos([]) == []\nassert op_sorta_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sorta_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_takewhilepos([10]) == [10]\nassert op_sorta_clamp10_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_negate_odds_div3", "entry_point": "op_negate_odds_div3", "primitives": ["negate", "odds", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then keep multiples of three.", "solution": "def op_negate_odds_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_odds_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_odds_div3([]) == []\nassert op_negate_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_negate_odds_div3([5, 5, 5]) == []\nassert op_negate_odds_div3([3, 1, 2]) == [-3]\nassert op_negate_odds_div3([10]) == []\nassert op_negate_odds_div3([2, 4, 6]) == []\nassert op_negate_odds_div3([-7, 12, -7]) == []"}
{"id": "op_dec_clamp10_min", "entry_point": "op_dec_clamp10_min", "primitives": ["dec", "clamp10", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cap each value at 10, then return the minimum (0 if empty).", "solution": "def op_dec_clamp10_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return min(r) if r else 0", "tests": "assert op_dec_clamp10_min([1, 2, 3, 4]) == 0\nassert op_dec_clamp10_min([]) == 0\nassert op_dec_clamp10_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_clamp10_min([5, 5, 5]) == 4\nassert op_dec_clamp10_min([3, 1, 2]) == 0\nassert op_dec_clamp10_min([10]) == 9\nassert op_dec_clamp10_min([2, 4, 6]) == 1\nassert op_dec_clamp10_min([-7, 12, -7]) == -8"}
{"id": "op_sorta_inc_alldistinct", "entry_point": "op_sorta_inc_alldistinct", "primitives": ["sorta", "inc", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then return whether all values are distinct.", "solution": "def op_sorta_inc_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sorta_inc_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_inc_alldistinct([]) == True\nassert op_sorta_inc_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sorta_inc_alldistinct([5, 5, 5]) == False\nassert op_sorta_inc_alldistinct([3, 1, 2]) == True\nassert op_sorta_inc_alldistinct([10]) == True\nassert op_sorta_inc_alldistinct([2, 4, 6]) == True\nassert op_sorta_inc_alldistinct([-7, 12, -7]) == False"}
{"id": "op_evens_neg_dropfirst", "entry_point": "op_evens_neg_dropfirst", "primitives": ["evens", "neg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers, then drop the first element.", "solution": "def op_evens_neg_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_evens_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_evens_neg_dropfirst([]) == []\nassert op_evens_neg_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_evens_neg_dropfirst([5, 5, 5]) == []\nassert op_evens_neg_dropfirst([3, 1, 2]) == []\nassert op_evens_neg_dropfirst([10]) == []\nassert op_evens_neg_dropfirst([2, 4, 6]) == []\nassert op_evens_neg_dropfirst([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sorta_sortd", "entry_point": "op_takewhilepos_sorta_sortd", "primitives": ["takewhilepos", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending, then sort descending.", "solution": "def op_takewhilepos_sorta_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_sorta_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_sorta_sortd([]) == []\nassert op_takewhilepos_sorta_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sorta_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sorta_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_sorta_sortd([10]) == [10]\nassert op_takewhilepos_sorta_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_sorta_sortd([-7, 12, -7]) == []"}
{"id": "op_sorta_add10_double", "entry_point": "op_sorta_add10_double", "primitives": ["sorta", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then double each.", "solution": "def op_sorta_add10_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_add10_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_sorta_add10_double([]) == []\nassert op_sorta_add10_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_sorta_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_sorta_add10_double([3, 1, 2]) == [22, 24, 26]\nassert op_sorta_add10_double([10]) == [40]\nassert op_sorta_add10_double([2, 4, 6]) == [24, 28, 32]\nassert op_sorta_add10_double([-7, 12, -7]) == [6, 6, 44]"}
{"id": "op_ages_takewhilepos_min", "entry_point": "op_ages_takewhilepos_min", "primitives": ["ages", "takewhilepos", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_ages_takewhilepos_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_ages_takewhilepos_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_takewhilepos_min([]) == 0\nassert op_ages_takewhilepos_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_takewhilepos_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_takewhilepos_padto3_alldistinct", "entry_point": "op_takewhilepos_padto3_alldistinct", "primitives": ["takewhilepos", "padto3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then return whether all values are distinct.", "solution": "def op_takewhilepos_padto3_alldistinct(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r) == len(set(r))", "tests": "assert op_takewhilepos_padto3_alldistinct([1, 2, 3, 4]) == True\nassert op_takewhilepos_padto3_alldistinct([]) == False\nassert op_takewhilepos_padto3_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_padto3_alldistinct([5, 5, 5]) == False\nassert op_takewhilepos_padto3_alldistinct([3, 1, 2]) == True\nassert op_takewhilepos_padto3_alldistinct([10]) == False\nassert op_takewhilepos_padto3_alldistinct([2, 4, 6]) == True\nassert op_takewhilepos_padto3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_inc_odds_neg", "entry_point": "op_inc_odds_neg", "primitives": ["inc", "odds", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then keep the negative numbers.", "solution": "def op_inc_odds_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_odds_neg([1, 2, 3, 4]) == []\nassert op_inc_odds_neg([]) == []\nassert op_inc_odds_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_odds_neg([5, 5, 5]) == []\nassert op_inc_odds_neg([3, 1, 2]) == []\nassert op_inc_odds_neg([10]) == []\nassert op_inc_odds_neg([2, 4, 6]) == []\nassert op_inc_odds_neg([-7, 12, -7]) == []"}
{"id": "op_square_dec_last3", "entry_point": "op_square_dec_last3", "primitives": ["square", "dec", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each, then keep only the last three.", "solution": "def op_square_dec_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_square_dec_last3([1, 2, 3, 4]) == [3, 8, 15]\nassert op_square_dec_last3([]) == []\nassert op_square_dec_last3([-2, -1, 0, 1, 2]) == [-1, 0, 3]\nassert op_square_dec_last3([5, 5, 5]) == [24, 24, 24]\nassert op_square_dec_last3([3, 1, 2]) == [8, 0, 3]\nassert op_square_dec_last3([10]) == [99]\nassert op_square_dec_last3([2, 4, 6]) == [3, 15, 35]\nassert op_square_dec_last3([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_clamp10_div3_counteven", "entry_point": "op_clamp10_div3_counteven", "primitives": ["clamp10", "div3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep multiples of three, then return how many values are even.", "solution": "def op_clamp10_div3_counteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_clamp10_div3_counteven([1, 2, 3, 4]) == 0\nassert op_clamp10_div3_counteven([]) == 0\nassert op_clamp10_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_clamp10_div3_counteven([5, 5, 5]) == 0\nassert op_clamp10_div3_counteven([3, 1, 2]) == 0\nassert op_clamp10_div3_counteven([10]) == 0\nassert op_clamp10_div3_counteven([2, 4, 6]) == 1\nassert op_clamp10_div3_counteven([-7, 12, -7]) == 0"}
{"id": "op_negate_last3_oremptyzero", "entry_point": "op_negate_last3_oremptyzero", "primitives": ["negate", "last3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then if empty, use a single zero.", "solution": "def op_negate_last3_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_last3_oremptyzero([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_last3_oremptyzero([]) == [0]\nassert op_negate_last3_oremptyzero([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_negate_last3_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_last3_oremptyzero([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_last3_oremptyzero([10]) == [-10]\nassert op_negate_last3_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_last3_oremptyzero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_add10_rev_sorta", "entry_point": "op_add10_rev_sorta", "primitives": ["add10", "rev", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then sort ascending.", "solution": "def op_add10_rev_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = sorted(r)\n    return r", "tests": "assert op_add10_rev_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_rev_sorta([]) == []\nassert op_add10_rev_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_rev_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_rev_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_rev_sorta([10]) == [20]\nassert op_add10_rev_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_rev_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_clamp10_sortd_uniq", "entry_point": "op_clamp10_sortd_uniq", "primitives": ["clamp10", "sortd", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_sortd_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_sortd_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_sortd_uniq([]) == []\nassert op_clamp10_sortd_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_sortd_uniq([5, 5, 5]) == [5]\nassert op_clamp10_sortd_uniq([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_sortd_uniq([10]) == [10]\nassert op_clamp10_sortd_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_sortd_uniq([-7, 12, -7]) == [10, -7]"}
{"id": "op_absval_evens_len", "entry_point": "op_absval_evens_len", "primitives": ["absval", "evens", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then return how many remain.", "solution": "def op_absval_evens_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_absval_evens_len([1, 2, 3, 4]) == 2\nassert op_absval_evens_len([]) == 0\nassert op_absval_evens_len([-2, -1, 0, 1, 2]) == 3\nassert op_absval_evens_len([5, 5, 5]) == 0\nassert op_absval_evens_len([3, 1, 2]) == 1\nassert op_absval_evens_len([10]) == 1\nassert op_absval_evens_len([2, 4, 6]) == 3\nassert op_absval_evens_len([-7, 12, -7]) == 1"}
{"id": "op_neg_trimends_dropzeros", "entry_point": "op_neg_trimends_dropzeros", "primitives": ["neg", "trimends", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then drop the zeros.", "solution": "def op_neg_trimends_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_neg_trimends_dropzeros([1, 2, 3, 4]) == []\nassert op_neg_trimends_dropzeros([]) == []\nassert op_neg_trimends_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_dropzeros([5, 5, 5]) == []\nassert op_neg_trimends_dropzeros([3, 1, 2]) == []\nassert op_neg_trimends_dropzeros([10]) == []\nassert op_neg_trimends_dropzeros([2, 4, 6]) == []\nassert op_neg_trimends_dropzeros([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_negate_allpos", "entry_point": "op_takewhilepos_negate_allpos", "primitives": ["takewhilepos", "negate", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then return whether all values are positive.", "solution": "def op_takewhilepos_negate_allpos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_takewhilepos_negate_allpos([1, 2, 3, 4]) == False\nassert op_takewhilepos_negate_allpos([]) == True\nassert op_takewhilepos_negate_allpos([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_negate_allpos([5, 5, 5]) == False\nassert op_takewhilepos_negate_allpos([3, 1, 2]) == False\nassert op_takewhilepos_negate_allpos([10]) == False\nassert op_takewhilepos_negate_allpos([2, 4, 6]) == False\nassert op_takewhilepos_negate_allpos([-7, 12, -7]) == True"}
{"id": "op_dropfirst_uniq_dropzeros", "entry_point": "op_dropfirst_uniq_dropzeros", "primitives": ["dropfirst", "uniq", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_dropfirst_uniq_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_uniq_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_uniq_dropzeros([]) == []\nassert op_dropfirst_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropfirst_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_dropfirst_uniq_dropzeros([3, 1, 2]) == [1, 2]\nassert op_dropfirst_uniq_dropzeros([10]) == []\nassert op_dropfirst_uniq_dropzeros([2, 4, 6]) == [4, 6]\nassert op_dropfirst_uniq_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropzeros_double_sum", "entry_point": "op_dropzeros_double_sum", "primitives": ["dropzeros", "double", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then return their sum.", "solution": "def op_dropzeros_double_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return sum(r)", "tests": "assert op_dropzeros_double_sum([1, 2, 3, 4]) == 20\nassert op_dropzeros_double_sum([]) == 0\nassert op_dropzeros_double_sum([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_double_sum([5, 5, 5]) == 30\nassert op_dropzeros_double_sum([3, 1, 2]) == 12\nassert op_dropzeros_double_sum([10]) == 20\nassert op_dropzeros_double_sum([2, 4, 6]) == 24\nassert op_dropzeros_double_sum([-7, 12, -7]) == -4"}
{"id": "op_padto3_gt5_div3", "entry_point": "op_padto3_gt5_div3", "primitives": ["padto3", "gt5", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then keep multiples of three.", "solution": "def op_padto3_gt5_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_gt5_div3([1, 2, 3, 4]) == []\nassert op_padto3_gt5_div3([]) == []\nassert op_padto3_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5_div3([5, 5, 5]) == []\nassert op_padto3_gt5_div3([3, 1, 2]) == []\nassert op_padto3_gt5_div3([10]) == []\nassert op_padto3_gt5_div3([2, 4, 6]) == [6]\nassert op_padto3_gt5_div3([-7, 12, -7]) == [12]"}
{"id": "op_ages_rev_issorted", "entry_point": "op_ages_rev_issorted", "primitives": ["ages", "rev", "issorted"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then return whether the list is sorted ascending.", "solution": "def op_ages_rev_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    return r == sorted(r)", "tests": "assert op_ages_rev_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_rev_issorted([]) == True\nassert op_ages_rev_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_rev_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_negate_dropzeros_div3", "entry_point": "op_negate_dropzeros_div3", "primitives": ["negate", "dropzeros", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then keep multiples of three.", "solution": "def op_negate_dropzeros_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_dropzeros_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_dropzeros_div3([]) == []\nassert op_negate_dropzeros_div3([-2, -1, 0, 1, 2]) == []\nassert op_negate_dropzeros_div3([5, 5, 5]) == []\nassert op_negate_dropzeros_div3([3, 1, 2]) == [-3]\nassert op_negate_dropzeros_div3([10]) == []\nassert op_negate_dropzeros_div3([2, 4, 6]) == [-6]\nassert op_negate_dropzeros_div3([-7, 12, -7]) == [-12]"}
{"id": "op_sortd_add10_oremptyzero", "entry_point": "op_sortd_add10_oremptyzero", "primitives": ["sortd", "add10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then if empty, use a single zero.", "solution": "def op_sortd_add10_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_add10_oremptyzero([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sortd_add10_oremptyzero([]) == [0]\nassert op_sortd_add10_oremptyzero([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sortd_add10_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_sortd_add10_oremptyzero([3, 1, 2]) == [13, 12, 11]\nassert op_sortd_add10_oremptyzero([10]) == [20]\nassert op_sortd_add10_oremptyzero([2, 4, 6]) == [16, 14, 12]\nassert op_sortd_add10_oremptyzero([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_sorta_beforezero_neg", "entry_point": "op_sorta_beforezero_neg", "primitives": ["sorta", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_sorta_beforezero_neg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sorta_beforezero_neg([1, 2, 3, 4]) == []\nassert op_sorta_beforezero_neg([]) == []\nassert op_sorta_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_beforezero_neg([5, 5, 5]) == []\nassert op_sorta_beforezero_neg([3, 1, 2]) == []\nassert op_sorta_beforezero_neg([10]) == []\nassert op_sorta_beforezero_neg([2, 4, 6]) == []\nassert op_sorta_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_last3_prod", "entry_point": "op_neg_last3_prod", "primitives": ["neg", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then return their product.", "solution": "def op_neg_last3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_neg_last3_prod([1, 2, 3, 4]) == 1\nassert op_neg_last3_prod([]) == 1\nassert op_neg_last3_prod([-2, -1, 0, 1, 2]) == 2\nassert op_neg_last3_prod([5, 5, 5]) == 1\nassert op_neg_last3_prod([3, 1, 2]) == 1\nassert op_neg_last3_prod([10]) == 1\nassert op_neg_last3_prod([2, 4, 6]) == 1\nassert op_neg_last3_prod([-7, 12, -7]) == 49"}
{"id": "op_gt5_evens_absval", "entry_point": "op_gt5_evens_absval", "primitives": ["gt5", "evens", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then take the absolute value of each.", "solution": "def op_gt5_evens_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_evens_absval([1, 2, 3, 4]) == []\nassert op_gt5_evens_absval([]) == []\nassert op_gt5_evens_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens_absval([5, 5, 5]) == []\nassert op_gt5_evens_absval([3, 1, 2]) == []\nassert op_gt5_evens_absval([10]) == [10]\nassert op_gt5_evens_absval([2, 4, 6]) == [6]\nassert op_gt5_evens_absval([-7, 12, -7]) == [12]"}
{"id": "op_double_add10_clamp10", "entry_point": "op_double_add10_clamp10", "primitives": ["double", "add10", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then cap each value at 10.", "solution": "def op_double_add10_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_add10_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_double_add10_clamp10([]) == []\nassert op_double_add10_clamp10([-2, -1, 0, 1, 2]) == [6, 8, 10, 10, 10]\nassert op_double_add10_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_double_add10_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_double_add10_clamp10([10]) == [10]\nassert op_double_add10_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_double_add10_clamp10([-7, 12, -7]) == [-4, 10, -4]"}
{"id": "op_uniq_absval_dropfirst", "entry_point": "op_uniq_absval_dropfirst", "primitives": ["uniq", "absval", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then drop the first element.", "solution": "def op_uniq_absval_dropfirst(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_uniq_absval_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_absval_dropfirst([]) == []\nassert op_uniq_absval_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_uniq_absval_dropfirst([5, 5, 5]) == []\nassert op_uniq_absval_dropfirst([3, 1, 2]) == [1, 2]\nassert op_uniq_absval_dropfirst([10]) == []\nassert op_uniq_absval_dropfirst([2, 4, 6]) == [4, 6]\nassert op_uniq_absval_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_absval_inc_max", "entry_point": "op_absval_inc_max", "primitives": ["absval", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add one to each, then return the maximum (0 if empty).", "solution": "def op_absval_inc_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_absval_inc_max([1, 2, 3, 4]) == 5\nassert op_absval_inc_max([]) == 0\nassert op_absval_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_absval_inc_max([5, 5, 5]) == 6\nassert op_absval_inc_max([3, 1, 2]) == 4\nassert op_absval_inc_max([10]) == 11\nassert op_absval_inc_max([2, 4, 6]) == 7\nassert op_absval_inc_max([-7, 12, -7]) == 13"}
{"id": "op_square_takewhilepos_negate", "entry_point": "op_square_takewhilepos_negate", "primitives": ["square", "takewhilepos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then negate each.", "solution": "def op_square_takewhilepos_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_takewhilepos_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_takewhilepos_negate([]) == []\nassert op_square_takewhilepos_negate([-2, -1, 0, 1, 2]) == [-4, -1]\nassert op_square_takewhilepos_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_takewhilepos_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_square_takewhilepos_negate([10]) == [-100]\nassert op_square_takewhilepos_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_takewhilepos_negate([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_sortabs_clamp10_dropfirst", "entry_point": "op_sortabs_clamp10_dropfirst", "primitives": ["sortabs", "clamp10", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then drop the first element.", "solution": "def op_sortabs_clamp10_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_clamp10_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_clamp10_dropfirst([]) == []\nassert op_sortabs_clamp10_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_clamp10_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortabs_clamp10_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sortabs_clamp10_dropfirst([10]) == []\nassert op_sortabs_clamp10_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sortabs_clamp10_dropfirst([-7, 12, -7]) == [-7, 10]"}
{"id": "op_uniq_evens_min", "entry_point": "op_uniq_evens_min", "primitives": ["uniq", "evens", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_uniq_evens_min(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_uniq_evens_min([1, 2, 3, 4]) == 2\nassert op_uniq_evens_min([]) == 0\nassert op_uniq_evens_min([-2, -1, 0, 1, 2]) == -2\nassert op_uniq_evens_min([5, 5, 5]) == 0\nassert op_uniq_evens_min([3, 1, 2]) == 2\nassert op_uniq_evens_min([10]) == 10\nassert op_uniq_evens_min([2, 4, 6]) == 2\nassert op_uniq_evens_min([-7, 12, -7]) == 12"}
{"id": "op_first3_double_counteven", "entry_point": "op_first3_double_counteven", "primitives": ["first3", "double", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then return how many values are even.", "solution": "def op_first3_double_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_double_counteven([1, 2, 3, 4]) == 3\nassert op_first3_double_counteven([]) == 0\nassert op_first3_double_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_first3_double_counteven([5, 5, 5]) == 3\nassert op_first3_double_counteven([3, 1, 2]) == 3\nassert op_first3_double_counteven([10]) == 1\nassert op_first3_double_counteven([2, 4, 6]) == 3\nassert op_first3_double_counteven([-7, 12, -7]) == 3"}
{"id": "op_sortd_square_pos", "entry_point": "op_sortd_square_pos", "primitives": ["sortd", "square", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then keep the positive numbers.", "solution": "def op_sortd_square_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_square_pos([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_square_pos([]) == []\nassert op_sortd_square_pos([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_sortd_square_pos([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_pos([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_square_pos([10]) == [100]\nassert op_sortd_square_pos([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square_pos([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_square_last3_dec", "entry_point": "op_square_last3_dec", "primitives": ["square", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then subtract one from each.", "solution": "def op_square_last3_dec(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_square_last3_dec([1, 2, 3, 4]) == [3, 8, 15]\nassert op_square_last3_dec([]) == []\nassert op_square_last3_dec([-2, -1, 0, 1, 2]) == [-1, 0, 3]\nassert op_square_last3_dec([5, 5, 5]) == [24, 24, 24]\nassert op_square_last3_dec([3, 1, 2]) == [8, 0, 3]\nassert op_square_last3_dec([10]) == [99]\nassert op_square_last3_dec([2, 4, 6]) == [3, 15, 35]\nassert op_square_last3_dec([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_last3_first3_alldistinct", "entry_point": "op_last3_first3_alldistinct", "primitives": ["last3", "first3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then return whether all values are distinct.", "solution": "def op_last3_first3_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_last3_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_first3_alldistinct([]) == True\nassert op_last3_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_first3_alldistinct([5, 5, 5]) == False\nassert op_last3_first3_alldistinct([3, 1, 2]) == True\nassert op_last3_first3_alldistinct([10]) == True\nassert op_last3_first3_alldistinct([2, 4, 6]) == True\nassert op_last3_first3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_first3_beforezero_neg", "entry_point": "op_first3_beforezero_neg", "primitives": ["first3", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_first3_beforezero_neg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_first3_beforezero_neg([1, 2, 3, 4]) == []\nassert op_first3_beforezero_neg([]) == []\nassert op_first3_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_beforezero_neg([5, 5, 5]) == []\nassert op_first3_beforezero_neg([3, 1, 2]) == []\nassert op_first3_beforezero_neg([10]) == []\nassert op_first3_beforezero_neg([2, 4, 6]) == []\nassert op_first3_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropzeros_takewhilepos_issorted", "entry_point": "op_dropzeros_takewhilepos_issorted", "primitives": ["dropzeros", "takewhilepos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_takewhilepos_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r == sorted(r)", "tests": "assert op_dropzeros_takewhilepos_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_takewhilepos_issorted([]) == True\nassert op_dropzeros_takewhilepos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_takewhilepos_issorted([5, 5, 5]) == True\nassert op_dropzeros_takewhilepos_issorted([3, 1, 2]) == False\nassert op_dropzeros_takewhilepos_issorted([10]) == True\nassert op_dropzeros_takewhilepos_issorted([2, 4, 6]) == True\nassert op_dropzeros_takewhilepos_issorted([-7, 12, -7]) == True"}
{"id": "op_ages_uniq_odds", "entry_point": "op_ages_uniq_odds", "primitives": ["ages", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_ages_uniq_odds(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_ages_uniq_odds([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_uniq_odds([]) == []\nassert op_ages_uniq_odds([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_uniq_odds([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_odds_inc_double", "entry_point": "op_odds_inc_double", "primitives": ["odds", "inc", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then double each.", "solution": "def op_odds_inc_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_inc_double([1, 2, 3, 4]) == [4, 8]\nassert op_odds_inc_double([]) == []\nassert op_odds_inc_double([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_odds_inc_double([5, 5, 5]) == [12, 12, 12]\nassert op_odds_inc_double([3, 1, 2]) == [8, 4]\nassert op_odds_inc_double([10]) == []\nassert op_odds_inc_double([2, 4, 6]) == []\nassert op_odds_inc_double([-7, 12, -7]) == [-12, -12]"}
{"id": "op_clamp10_odds_uniq", "entry_point": "op_clamp10_odds_uniq", "primitives": ["clamp10", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_odds_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_odds_uniq([]) == []\nassert op_clamp10_odds_uniq([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_odds_uniq([5, 5, 5]) == [5]\nassert op_clamp10_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_clamp10_odds_uniq([10]) == []\nassert op_clamp10_odds_uniq([2, 4, 6]) == []\nassert op_clamp10_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_neg_sorta_add10", "entry_point": "op_neg_sorta_add10", "primitives": ["neg", "sorta", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then add ten to each.", "solution": "def op_neg_sorta_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_sorta_add10([1, 2, 3, 4]) == []\nassert op_neg_sorta_add10([]) == []\nassert op_neg_sorta_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_neg_sorta_add10([5, 5, 5]) == []\nassert op_neg_sorta_add10([3, 1, 2]) == []\nassert op_neg_sorta_add10([10]) == []\nassert op_neg_sorta_add10([2, 4, 6]) == []\nassert op_neg_sorta_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_names_prefixup_lower", "entry_point": "op_names_prefixup_lower", "primitives": ["names", "prefixup", "lower"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then prefix each with a hash, then lowercase each string.", "solution": "def op_names_prefixup_lower(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_names_prefixup_lower([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['#ada', '#bo']\nassert op_names_prefixup_lower([]) == []\nassert op_names_prefixup_lower([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['#cy', '#dee', '#el']\nassert op_names_prefixup_lower([{'name': 'Fi', 'age': 41}]) == ['#fi']"}
{"id": "op_sortage_names_sortalpha", "entry_point": "op_sortage_names_sortalpha", "primitives": ["sortage", "names", "sortalpha"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the names, then sort alphabetically.", "solution": "def op_sortage_names_sortalpha(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['name'] for d in r]\n    r = sorted(r)\n    return r", "tests": "assert op_sortage_names_sortalpha([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_sortage_names_sortalpha([]) == []\nassert op_sortage_names_sortalpha([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_sortage_names_sortalpha([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_rev_sorta_issorted", "entry_point": "op_rev_sorta_issorted", "primitives": ["rev", "sorta", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_rev_sorta_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_rev_sorta_issorted([1, 2, 3, 4]) == True\nassert op_rev_sorta_issorted([]) == True\nassert op_rev_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_rev_sorta_issorted([5, 5, 5]) == True\nassert op_rev_sorta_issorted([3, 1, 2]) == True\nassert op_rev_sorta_issorted([10]) == True\nassert op_rev_sorta_issorted([2, 4, 6]) == True\nassert op_rev_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_last3_neg_sorta", "entry_point": "op_last3_neg_sorta", "primitives": ["last3", "neg", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then sort ascending.", "solution": "def op_last3_neg_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_neg_sorta([1, 2, 3, 4]) == []\nassert op_last3_neg_sorta([]) == []\nassert op_last3_neg_sorta([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_sorta([5, 5, 5]) == []\nassert op_last3_neg_sorta([3, 1, 2]) == []\nassert op_last3_neg_sorta([10]) == []\nassert op_last3_neg_sorta([2, 4, 6]) == []\nassert op_last3_neg_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_rev_inc_absval", "entry_point": "op_rev_inc_absval", "primitives": ["rev", "inc", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then take the absolute value of each.", "solution": "def op_rev_inc_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_inc_absval([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_rev_inc_absval([]) == []\nassert op_rev_inc_absval([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, 1]\nassert op_rev_inc_absval([5, 5, 5]) == [6, 6, 6]\nassert op_rev_inc_absval([3, 1, 2]) == [3, 2, 4]\nassert op_rev_inc_absval([10]) == [11]\nassert op_rev_inc_absval([2, 4, 6]) == [7, 5, 3]\nassert op_rev_inc_absval([-7, 12, -7]) == [6, 13, 6]"}
{"id": "op_uniq_pos_dec", "entry_point": "op_uniq_pos_dec", "primitives": ["uniq", "pos", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then subtract one from each.", "solution": "def op_uniq_pos_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_pos_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_uniq_pos_dec([]) == []\nassert op_uniq_pos_dec([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_uniq_pos_dec([5, 5, 5]) == [4]\nassert op_uniq_pos_dec([3, 1, 2]) == [2, 0, 1]\nassert op_uniq_pos_dec([10]) == [9]\nassert op_uniq_pos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_pos_dec([-7, 12, -7]) == [11]"}
{"id": "op_last3_sorta_evens", "entry_point": "op_last3_sorta_evens", "primitives": ["last3", "sorta", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then keep the even numbers.", "solution": "def op_last3_sorta_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_sorta_evens([1, 2, 3, 4]) == [2, 4]\nassert op_last3_sorta_evens([]) == []\nassert op_last3_sorta_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_last3_sorta_evens([5, 5, 5]) == []\nassert op_last3_sorta_evens([3, 1, 2]) == [2]\nassert op_last3_sorta_evens([10]) == [10]\nassert op_last3_sorta_evens([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sorta_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortd_pos_square", "entry_point": "op_sortd_pos_square", "primitives": ["sortd", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then square each.", "solution": "def op_sortd_pos_square(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortd_pos_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_pos_square([]) == []\nassert op_sortd_pos_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_sortd_pos_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_pos_square([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_pos_square([10]) == [100]\nassert op_sortd_pos_square([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_rev_inc_trimends", "entry_point": "op_rev_inc_trimends", "primitives": ["rev", "inc", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then drop the first and last elements.", "solution": "def op_rev_inc_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_inc_trimends([1, 2, 3, 4]) == [4, 3]\nassert op_rev_inc_trimends([]) == []\nassert op_rev_inc_trimends([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_inc_trimends([5, 5, 5]) == [6]\nassert op_rev_inc_trimends([3, 1, 2]) == [2]\nassert op_rev_inc_trimends([10]) == []\nassert op_rev_inc_trimends([2, 4, 6]) == [5]\nassert op_rev_inc_trimends([-7, 12, -7]) == [13]"}
{"id": "op_dec_takewhilepos_counteven", "entry_point": "op_dec_takewhilepos_counteven", "primitives": ["dec", "takewhilepos", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then return how many values are even.", "solution": "def op_dec_takewhilepos_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_takewhilepos_counteven([1, 2, 3, 4]) == 0\nassert op_dec_takewhilepos_counteven([]) == 0\nassert op_dec_takewhilepos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dec_takewhilepos_counteven([5, 5, 5]) == 3\nassert op_dec_takewhilepos_counteven([3, 1, 2]) == 1\nassert op_dec_takewhilepos_counteven([10]) == 0\nassert op_dec_takewhilepos_counteven([2, 4, 6]) == 0\nassert op_dec_takewhilepos_counteven([-7, 12, -7]) == 0"}
{"id": "op_padto3_evens_inc", "entry_point": "op_padto3_evens_inc", "primitives": ["padto3", "evens", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then add one to each.", "solution": "def op_padto3_evens_inc(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_padto3_evens_inc([1, 2, 3, 4]) == [3, 5]\nassert op_padto3_evens_inc([]) == [1, 1, 1]\nassert op_padto3_evens_inc([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_padto3_evens_inc([5, 5, 5]) == []\nassert op_padto3_evens_inc([3, 1, 2]) == [3]\nassert op_padto3_evens_inc([10]) == [11, 1, 1]\nassert op_padto3_evens_inc([2, 4, 6]) == [3, 5, 7]\nassert op_padto3_evens_inc([-7, 12, -7]) == [13]"}
{"id": "op_firstchar_sortalpha_maxlen", "entry_point": "op_firstchar_sortalpha_maxlen", "primitives": ["firstchar", "sortalpha", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then return the length of the longest string (0 if none).", "solution": "def op_firstchar_sortalpha_maxlen(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_firstchar_sortalpha_maxlen(['Hello', 'world']) == 1\nassert op_firstchar_sortalpha_maxlen([]) == 0\nassert op_firstchar_sortalpha_maxlen(['  a ', '', 'BC', 'bc']) == 1\nassert op_firstchar_sortalpha_maxlen(['one', 'one', 'Two']) == 1\nassert op_firstchar_sortalpha_maxlen(['x']) == 1\nassert op_firstchar_sortalpha_maxlen(['abc', 'de', '']) == 1"}
{"id": "op_padto3_negate_dropfirst", "entry_point": "op_padto3_negate_dropfirst", "primitives": ["padto3", "negate", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then negate each, then drop the first element.", "solution": "def op_padto3_negate_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_negate_dropfirst([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_padto3_negate_dropfirst([]) == [0, 0]\nassert op_padto3_negate_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_padto3_negate_dropfirst([5, 5, 5]) == [-5, -5]\nassert op_padto3_negate_dropfirst([3, 1, 2]) == [-1, -2]\nassert op_padto3_negate_dropfirst([10]) == [0, 0]\nassert op_padto3_negate_dropfirst([2, 4, 6]) == [-4, -6]\nassert op_padto3_negate_dropfirst([-7, 12, -7]) == [-12, 7]"}
{"id": "op_clamp10_inc_min", "entry_point": "op_clamp10_inc_min", "primitives": ["clamp10", "inc", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then return the minimum (0 if empty).", "solution": "def op_clamp10_inc_min(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_clamp10_inc_min([1, 2, 3, 4]) == 2\nassert op_clamp10_inc_min([]) == 0\nassert op_clamp10_inc_min([-2, -1, 0, 1, 2]) == -1\nassert op_clamp10_inc_min([5, 5, 5]) == 6\nassert op_clamp10_inc_min([3, 1, 2]) == 2\nassert op_clamp10_inc_min([10]) == 11\nassert op_clamp10_inc_min([2, 4, 6]) == 3\nassert op_clamp10_inc_min([-7, 12, -7]) == -6"}
{"id": "op_rev_inc_last3", "entry_point": "op_rev_inc_last3", "primitives": ["rev", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then keep only the last three.", "solution": "def op_rev_inc_last3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_rev_inc_last3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_inc_last3([]) == []\nassert op_rev_inc_last3([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_rev_inc_last3([5, 5, 5]) == [6, 6, 6]\nassert op_rev_inc_last3([3, 1, 2]) == [3, 2, 4]\nassert op_rev_inc_last3([10]) == [11]\nassert op_rev_inc_last3([2, 4, 6]) == [7, 5, 3]\nassert op_rev_inc_last3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_clamp10_beforezero_sortabs", "entry_point": "op_clamp10_beforezero_sortabs", "primitives": ["clamp10", "beforezero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then sort by absolute value.", "solution": "def op_clamp10_beforezero_sortabs(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_clamp10_beforezero_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_beforezero_sortabs([]) == []\nassert op_clamp10_beforezero_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_clamp10_beforezero_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_beforezero_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_beforezero_sortabs([10]) == [10]\nassert op_clamp10_beforezero_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_beforezero_sortabs([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_beforezero_add10_gt5", "entry_point": "op_beforezero_add10_gt5", "primitives": ["beforezero", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then keep values greater than five.", "solution": "def op_beforezero_add10_gt5(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_beforezero_add10_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_beforezero_add10_gt5([]) == []\nassert op_beforezero_add10_gt5([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_beforezero_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_beforezero_add10_gt5([10]) == [20]\nassert op_beforezero_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_beforezero_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_dropfirst_absval_counteven", "entry_point": "op_dropfirst_absval_counteven", "primitives": ["dropfirst", "absval", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then return how many values are even.", "solution": "def op_dropfirst_absval_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_absval_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_absval_counteven([]) == 0\nassert op_dropfirst_absval_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_absval_counteven([5, 5, 5]) == 0\nassert op_dropfirst_absval_counteven([3, 1, 2]) == 1\nassert op_dropfirst_absval_counteven([10]) == 0\nassert op_dropfirst_absval_counteven([2, 4, 6]) == 2\nassert op_dropfirst_absval_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_add10_clamp10", "entry_point": "op_rev_add10_clamp10", "primitives": ["rev", "add10", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then cap each value at 10.", "solution": "def op_rev_add10_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_add10_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_rev_add10_clamp10([]) == []\nassert op_rev_add10_clamp10([-2, -1, 0, 1, 2]) == [10, 10, 10, 9, 8]\nassert op_rev_add10_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_rev_add10_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_rev_add10_clamp10([10]) == [10]\nassert op_rev_add10_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_rev_add10_clamp10([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_rev_odds_dropfirst", "entry_point": "op_rev_odds_dropfirst", "primitives": ["rev", "odds", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then drop the first element.", "solution": "def op_rev_odds_dropfirst(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_rev_odds_dropfirst([1, 2, 3, 4]) == [1]\nassert op_rev_odds_dropfirst([]) == []\nassert op_rev_odds_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_rev_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_rev_odds_dropfirst([3, 1, 2]) == [3]\nassert op_rev_odds_dropfirst([10]) == []\nassert op_rev_odds_dropfirst([2, 4, 6]) == []\nassert op_rev_odds_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_last3_trimends_inc", "entry_point": "op_last3_trimends_inc", "primitives": ["last3", "trimends", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then add one to each.", "solution": "def op_last3_trimends_inc(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_last3_trimends_inc([1, 2, 3, 4]) == [4]\nassert op_last3_trimends_inc([]) == []\nassert op_last3_trimends_inc([-2, -1, 0, 1, 2]) == [2]\nassert op_last3_trimends_inc([5, 5, 5]) == [6]\nassert op_last3_trimends_inc([3, 1, 2]) == [2]\nassert op_last3_trimends_inc([10]) == []\nassert op_last3_trimends_inc([2, 4, 6]) == [5]\nassert op_last3_trimends_inc([-7, 12, -7]) == [13]"}
{"id": "op_oremptyzero_padto3_square", "entry_point": "op_oremptyzero_padto3_square", "primitives": ["oremptyzero", "padto3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then square each.", "solution": "def op_oremptyzero_padto3_square(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_oremptyzero_padto3_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_oremptyzero_padto3_square([]) == [0, 0, 0]\nassert op_oremptyzero_padto3_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_oremptyzero_padto3_square([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_padto3_square([3, 1, 2]) == [9, 1, 4]\nassert op_oremptyzero_padto3_square([10]) == [100, 0, 0]\nassert op_oremptyzero_padto3_square([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_padto3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_takewhilepos_dropzeros_sum", "entry_point": "op_takewhilepos_dropzeros_sum", "primitives": ["takewhilepos", "dropzeros", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then return their sum.", "solution": "def op_takewhilepos_dropzeros_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_takewhilepos_dropzeros_sum([1, 2, 3, 4]) == 10\nassert op_takewhilepos_dropzeros_sum([]) == 0\nassert op_takewhilepos_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropzeros_sum([5, 5, 5]) == 15\nassert op_takewhilepos_dropzeros_sum([3, 1, 2]) == 6\nassert op_takewhilepos_dropzeros_sum([10]) == 10\nassert op_takewhilepos_dropzeros_sum([2, 4, 6]) == 12\nassert op_takewhilepos_dropzeros_sum([-7, 12, -7]) == 0"}
{"id": "op_takewhilepos_dropzeros_double", "entry_point": "op_takewhilepos_dropzeros_double", "primitives": ["takewhilepos", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then double each.", "solution": "def op_takewhilepos_dropzeros_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_dropzeros_double([]) == []\nassert op_takewhilepos_dropzeros_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_dropzeros_double([10]) == [20]\nassert op_takewhilepos_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_dropzeros_double([-7, 12, -7]) == []"}
{"id": "op_add10_beforezero_last3", "entry_point": "op_add10_beforezero_last3", "primitives": ["add10", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero, then keep only the last three.", "solution": "def op_add10_beforezero_last3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_add10_beforezero_last3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_beforezero_last3([]) == []\nassert op_add10_beforezero_last3([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_add10_beforezero_last3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_beforezero_last3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_beforezero_last3([10]) == [20]\nassert op_add10_beforezero_last3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_beforezero_last3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_beforezero_first3_pos", "entry_point": "op_beforezero_first3_pos", "primitives": ["beforezero", "first3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then keep the positive numbers.", "solution": "def op_beforezero_first3_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_first3_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_pos([]) == []\nassert op_beforezero_first3_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_first3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_pos([10]) == [10]\nassert op_beforezero_first3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_pos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_evens_odds", "entry_point": "op_uniq_evens_odds", "primitives": ["uniq", "evens", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then keep the odd numbers.", "solution": "def op_uniq_evens_odds(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_uniq_evens_odds([1, 2, 3, 4]) == []\nassert op_uniq_evens_odds([]) == []\nassert op_uniq_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_uniq_evens_odds([5, 5, 5]) == []\nassert op_uniq_evens_odds([3, 1, 2]) == []\nassert op_uniq_evens_odds([10]) == []\nassert op_uniq_evens_odds([2, 4, 6]) == []\nassert op_uniq_evens_odds([-7, 12, -7]) == []"}
{"id": "op_first3_dropfirst_div3", "entry_point": "op_first3_dropfirst_div3", "primitives": ["first3", "dropfirst", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then keep multiples of three.", "solution": "def op_first3_dropfirst_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_first3_dropfirst_div3([]) == []\nassert op_first3_dropfirst_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropfirst_div3([5, 5, 5]) == []\nassert op_first3_dropfirst_div3([3, 1, 2]) == []\nassert op_first3_dropfirst_div3([10]) == []\nassert op_first3_dropfirst_div3([2, 4, 6]) == [6]\nassert op_first3_dropfirst_div3([-7, 12, -7]) == [12]"}
{"id": "op_first3_add10_firsteven", "entry_point": "op_first3_add10_firsteven", "primitives": ["first3", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then return the first even value (0 if none).", "solution": "def op_first3_add10_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_first3_add10_firsteven([]) == 0\nassert op_first3_add10_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_first3_add10_firsteven([5, 5, 5]) == 0\nassert op_first3_add10_firsteven([3, 1, 2]) == 12\nassert op_first3_add10_firsteven([10]) == 20\nassert op_first3_add10_firsteven([2, 4, 6]) == 12\nassert op_first3_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_sortabs_absval_clamp10", "entry_point": "op_sortabs_absval_clamp10", "primitives": ["sortabs", "absval", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then cap each value at 10.", "solution": "def op_sortabs_absval_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_absval_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_absval_clamp10([]) == []\nassert op_sortabs_absval_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_sortabs_absval_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_absval_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_absval_clamp10([10]) == [10]\nassert op_sortabs_absval_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_absval_clamp10([-7, 12, -7]) == [7, 7, 10]"}
{"id": "op_odds_inc_div3", "entry_point": "op_odds_inc_div3", "primitives": ["odds", "inc", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then keep multiples of three.", "solution": "def op_odds_inc_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_inc_div3([1, 2, 3, 4]) == []\nassert op_odds_inc_div3([]) == []\nassert op_odds_inc_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_odds_inc_div3([5, 5, 5]) == [6, 6, 6]\nassert op_odds_inc_div3([3, 1, 2]) == []\nassert op_odds_inc_div3([10]) == []\nassert op_odds_inc_div3([2, 4, 6]) == []\nassert op_odds_inc_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_first3_gt5_len", "entry_point": "op_first3_gt5_len", "primitives": ["first3", "gt5", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then return how many remain.", "solution": "def op_first3_gt5_len(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_first3_gt5_len([1, 2, 3, 4]) == 0\nassert op_first3_gt5_len([]) == 0\nassert op_first3_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_first3_gt5_len([5, 5, 5]) == 0\nassert op_first3_gt5_len([3, 1, 2]) == 0\nassert op_first3_gt5_len([10]) == 1\nassert op_first3_gt5_len([2, 4, 6]) == 1\nassert op_first3_gt5_len([-7, 12, -7]) == 1"}
{"id": "op_beforezero_sorta_add10", "entry_point": "op_beforezero_sorta_add10", "primitives": ["beforezero", "sorta", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then add ten to each.", "solution": "def op_beforezero_sorta_add10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_beforezero_sorta_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_beforezero_sorta_add10([]) == []\nassert op_beforezero_sorta_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_beforezero_sorta_add10([5, 5, 5]) == [15, 15, 15]\nassert op_beforezero_sorta_add10([3, 1, 2]) == [11, 12, 13]\nassert op_beforezero_sorta_add10([10]) == [20]\nassert op_beforezero_sorta_add10([2, 4, 6]) == [12, 14, 16]\nassert op_beforezero_sorta_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_double_padto3_dropzeros", "entry_point": "op_double_padto3_dropzeros", "primitives": ["double", "padto3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements, then drop the zeros.", "solution": "def op_double_padto3_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_padto3_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_padto3_dropzeros([]) == []\nassert op_double_padto3_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_padto3_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_double_padto3_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_double_padto3_dropzeros([10]) == [20]\nassert op_double_padto3_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_double_padto3_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_dropfirst_sortd_double", "entry_point": "op_dropfirst_sortd_double", "primitives": ["dropfirst", "sortd", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then double each.", "solution": "def op_dropfirst_sortd_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_sortd_double([1, 2, 3, 4]) == [8, 6, 4]\nassert op_dropfirst_sortd_double([]) == []\nassert op_dropfirst_sortd_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2]\nassert op_dropfirst_sortd_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_sortd_double([3, 1, 2]) == [4, 2]\nassert op_dropfirst_sortd_double([10]) == []\nassert op_dropfirst_sortd_double([2, 4, 6]) == [12, 8]\nassert op_dropfirst_sortd_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_rev_beforezero_add10", "entry_point": "op_rev_beforezero_add10", "primitives": ["rev", "beforezero", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then add ten to each.", "solution": "def op_rev_beforezero_add10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_rev_beforezero_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_rev_beforezero_add10([]) == []\nassert op_rev_beforezero_add10([-2, -1, 0, 1, 2]) == [12, 11]\nassert op_rev_beforezero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_rev_beforezero_add10([3, 1, 2]) == [12, 11, 13]\nassert op_rev_beforezero_add10([10]) == [20]\nassert op_rev_beforezero_add10([2, 4, 6]) == [16, 14, 12]\nassert op_rev_beforezero_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_uniq_clamp10_dec", "entry_point": "op_uniq_clamp10_dec", "primitives": ["uniq", "clamp10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then subtract one from each.", "solution": "def op_uniq_clamp10_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_clamp10_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_uniq_clamp10_dec([]) == []\nassert op_uniq_clamp10_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_uniq_clamp10_dec([5, 5, 5]) == [4]\nassert op_uniq_clamp10_dec([3, 1, 2]) == [2, 0, 1]\nassert op_uniq_clamp10_dec([10]) == [9]\nassert op_uniq_clamp10_dec([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_clamp10_dec([-7, 12, -7]) == [-8, 9]"}
{"id": "op_last3_add10_first3", "entry_point": "op_last3_add10_first3", "primitives": ["last3", "add10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then keep only the first three.", "solution": "def op_last3_add10_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_last3_add10_first3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10_first3([]) == []\nassert op_last3_add10_first3([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10_first3([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_last3_add10_first3([10]) == [20]\nassert op_last3_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_first3([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_uniq_pos_negate", "entry_point": "op_uniq_pos_negate", "primitives": ["uniq", "pos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then negate each.", "solution": "def op_uniq_pos_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_pos_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_pos_negate([]) == []\nassert op_uniq_pos_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_uniq_pos_negate([5, 5, 5]) == [-5]\nassert op_uniq_pos_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_pos_negate([10]) == [-10]\nassert op_uniq_pos_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_pos_negate([-7, 12, -7]) == [-12]"}
{"id": "op_last3_absval_haszero", "entry_point": "op_last3_absval_haszero", "primitives": ["last3", "absval", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_last3_absval_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_last3_absval_haszero([1, 2, 3, 4]) == False\nassert op_last3_absval_haszero([]) == False\nassert op_last3_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_last3_absval_haszero([5, 5, 5]) == False\nassert op_last3_absval_haszero([3, 1, 2]) == False\nassert op_last3_absval_haszero([10]) == False\nassert op_last3_absval_haszero([2, 4, 6]) == False\nassert op_last3_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_trimends_add10", "entry_point": "op_dropfirst_trimends_add10", "primitives": ["dropfirst", "trimends", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then add ten to each.", "solution": "def op_dropfirst_trimends_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_trimends_add10([1, 2, 3, 4]) == [13]\nassert op_dropfirst_trimends_add10([]) == []\nassert op_dropfirst_trimends_add10([-2, -1, 0, 1, 2]) == [10, 11]\nassert op_dropfirst_trimends_add10([5, 5, 5]) == []\nassert op_dropfirst_trimends_add10([3, 1, 2]) == []\nassert op_dropfirst_trimends_add10([10]) == []\nassert op_dropfirst_trimends_add10([2, 4, 6]) == []\nassert op_dropfirst_trimends_add10([-7, 12, -7]) == []"}
{"id": "op_negate_absval_min", "entry_point": "op_negate_absval_min", "primitives": ["negate", "absval", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_negate_absval_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_negate_absval_min([1, 2, 3, 4]) == 1\nassert op_negate_absval_min([]) == 0\nassert op_negate_absval_min([-2, -1, 0, 1, 2]) == 0\nassert op_negate_absval_min([5, 5, 5]) == 5\nassert op_negate_absval_min([3, 1, 2]) == 1\nassert op_negate_absval_min([10]) == 10\nassert op_negate_absval_min([2, 4, 6]) == 2\nassert op_negate_absval_min([-7, 12, -7]) == 7"}
{"id": "op_dropzeros_odds_absval", "entry_point": "op_dropzeros_odds_absval", "primitives": ["dropzeros", "odds", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then take the absolute value of each.", "solution": "def op_dropzeros_odds_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_odds_absval([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds_absval([]) == []\nassert op_dropzeros_odds_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_dropzeros_odds_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_absval([3, 1, 2]) == [3, 1]\nassert op_dropzeros_odds_absval([10]) == []\nassert op_dropzeros_odds_absval([2, 4, 6]) == []\nassert op_dropzeros_odds_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_neg_sorta_uniq", "entry_point": "op_neg_sorta_uniq", "primitives": ["neg", "sorta", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then drop duplicates keeping first occurrence.", "solution": "def op_neg_sorta_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_neg_sorta_uniq([1, 2, 3, 4]) == []\nassert op_neg_sorta_uniq([]) == []\nassert op_neg_sorta_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_sorta_uniq([5, 5, 5]) == []\nassert op_neg_sorta_uniq([3, 1, 2]) == []\nassert op_neg_sorta_uniq([10]) == []\nassert op_neg_sorta_uniq([2, 4, 6]) == []\nassert op_neg_sorta_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_absval_negate", "entry_point": "op_padto3_absval_negate", "primitives": ["padto3", "absval", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then negate each.", "solution": "def op_padto3_absval_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_absval_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_padto3_absval_negate([]) == [0, 0, 0]\nassert op_padto3_absval_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, -1, -2]\nassert op_padto3_absval_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_absval_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_absval_negate([10]) == [-10, 0, 0]\nassert op_padto3_absval_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_absval_negate([-7, 12, -7]) == [-7, -12, -7]"}
{"id": "op_sortd_padto3_alldistinct", "entry_point": "op_sortd_padto3_alldistinct", "primitives": ["sortd", "padto3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then return whether all values are distinct.", "solution": "def op_sortd_padto3_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r) == len(set(r))", "tests": "assert op_sortd_padto3_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_padto3_alldistinct([]) == False\nassert op_sortd_padto3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_padto3_alldistinct([5, 5, 5]) == False\nassert op_sortd_padto3_alldistinct([3, 1, 2]) == True\nassert op_sortd_padto3_alldistinct([10]) == False\nassert op_sortd_padto3_alldistinct([2, 4, 6]) == True\nassert op_sortd_padto3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dec_pos_odds", "entry_point": "op_dec_pos_odds", "primitives": ["dec", "pos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_dec_pos_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_pos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dec_pos_odds([]) == []\nassert op_dec_pos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_dec_pos_odds([5, 5, 5]) == []\nassert op_dec_pos_odds([3, 1, 2]) == [1]\nassert op_dec_pos_odds([10]) == [9]\nassert op_dec_pos_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_pos_odds([-7, 12, -7]) == [11]"}
{"id": "op_dropzeros_neg_dec", "entry_point": "op_dropzeros_neg_dec", "primitives": ["dropzeros", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then subtract one from each.", "solution": "def op_dropzeros_neg_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropzeros_neg_dec([1, 2, 3, 4]) == []\nassert op_dropzeros_neg_dec([]) == []\nassert op_dropzeros_neg_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_dropzeros_neg_dec([5, 5, 5]) == []\nassert op_dropzeros_neg_dec([3, 1, 2]) == []\nassert op_dropzeros_neg_dec([10]) == []\nassert op_dropzeros_neg_dec([2, 4, 6]) == []\nassert op_dropzeros_neg_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_sorta_square_add10", "entry_point": "op_sorta_square_add10", "primitives": ["sorta", "square", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each, then add ten to each.", "solution": "def op_sorta_square_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_square_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_sorta_square_add10([]) == []\nassert op_sorta_square_add10([-2, -1, 0, 1, 2]) == [14, 11, 10, 11, 14]\nassert op_sorta_square_add10([5, 5, 5]) == [35, 35, 35]\nassert op_sorta_square_add10([3, 1, 2]) == [11, 14, 19]\nassert op_sorta_square_add10([10]) == [110]\nassert op_sorta_square_add10([2, 4, 6]) == [14, 26, 46]\nassert op_sorta_square_add10([-7, 12, -7]) == [59, 59, 154]"}
{"id": "op_trimends_dropfirst_odds", "entry_point": "op_trimends_dropfirst_odds", "primitives": ["trimends", "dropfirst", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the first element, then keep the odd numbers.", "solution": "def op_trimends_dropfirst_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_dropfirst_odds([1, 2, 3, 4]) == [3]\nassert op_trimends_dropfirst_odds([]) == []\nassert op_trimends_dropfirst_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_dropfirst_odds([5, 5, 5]) == []\nassert op_trimends_dropfirst_odds([3, 1, 2]) == []\nassert op_trimends_dropfirst_odds([10]) == []\nassert op_trimends_dropfirst_odds([2, 4, 6]) == []\nassert op_trimends_dropfirst_odds([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_absval_odds", "entry_point": "op_oremptyzero_absval_odds", "primitives": ["oremptyzero", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_oremptyzero_absval_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_absval_odds([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_absval_odds([]) == []\nassert op_oremptyzero_absval_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_oremptyzero_absval_odds([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_absval_odds([3, 1, 2]) == [3, 1]\nassert op_oremptyzero_absval_odds([10]) == []\nassert op_oremptyzero_absval_odds([2, 4, 6]) == []\nassert op_oremptyzero_absval_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_uniq_takewhilepos_add10", "entry_point": "op_uniq_takewhilepos_add10", "primitives": ["uniq", "takewhilepos", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then add ten to each.", "solution": "def op_uniq_takewhilepos_add10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_uniq_takewhilepos_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_takewhilepos_add10([]) == []\nassert op_uniq_takewhilepos_add10([-2, -1, 0, 1, 2]) == []\nassert op_uniq_takewhilepos_add10([5, 5, 5]) == [15]\nassert op_uniq_takewhilepos_add10([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_takewhilepos_add10([10]) == [20]\nassert op_uniq_takewhilepos_add10([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_takewhilepos_add10([-7, 12, -7]) == []"}
{"id": "op_uniqs_firstchar_lower", "entry_point": "op_uniqs_firstchar_lower", "primitives": ["uniqs", "firstchar", "lower"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then keep the first character of each (dropping empties), then lowercase each string.", "solution": "def op_uniqs_firstchar_lower(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[0] for s in r if s]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_uniqs_firstchar_lower(['Hello', 'world']) == ['h', 'w']\nassert op_uniqs_firstchar_lower([]) == []\nassert op_uniqs_firstchar_lower(['  a ', '', 'BC', 'bc']) == [' ', 'b', 'b']\nassert op_uniqs_firstchar_lower(['one', 'one', 'Two']) == ['o', 't']\nassert op_uniqs_firstchar_lower(['x']) == ['x']\nassert op_uniqs_firstchar_lower(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_beforezero_takewhilepos_min", "entry_point": "op_beforezero_takewhilepos_min", "primitives": ["beforezero", "takewhilepos", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_beforezero_takewhilepos_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_beforezero_takewhilepos_min([1, 2, 3, 4]) == 1\nassert op_beforezero_takewhilepos_min([]) == 0\nassert op_beforezero_takewhilepos_min([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_takewhilepos_min([5, 5, 5]) == 5\nassert op_beforezero_takewhilepos_min([3, 1, 2]) == 1\nassert op_beforezero_takewhilepos_min([10]) == 10\nassert op_beforezero_takewhilepos_min([2, 4, 6]) == 2\nassert op_beforezero_takewhilepos_min([-7, 12, -7]) == 0"}
{"id": "op_absval_dropfirst_firsteven", "entry_point": "op_absval_dropfirst_firsteven", "primitives": ["absval", "dropfirst", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first element, then return the first even value (0 if none).", "solution": "def op_absval_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_dropfirst_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_dropfirst_firsteven([]) == 0\nassert op_absval_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_absval_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_absval_dropfirst_firsteven([3, 1, 2]) == 2\nassert op_absval_dropfirst_firsteven([10]) == 0\nassert op_absval_dropfirst_firsteven([2, 4, 6]) == 4\nassert op_absval_dropfirst_firsteven([-7, 12, -7]) == 12"}
{"id": "op_ages_clamp10_oremptyzero", "entry_point": "op_ages_clamp10_oremptyzero", "primitives": ["ages", "clamp10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_ages_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_clamp10_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_clamp10_oremptyzero([]) == [0]\nassert op_ages_clamp10_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10_oremptyzero([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_odds_last3_sortd", "entry_point": "op_odds_last3_sortd", "primitives": ["odds", "last3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then sort descending.", "solution": "def op_odds_last3_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_last3_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_odds_last3_sortd([]) == []\nassert op_odds_last3_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_last3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_odds_last3_sortd([3, 1, 2]) == [3, 1]\nassert op_odds_last3_sortd([10]) == []\nassert op_odds_last3_sortd([2, 4, 6]) == []\nassert op_odds_last3_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_add10_padto3", "entry_point": "op_neg_add10_padto3", "primitives": ["neg", "add10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_neg_add10_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_add10_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_add10_padto3([]) == [0, 0, 0]\nassert op_neg_add10_padto3([-2, -1, 0, 1, 2]) == [8, 9, 0]\nassert op_neg_add10_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_add10_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_add10_padto3([10]) == [0, 0, 0]\nassert op_neg_add10_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_add10_padto3([-7, 12, -7]) == [3, 3, 0]"}
{"id": "op_odds_neg_absval", "entry_point": "op_odds_neg_absval", "primitives": ["odds", "neg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then take the absolute value of each.", "solution": "def op_odds_neg_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_neg_absval([1, 2, 3, 4]) == []\nassert op_odds_neg_absval([]) == []\nassert op_odds_neg_absval([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_neg_absval([5, 5, 5]) == []\nassert op_odds_neg_absval([3, 1, 2]) == []\nassert op_odds_neg_absval([10]) == []\nassert op_odds_neg_absval([2, 4, 6]) == []\nassert op_odds_neg_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_add10_neg_gt5", "entry_point": "op_add10_neg_gt5", "primitives": ["add10", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then keep values greater than five.", "solution": "def op_add10_neg_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_neg_gt5([1, 2, 3, 4]) == []\nassert op_add10_neg_gt5([]) == []\nassert op_add10_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_gt5([5, 5, 5]) == []\nassert op_add10_neg_gt5([3, 1, 2]) == []\nassert op_add10_neg_gt5([10]) == []\nassert op_add10_neg_gt5([2, 4, 6]) == []\nassert op_add10_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_sorta_square_counteven", "entry_point": "op_sorta_square_counteven", "primitives": ["sorta", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each, then return how many values are even.", "solution": "def op_sorta_square_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_square_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_square_counteven([]) == 0\nassert op_sorta_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_square_counteven([5, 5, 5]) == 0\nassert op_sorta_square_counteven([3, 1, 2]) == 1\nassert op_sorta_square_counteven([10]) == 1\nassert op_sorta_square_counteven([2, 4, 6]) == 3\nassert op_sorta_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_trimends_dropzeros_dropfirst", "entry_point": "op_trimends_dropzeros_dropfirst", "primitives": ["trimends", "dropzeros", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then drop the first element.", "solution": "def op_trimends_dropzeros_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_dropzeros_dropfirst([1, 2, 3, 4]) == [3]\nassert op_trimends_dropzeros_dropfirst([]) == []\nassert op_trimends_dropzeros_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_dropzeros_dropfirst([5, 5, 5]) == []\nassert op_trimends_dropzeros_dropfirst([3, 1, 2]) == []\nassert op_trimends_dropzeros_dropfirst([10]) == []\nassert op_trimends_dropzeros_dropfirst([2, 4, 6]) == []\nassert op_trimends_dropzeros_dropfirst([-7, 12, -7]) == []"}
{"id": "op_absval_rev_last3", "entry_point": "op_absval_rev_last3", "primitives": ["absval", "rev", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then keep only the last three.", "solution": "def op_absval_rev_last3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_absval_rev_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_absval_rev_last3([]) == []\nassert op_absval_rev_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_absval_rev_last3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_rev_last3([3, 1, 2]) == [2, 1, 3]\nassert op_absval_rev_last3([10]) == [10]\nassert op_absval_rev_last3([2, 4, 6]) == [6, 4, 2]\nassert op_absval_rev_last3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_odds_pos_allpos", "entry_point": "op_odds_pos_allpos", "primitives": ["odds", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_odds_pos_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_odds_pos_allpos([1, 2, 3, 4]) == True\nassert op_odds_pos_allpos([]) == True\nassert op_odds_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_odds_pos_allpos([5, 5, 5]) == True\nassert op_odds_pos_allpos([3, 1, 2]) == True\nassert op_odds_pos_allpos([10]) == True\nassert op_odds_pos_allpos([2, 4, 6]) == True\nassert op_odds_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_square_clamp10_trimends", "entry_point": "op_square_clamp10_trimends", "primitives": ["square", "clamp10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then drop the first and last elements.", "solution": "def op_square_clamp10_trimends(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_square_clamp10_trimends([1, 2, 3, 4]) == [4, 9]\nassert op_square_clamp10_trimends([]) == []\nassert op_square_clamp10_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_square_clamp10_trimends([5, 5, 5]) == [10]\nassert op_square_clamp10_trimends([3, 1, 2]) == [1]\nassert op_square_clamp10_trimends([10]) == []\nassert op_square_clamp10_trimends([2, 4, 6]) == [10]\nassert op_square_clamp10_trimends([-7, 12, -7]) == [10]"}
{"id": "op_evens_first3_sortabs", "entry_point": "op_evens_first3_sortabs", "primitives": ["evens", "first3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three, then sort by absolute value.", "solution": "def op_evens_first3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_first3_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_evens_first3_sortabs([]) == []\nassert op_evens_first3_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_evens_first3_sortabs([5, 5, 5]) == []\nassert op_evens_first3_sortabs([3, 1, 2]) == [2]\nassert op_evens_first3_sortabs([10]) == [10]\nassert op_evens_first3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_evens_first3_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_absval_first3_max", "entry_point": "op_absval_first3_max", "primitives": ["absval", "first3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_absval_first3_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_absval_first3_max([1, 2, 3, 4]) == 3\nassert op_absval_first3_max([]) == 0\nassert op_absval_first3_max([-2, -1, 0, 1, 2]) == 2\nassert op_absval_first3_max([5, 5, 5]) == 5\nassert op_absval_first3_max([3, 1, 2]) == 3\nassert op_absval_first3_max([10]) == 10\nassert op_absval_first3_max([2, 4, 6]) == 6\nassert op_absval_first3_max([-7, 12, -7]) == 12"}
{"id": "op_div3_beforezero_last3", "entry_point": "op_div3_beforezero_last3", "primitives": ["div3", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then keep only the last three.", "solution": "def op_div3_beforezero_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_div3_beforezero_last3([1, 2, 3, 4]) == [3]\nassert op_div3_beforezero_last3([]) == []\nassert op_div3_beforezero_last3([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_last3([5, 5, 5]) == []\nassert op_div3_beforezero_last3([3, 1, 2]) == [3]\nassert op_div3_beforezero_last3([10]) == []\nassert op_div3_beforezero_last3([2, 4, 6]) == [6]\nassert op_div3_beforezero_last3([-7, 12, -7]) == [12]"}
{"id": "op_prefixup_sortalpha_joinc", "entry_point": "op_prefixup_sortalpha_joinc", "primitives": ["prefixup", "sortalpha", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort alphabetically, then join them with commas.", "solution": "def op_prefixup_sortalpha_joinc(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    return ','.join(r)", "tests": "assert op_prefixup_sortalpha_joinc(['Hello', 'world']) == '#Hello,#world'\nassert op_prefixup_sortalpha_joinc([]) == ''\nassert op_prefixup_sortalpha_joinc(['  a ', '', 'BC', 'bc']) == '#,#  a ,#BC,#bc'\nassert op_prefixup_sortalpha_joinc(['one', 'one', 'Two']) == '#Two,#one,#one'\nassert op_prefixup_sortalpha_joinc(['x']) == '#x'\nassert op_prefixup_sortalpha_joinc(['abc', 'de', '']) == '#,#abc,#de'"}
{"id": "op_square_beforezero_counteven", "entry_point": "op_square_beforezero_counteven", "primitives": ["square", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then return how many values are even.", "solution": "def op_square_beforezero_counteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_square_beforezero_counteven([1, 2, 3, 4]) == 2\nassert op_square_beforezero_counteven([]) == 0\nassert op_square_beforezero_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_square_beforezero_counteven([5, 5, 5]) == 0\nassert op_square_beforezero_counteven([3, 1, 2]) == 1\nassert op_square_beforezero_counteven([10]) == 1\nassert op_square_beforezero_counteven([2, 4, 6]) == 3\nassert op_square_beforezero_counteven([-7, 12, -7]) == 1"}
{"id": "op_square_takewhilepos_dropfirst", "entry_point": "op_square_takewhilepos_dropfirst", "primitives": ["square", "takewhilepos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then drop the first element.", "solution": "def op_square_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_square_takewhilepos_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_takewhilepos_dropfirst([]) == []\nassert op_square_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_square_takewhilepos_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_takewhilepos_dropfirst([3, 1, 2]) == [1, 4]\nassert op_square_takewhilepos_dropfirst([10]) == []\nassert op_square_takewhilepos_dropfirst([2, 4, 6]) == [16, 36]\nassert op_square_takewhilepos_dropfirst([-7, 12, -7]) == [144, 49]"}
{"id": "op_inc_square_issorted", "entry_point": "op_inc_square_issorted", "primitives": ["inc", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each, then return whether the list is sorted ascending.", "solution": "def op_inc_square_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_inc_square_issorted([1, 2, 3, 4]) == True\nassert op_inc_square_issorted([]) == True\nassert op_inc_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_inc_square_issorted([5, 5, 5]) == True\nassert op_inc_square_issorted([3, 1, 2]) == False\nassert op_inc_square_issorted([10]) == True\nassert op_inc_square_issorted([2, 4, 6]) == True\nassert op_inc_square_issorted([-7, 12, -7]) == False"}
{"id": "op_odds_negate_pos", "entry_point": "op_odds_negate_pos", "primitives": ["odds", "negate", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each, then keep the positive numbers.", "solution": "def op_odds_negate_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_odds_negate_pos([1, 2, 3, 4]) == []\nassert op_odds_negate_pos([]) == []\nassert op_odds_negate_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_negate_pos([5, 5, 5]) == []\nassert op_odds_negate_pos([3, 1, 2]) == []\nassert op_odds_negate_pos([10]) == []\nassert op_odds_negate_pos([2, 4, 6]) == []\nassert op_odds_negate_pos([-7, 12, -7]) == [7, 7]"}
{"id": "op_sorta_evens_alldistinct", "entry_point": "op_sorta_evens_alldistinct", "primitives": ["sorta", "evens", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_sorta_evens_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_sorta_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_evens_alldistinct([]) == True\nassert op_sorta_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sorta_evens_alldistinct([5, 5, 5]) == True\nassert op_sorta_evens_alldistinct([3, 1, 2]) == True\nassert op_sorta_evens_alldistinct([10]) == True\nassert op_sorta_evens_alldistinct([2, 4, 6]) == True\nassert op_sorta_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_double_gt5_odds", "entry_point": "op_double_gt5_odds", "primitives": ["double", "gt5", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then keep the odd numbers.", "solution": "def op_double_gt5_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_gt5_odds([1, 2, 3, 4]) == []\nassert op_double_gt5_odds([]) == []\nassert op_double_gt5_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_odds([5, 5, 5]) == []\nassert op_double_gt5_odds([3, 1, 2]) == []\nassert op_double_gt5_odds([10]) == []\nassert op_double_gt5_odds([2, 4, 6]) == []\nassert op_double_gt5_odds([-7, 12, -7]) == []"}
{"id": "op_sortabs_add10_anyeven", "entry_point": "op_sortabs_add10_anyeven", "primitives": ["sortabs", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add ten to each, then return whether any value is even.", "solution": "def op_sortabs_add10_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_add10_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_add10_anyeven([]) == False\nassert op_sortabs_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_add10_anyeven([5, 5, 5]) == False\nassert op_sortabs_add10_anyeven([3, 1, 2]) == True\nassert op_sortabs_add10_anyeven([10]) == True\nassert op_sortabs_add10_anyeven([2, 4, 6]) == True\nassert op_sortabs_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_odds_beforezero_counteven", "entry_point": "op_odds_beforezero_counteven", "primitives": ["odds", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then return how many values are even.", "solution": "def op_odds_beforezero_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_odds_beforezero_counteven([1, 2, 3, 4]) == 0\nassert op_odds_beforezero_counteven([]) == 0\nassert op_odds_beforezero_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_beforezero_counteven([5, 5, 5]) == 0\nassert op_odds_beforezero_counteven([3, 1, 2]) == 0\nassert op_odds_beforezero_counteven([10]) == 0\nassert op_odds_beforezero_counteven([2, 4, 6]) == 0\nassert op_odds_beforezero_counteven([-7, 12, -7]) == 0"}
{"id": "op_square_sortabs_first3", "entry_point": "op_square_sortabs_first3", "primitives": ["square", "sortabs", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then keep only the first three.", "solution": "def op_square_sortabs_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_square_sortabs_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_square_sortabs_first3([]) == []\nassert op_square_sortabs_first3([-2, -1, 0, 1, 2]) == [0, 1, 1]\nassert op_square_sortabs_first3([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortabs_first3([3, 1, 2]) == [1, 4, 9]\nassert op_square_sortabs_first3([10]) == [100]\nassert op_square_sortabs_first3([2, 4, 6]) == [4, 16, 36]\nassert op_square_sortabs_first3([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dec_dropwhileneg_inc", "entry_point": "op_dec_dropwhileneg_inc", "primitives": ["dec", "dropwhileneg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then add one to each.", "solution": "def op_dec_dropwhileneg_inc(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dec_dropwhileneg_inc([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_dropwhileneg_inc([]) == []\nassert op_dec_dropwhileneg_inc([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dec_dropwhileneg_inc([5, 5, 5]) == [5, 5, 5]\nassert op_dec_dropwhileneg_inc([3, 1, 2]) == [3, 1, 2]\nassert op_dec_dropwhileneg_inc([10]) == [10]\nassert op_dec_dropwhileneg_inc([2, 4, 6]) == [2, 4, 6]\nassert op_dec_dropwhileneg_inc([-7, 12, -7]) == [12, -7]"}
{"id": "op_oremptyzero_gt5_dropfirst", "entry_point": "op_oremptyzero_gt5_dropfirst", "primitives": ["oremptyzero", "gt5", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then drop the first element.", "solution": "def op_oremptyzero_gt5_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_dropfirst([]) == []\nassert op_oremptyzero_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_dropfirst([5, 5, 5]) == []\nassert op_oremptyzero_gt5_dropfirst([3, 1, 2]) == []\nassert op_oremptyzero_gt5_dropfirst([10]) == []\nassert op_oremptyzero_gt5_dropfirst([2, 4, 6]) == []\nassert op_oremptyzero_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_trimends_sortd", "entry_point": "op_add10_trimends_sortd", "primitives": ["add10", "trimends", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then sort descending.", "solution": "def op_add10_trimends_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_trimends_sortd([1, 2, 3, 4]) == [13, 12]\nassert op_add10_trimends_sortd([]) == []\nassert op_add10_trimends_sortd([-2, -1, 0, 1, 2]) == [11, 10, 9]\nassert op_add10_trimends_sortd([5, 5, 5]) == [15]\nassert op_add10_trimends_sortd([3, 1, 2]) == [11]\nassert op_add10_trimends_sortd([10]) == []\nassert op_add10_trimends_sortd([2, 4, 6]) == [14]\nassert op_add10_trimends_sortd([-7, 12, -7]) == [22]"}
{"id": "op_sortd_sorta_pos", "entry_point": "op_sortd_sorta_pos", "primitives": ["sortd", "sorta", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then keep the positive numbers.", "solution": "def op_sortd_sorta_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sorta_pos([]) == []\nassert op_sortd_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortd_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sorta_pos([10]) == [10]\nassert op_sortd_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_rev_sorta_absval", "entry_point": "op_rev_sorta_absval", "primitives": ["rev", "sorta", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then take the absolute value of each.", "solution": "def op_rev_sorta_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_sorta_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_sorta_absval([]) == []\nassert op_rev_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_rev_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sorta_absval([10]) == [10]\nassert op_rev_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sorta_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_takewhilepos_sortd_anyeven", "entry_point": "op_takewhilepos_sortd_anyeven", "primitives": ["takewhilepos", "sortd", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort descending, then return whether any value is even.", "solution": "def op_takewhilepos_sortd_anyeven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_takewhilepos_sortd_anyeven([1, 2, 3, 4]) == True\nassert op_takewhilepos_sortd_anyeven([]) == False\nassert op_takewhilepos_sortd_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_sortd_anyeven([5, 5, 5]) == False\nassert op_takewhilepos_sortd_anyeven([3, 1, 2]) == True\nassert op_takewhilepos_sortd_anyeven([10]) == True\nassert op_takewhilepos_sortd_anyeven([2, 4, 6]) == True\nassert op_takewhilepos_sortd_anyeven([-7, 12, -7]) == False"}
{"id": "op_last3_sortd_clamp10", "entry_point": "op_last3_sortd_clamp10", "primitives": ["last3", "sortd", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then cap each value at 10.", "solution": "def op_last3_sortd_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_sortd_clamp10([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_sortd_clamp10([]) == []\nassert op_last3_sortd_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_sortd_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortd_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_last3_sortd_clamp10([10]) == [10]\nassert op_last3_sortd_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_last3_sortd_clamp10([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_evens_trimends_max", "entry_point": "op_evens_trimends_max", "primitives": ["evens", "trimends", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_evens_trimends_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_evens_trimends_max([1, 2, 3, 4]) == 0\nassert op_evens_trimends_max([]) == 0\nassert op_evens_trimends_max([-2, -1, 0, 1, 2]) == 0\nassert op_evens_trimends_max([5, 5, 5]) == 0\nassert op_evens_trimends_max([3, 1, 2]) == 0\nassert op_evens_trimends_max([10]) == 0\nassert op_evens_trimends_max([2, 4, 6]) == 4\nassert op_evens_trimends_max([-7, 12, -7]) == 0"}
{"id": "op_neg_square_alldistinct", "entry_point": "op_neg_square_alldistinct", "primitives": ["neg", "square", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each, then return whether all values are distinct.", "solution": "def op_neg_square_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_neg_square_alldistinct([1, 2, 3, 4]) == True\nassert op_neg_square_alldistinct([]) == True\nassert op_neg_square_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_neg_square_alldistinct([5, 5, 5]) == True\nassert op_neg_square_alldistinct([3, 1, 2]) == True\nassert op_neg_square_alldistinct([10]) == True\nassert op_neg_square_alldistinct([2, 4, 6]) == True\nassert op_neg_square_alldistinct([-7, 12, -7]) == False"}
{"id": "op_takewhilepos_pos_dropzeros", "entry_point": "op_takewhilepos_pos_dropzeros", "primitives": ["takewhilepos", "pos", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then drop the zeros.", "solution": "def op_takewhilepos_pos_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_pos_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_pos_dropzeros([]) == []\nassert op_takewhilepos_pos_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_pos_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_pos_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_pos_dropzeros([10]) == [10]\nassert op_takewhilepos_pos_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_pos_dropzeros([-7, 12, -7]) == []"}
{"id": "op_neg_dropzeros_sortd", "entry_point": "op_neg_dropzeros_sortd", "primitives": ["neg", "dropzeros", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then sort descending.", "solution": "def op_neg_dropzeros_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_neg_dropzeros_sortd([1, 2, 3, 4]) == []\nassert op_neg_dropzeros_sortd([]) == []\nassert op_neg_dropzeros_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_dropzeros_sortd([5, 5, 5]) == []\nassert op_neg_dropzeros_sortd([3, 1, 2]) == []\nassert op_neg_dropzeros_sortd([10]) == []\nassert op_neg_dropzeros_sortd([2, 4, 6]) == []\nassert op_neg_dropzeros_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_add10_neg_dropzeros", "entry_point": "op_add10_neg_dropzeros", "primitives": ["add10", "neg", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then drop the zeros.", "solution": "def op_add10_neg_dropzeros(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_add10_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_add10_neg_dropzeros([]) == []\nassert op_add10_neg_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_dropzeros([5, 5, 5]) == []\nassert op_add10_neg_dropzeros([3, 1, 2]) == []\nassert op_add10_neg_dropzeros([10]) == []\nassert op_add10_neg_dropzeros([2, 4, 6]) == []\nassert op_add10_neg_dropzeros([-7, 12, -7]) == []"}
{"id": "op_double_first3_clamp10", "entry_point": "op_double_first3_clamp10", "primitives": ["double", "first3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three, then cap each value at 10.", "solution": "def op_double_first3_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_first3_clamp10([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_first3_clamp10([]) == []\nassert op_double_first3_clamp10([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_double_first3_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_double_first3_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_double_first3_clamp10([10]) == [10]\nassert op_double_first3_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_double_first3_clamp10([-7, 12, -7]) == [-14, 10, -14]"}
{"id": "op_padto3_sortd_beforezero", "entry_point": "op_padto3_sortd_beforezero", "primitives": ["padto3", "sortd", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then keep everything before the first zero.", "solution": "def op_padto3_sortd_beforezero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_padto3_sortd_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_sortd_beforezero([]) == []\nassert op_padto3_sortd_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_padto3_sortd_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortd_beforezero([3, 1, 2]) == [3, 2, 1]\nassert op_padto3_sortd_beforezero([10]) == [10]\nassert op_padto3_sortd_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_sortd_beforezero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_beforezero_dropzeros_firsteven", "entry_point": "op_beforezero_dropzeros_firsteven", "primitives": ["beforezero", "dropzeros", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then return the first even value (0 if none).", "solution": "def op_beforezero_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_dropzeros_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_dropzeros_firsteven([]) == 0\nassert op_beforezero_dropzeros_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_dropzeros_firsteven([5, 5, 5]) == 0\nassert op_beforezero_dropzeros_firsteven([3, 1, 2]) == 2\nassert op_beforezero_dropzeros_firsteven([10]) == 10\nassert op_beforezero_dropzeros_firsteven([2, 4, 6]) == 2\nassert op_beforezero_dropzeros_firsteven([-7, 12, -7]) == 12"}
{"id": "op_square_odds_anyeven", "entry_point": "op_square_odds_anyeven", "primitives": ["square", "odds", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then return whether any value is even.", "solution": "def op_square_odds_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_odds_anyeven([1, 2, 3, 4]) == False\nassert op_square_odds_anyeven([]) == False\nassert op_square_odds_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_square_odds_anyeven([5, 5, 5]) == False\nassert op_square_odds_anyeven([3, 1, 2]) == False\nassert op_square_odds_anyeven([10]) == False\nassert op_square_odds_anyeven([2, 4, 6]) == False\nassert op_square_odds_anyeven([-7, 12, -7]) == False"}
{"id": "op_rev_dropzeros_pos", "entry_point": "op_rev_dropzeros_pos", "primitives": ["rev", "dropzeros", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then keep the positive numbers.", "solution": "def op_rev_dropzeros_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_dropzeros_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropzeros_pos([]) == []\nassert op_rev_dropzeros_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_dropzeros_pos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros_pos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropzeros_pos([10]) == [10]\nassert op_rev_dropzeros_pos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropzeros_pos([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_nonempty_anyempty", "entry_point": "op_uniqs_nonempty_anyempty", "primitives": ["uniqs", "nonempty", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop empty strings, then return whether any string is empty.", "solution": "def op_uniqs_nonempty_anyempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if s]\n    return any(s == '' for s in r)", "tests": "assert op_uniqs_nonempty_anyempty(['Hello', 'world']) == False\nassert op_uniqs_nonempty_anyempty([]) == False\nassert op_uniqs_nonempty_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_uniqs_nonempty_anyempty(['one', 'one', 'Two']) == False\nassert op_uniqs_nonempty_anyempty(['x']) == False\nassert op_uniqs_nonempty_anyempty(['abc', 'de', '']) == False"}
{"id": "op_inc_sorta_double", "entry_point": "op_inc_sorta_double", "primitives": ["inc", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then double each.", "solution": "def op_inc_sorta_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_sorta_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_sorta_double([]) == []\nassert op_inc_sorta_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4, 6]\nassert op_inc_sorta_double([5, 5, 5]) == [12, 12, 12]\nassert op_inc_sorta_double([3, 1, 2]) == [4, 6, 8]\nassert op_inc_sorta_double([10]) == [22]\nassert op_inc_sorta_double([2, 4, 6]) == [6, 10, 14]\nassert op_inc_sorta_double([-7, 12, -7]) == [-12, -12, 26]"}
{"id": "op_padto3_trimends_evens", "entry_point": "op_padto3_trimends_evens", "primitives": ["padto3", "trimends", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first and last elements, then keep the even numbers.", "solution": "def op_padto3_trimends_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_trimends_evens([1, 2, 3, 4]) == [2]\nassert op_padto3_trimends_evens([]) == [0]\nassert op_padto3_trimends_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_trimends_evens([5, 5, 5]) == []\nassert op_padto3_trimends_evens([3, 1, 2]) == []\nassert op_padto3_trimends_evens([10]) == [0]\nassert op_padto3_trimends_evens([2, 4, 6]) == [4]\nassert op_padto3_trimends_evens([-7, 12, -7]) == [12]"}
{"id": "op_add10_beforezero_max", "entry_point": "op_add10_beforezero_max", "primitives": ["add10", "beforezero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_add10_beforezero_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_add10_beforezero_max([1, 2, 3, 4]) == 14\nassert op_add10_beforezero_max([]) == 0\nassert op_add10_beforezero_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_beforezero_max([5, 5, 5]) == 15\nassert op_add10_beforezero_max([3, 1, 2]) == 13\nassert op_add10_beforezero_max([10]) == 20\nassert op_add10_beforezero_max([2, 4, 6]) == 16\nassert op_add10_beforezero_max([-7, 12, -7]) == 22"}
{"id": "op_div3_rev_dropwhileneg", "entry_point": "op_div3_rev_dropwhileneg", "primitives": ["div3", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then drop the leading negative values.", "solution": "def op_div3_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_div3_rev_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_div3_rev_dropwhileneg([]) == []\nassert op_div3_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev_dropwhileneg([5, 5, 5]) == []\nassert op_div3_rev_dropwhileneg([3, 1, 2]) == [3]\nassert op_div3_rev_dropwhileneg([10]) == []\nassert op_div3_rev_dropwhileneg([2, 4, 6]) == [6]\nassert op_div3_rev_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_last3_inc_issorted", "entry_point": "op_last3_inc_issorted", "primitives": ["last3", "inc", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then return whether the list is sorted ascending.", "solution": "def op_last3_inc_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_last3_inc_issorted([1, 2, 3, 4]) == True\nassert op_last3_inc_issorted([]) == True\nassert op_last3_inc_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_inc_issorted([5, 5, 5]) == True\nassert op_last3_inc_issorted([3, 1, 2]) == False\nassert op_last3_inc_issorted([10]) == True\nassert op_last3_inc_issorted([2, 4, 6]) == True\nassert op_last3_inc_issorted([-7, 12, -7]) == False"}
{"id": "op_negate_odds_padto3", "entry_point": "op_negate_odds_padto3", "primitives": ["negate", "odds", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then pad with zeros to at least three elements.", "solution": "def op_negate_odds_padto3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_negate_odds_padto3([1, 2, 3, 4]) == [-1, -3, 0]\nassert op_negate_odds_padto3([]) == [0, 0, 0]\nassert op_negate_odds_padto3([-2, -1, 0, 1, 2]) == [1, -1, 0]\nassert op_negate_odds_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_odds_padto3([3, 1, 2]) == [-3, -1, 0]\nassert op_negate_odds_padto3([10]) == [0, 0, 0]\nassert op_negate_odds_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_negate_odds_padto3([-7, 12, -7]) == [7, 7, 0]"}
{"id": "op_absval_negate_padto3", "entry_point": "op_absval_negate_padto3", "primitives": ["absval", "negate", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then pad with zeros to at least three elements.", "solution": "def op_absval_negate_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_negate_padto3([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_absval_negate_padto3([]) == [0, 0, 0]\nassert op_absval_negate_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, -1, -2]\nassert op_absval_negate_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_absval_negate_padto3([3, 1, 2]) == [-3, -1, -2]\nassert op_absval_negate_padto3([10]) == [-10, 0, 0]\nassert op_absval_negate_padto3([2, 4, 6]) == [-2, -4, -6]\nassert op_absval_negate_padto3([-7, 12, -7]) == [-7, -12, -7]"}
{"id": "op_dropzeros_odds_sorta", "entry_point": "op_dropzeros_odds_sorta", "primitives": ["dropzeros", "odds", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then sort ascending.", "solution": "def op_dropzeros_odds_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_odds_sorta([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds_sorta([]) == []\nassert op_dropzeros_odds_sorta([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_odds_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_sorta([3, 1, 2]) == [1, 3]\nassert op_dropzeros_odds_sorta([10]) == []\nassert op_dropzeros_odds_sorta([2, 4, 6]) == []\nassert op_dropzeros_odds_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_absval_gt5_sum", "entry_point": "op_absval_gt5_sum", "primitives": ["absval", "gt5", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then return their sum.", "solution": "def op_absval_gt5_sum(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_absval_gt5_sum([1, 2, 3, 4]) == 0\nassert op_absval_gt5_sum([]) == 0\nassert op_absval_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_absval_gt5_sum([5, 5, 5]) == 0\nassert op_absval_gt5_sum([3, 1, 2]) == 0\nassert op_absval_gt5_sum([10]) == 10\nassert op_absval_gt5_sum([2, 4, 6]) == 6\nassert op_absval_gt5_sum([-7, 12, -7]) == 26"}
{"id": "op_div3_neg_trimends", "entry_point": "op_div3_neg_trimends", "primitives": ["div3", "neg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_div3_neg_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_neg_trimends([1, 2, 3, 4]) == []\nassert op_div3_neg_trimends([]) == []\nassert op_div3_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_neg_trimends([5, 5, 5]) == []\nassert op_div3_neg_trimends([3, 1, 2]) == []\nassert op_div3_neg_trimends([10]) == []\nassert op_div3_neg_trimends([2, 4, 6]) == []\nassert op_div3_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_oremptyzero_negate", "entry_point": "op_dropwhileneg_oremptyzero_negate", "primitives": ["dropwhileneg", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then negate each.", "solution": "def op_dropwhileneg_oremptyzero_negate(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropwhileneg_oremptyzero_negate([]) == [0]\nassert op_dropwhileneg_oremptyzero_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropwhileneg_oremptyzero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_dropwhileneg_oremptyzero_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_dropwhileneg_oremptyzero_negate([10]) == [-10]\nassert op_dropwhileneg_oremptyzero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropwhileneg_oremptyzero_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_uniq_rev_inc", "entry_point": "op_uniq_rev_inc", "primitives": ["uniq", "rev", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order, then add one to each.", "solution": "def op_uniq_rev_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_rev_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_uniq_rev_inc([]) == []\nassert op_uniq_rev_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_uniq_rev_inc([5, 5, 5]) == [6]\nassert op_uniq_rev_inc([3, 1, 2]) == [3, 2, 4]\nassert op_uniq_rev_inc([10]) == [11]\nassert op_uniq_rev_inc([2, 4, 6]) == [7, 5, 3]\nassert op_uniq_rev_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_beforezero_first3_firsteven", "entry_point": "op_beforezero_first3_firsteven", "primitives": ["beforezero", "first3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_beforezero_first3_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_first3_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_first3_firsteven([]) == 0\nassert op_beforezero_first3_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_first3_firsteven([5, 5, 5]) == 0\nassert op_beforezero_first3_firsteven([3, 1, 2]) == 2\nassert op_beforezero_first3_firsteven([10]) == 10\nassert op_beforezero_first3_firsteven([2, 4, 6]) == 2\nassert op_beforezero_first3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_trimends_neg_rev", "entry_point": "op_trimends_neg_rev", "primitives": ["trimends", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then reverse the order.", "solution": "def op_trimends_neg_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_neg_rev([1, 2, 3, 4]) == []\nassert op_trimends_neg_rev([]) == []\nassert op_trimends_neg_rev([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_neg_rev([5, 5, 5]) == []\nassert op_trimends_neg_rev([3, 1, 2]) == []\nassert op_trimends_neg_rev([10]) == []\nassert op_trimends_neg_rev([2, 4, 6]) == []\nassert op_trimends_neg_rev([-7, 12, -7]) == []"}
{"id": "op_sortabs_trimends_counteven", "entry_point": "op_sortabs_trimends_counteven", "primitives": ["sortabs", "trimends", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then return how many values are even.", "solution": "def op_sortabs_trimends_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortabs_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_sortabs_trimends_counteven([]) == 0\nassert op_sortabs_trimends_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_sortabs_trimends_counteven([5, 5, 5]) == 0\nassert op_sortabs_trimends_counteven([3, 1, 2]) == 1\nassert op_sortabs_trimends_counteven([10]) == 0\nassert op_sortabs_trimends_counteven([2, 4, 6]) == 1\nassert op_sortabs_trimends_counteven([-7, 12, -7]) == 0"}
{"id": "op_gt5_inc_allpos", "entry_point": "op_gt5_inc_allpos", "primitives": ["gt5", "inc", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then return whether all values are positive.", "solution": "def op_gt5_inc_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_inc_allpos([1, 2, 3, 4]) == True\nassert op_gt5_inc_allpos([]) == True\nassert op_gt5_inc_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_inc_allpos([5, 5, 5]) == True\nassert op_gt5_inc_allpos([3, 1, 2]) == True\nassert op_gt5_inc_allpos([10]) == True\nassert op_gt5_inc_allpos([2, 4, 6]) == True\nassert op_gt5_inc_allpos([-7, 12, -7]) == True"}
{"id": "op_dropzeros_evens_square", "entry_point": "op_dropzeros_evens_square", "primitives": ["dropzeros", "evens", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then square each.", "solution": "def op_dropzeros_evens_square(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropzeros_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_dropzeros_evens_square([]) == []\nassert op_dropzeros_evens_square([-2, -1, 0, 1, 2]) == [4, 4]\nassert op_dropzeros_evens_square([5, 5, 5]) == []\nassert op_dropzeros_evens_square([3, 1, 2]) == [4]\nassert op_dropzeros_evens_square([10]) == [100]\nassert op_dropzeros_evens_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_pos_evens_min", "entry_point": "op_pos_evens_min", "primitives": ["pos", "evens", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_pos_evens_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_pos_evens_min([1, 2, 3, 4]) == 2\nassert op_pos_evens_min([]) == 0\nassert op_pos_evens_min([-2, -1, 0, 1, 2]) == 2\nassert op_pos_evens_min([5, 5, 5]) == 0\nassert op_pos_evens_min([3, 1, 2]) == 2\nassert op_pos_evens_min([10]) == 10\nassert op_pos_evens_min([2, 4, 6]) == 2\nassert op_pos_evens_min([-7, 12, -7]) == 12"}
{"id": "op_last3_clamp10_square", "entry_point": "op_last3_clamp10_square", "primitives": ["last3", "clamp10", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then square each.", "solution": "def op_last3_clamp10_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_clamp10_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_clamp10_square([]) == []\nassert op_last3_clamp10_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_last3_clamp10_square([5, 5, 5]) == [25, 25, 25]\nassert op_last3_clamp10_square([3, 1, 2]) == [9, 1, 4]\nassert op_last3_clamp10_square([10]) == [100]\nassert op_last3_clamp10_square([2, 4, 6]) == [4, 16, 36]\nassert op_last3_clamp10_square([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_ages_rev_oremptyzero", "entry_point": "op_ages_rev_oremptyzero", "primitives": ["ages", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then if empty, use a single zero.", "solution": "def op_ages_rev_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_rev_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_rev_oremptyzero([]) == [0]\nassert op_ages_rev_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_rev_oremptyzero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_add10_last3_anyeven", "entry_point": "op_add10_last3_anyeven", "primitives": ["add10", "last3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return whether any value is even.", "solution": "def op_add10_last3_anyeven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_add10_last3_anyeven([1, 2, 3, 4]) == True\nassert op_add10_last3_anyeven([]) == False\nassert op_add10_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_add10_last3_anyeven([5, 5, 5]) == False\nassert op_add10_last3_anyeven([3, 1, 2]) == True\nassert op_add10_last3_anyeven([10]) == True\nassert op_add10_last3_anyeven([2, 4, 6]) == True\nassert op_add10_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_rev_double", "entry_point": "op_absval_rev_double", "primitives": ["absval", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then double each.", "solution": "def op_absval_rev_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_absval_rev_double([]) == []\nassert op_absval_rev_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_absval_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_absval_rev_double([10]) == [20]\nassert op_absval_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_absval_rev_double([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_add10_takewhilepos_inc", "entry_point": "op_add10_takewhilepos_inc", "primitives": ["add10", "takewhilepos", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then add one to each.", "solution": "def op_add10_takewhilepos_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_takewhilepos_inc([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_add10_takewhilepos_inc([]) == []\nassert op_add10_takewhilepos_inc([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_add10_takewhilepos_inc([5, 5, 5]) == [16, 16, 16]\nassert op_add10_takewhilepos_inc([3, 1, 2]) == [14, 12, 13]\nassert op_add10_takewhilepos_inc([10]) == [21]\nassert op_add10_takewhilepos_inc([2, 4, 6]) == [13, 15, 17]\nassert op_add10_takewhilepos_inc([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_last3_sortabs_div3", "entry_point": "op_last3_sortabs_div3", "primitives": ["last3", "sortabs", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then keep multiples of three.", "solution": "def op_last3_sortabs_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_sortabs_div3([1, 2, 3, 4]) == [3]\nassert op_last3_sortabs_div3([]) == []\nassert op_last3_sortabs_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_sortabs_div3([5, 5, 5]) == []\nassert op_last3_sortabs_div3([3, 1, 2]) == [3]\nassert op_last3_sortabs_div3([10]) == []\nassert op_last3_sortabs_div3([2, 4, 6]) == [6]\nassert op_last3_sortabs_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_odds_haszero", "entry_point": "op_dropwhileneg_odds_haszero", "primitives": ["dropwhileneg", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_odds_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_dropwhileneg_odds_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_odds_haszero([]) == False\nassert op_dropwhileneg_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_odds_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_odds_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_odds_haszero([10]) == False\nassert op_dropwhileneg_odds_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_negate_beforezero_gt5", "entry_point": "op_negate_beforezero_gt5", "primitives": ["negate", "beforezero", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_negate_beforezero_gt5(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_negate_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_negate_beforezero_gt5([]) == []\nassert op_negate_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_negate_beforezero_gt5([5, 5, 5]) == []\nassert op_negate_beforezero_gt5([3, 1, 2]) == []\nassert op_negate_beforezero_gt5([10]) == []\nassert op_negate_beforezero_gt5([2, 4, 6]) == []\nassert op_negate_beforezero_gt5([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropwhileneg_last3_absval", "entry_point": "op_dropwhileneg_last3_absval", "primitives": ["dropwhileneg", "last3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then take the absolute value of each.", "solution": "def op_dropwhileneg_last3_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_last3_absval([]) == []\nassert op_dropwhileneg_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_last3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_last3_absval([10]) == [10]\nassert op_dropwhileneg_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_last3_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_last3_oremptyzero_clamp10", "entry_point": "op_last3_oremptyzero_clamp10", "primitives": ["last3", "oremptyzero", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then cap each value at 10.", "solution": "def op_last3_oremptyzero_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_oremptyzero_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_oremptyzero_clamp10([]) == [0]\nassert op_last3_oremptyzero_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_oremptyzero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_oremptyzero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_last3_oremptyzero_clamp10([10]) == [10]\nassert op_last3_oremptyzero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_last3_oremptyzero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_takewhilepos_negate_trimends", "entry_point": "op_takewhilepos_negate_trimends", "primitives": ["takewhilepos", "negate", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then drop the first and last elements.", "solution": "def op_takewhilepos_negate_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_negate_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_takewhilepos_negate_trimends([]) == []\nassert op_takewhilepos_negate_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_trimends([5, 5, 5]) == [-5]\nassert op_takewhilepos_negate_trimends([3, 1, 2]) == [-1]\nassert op_takewhilepos_negate_trimends([10]) == []\nassert op_takewhilepos_negate_trimends([2, 4, 6]) == [-4]\nassert op_takewhilepos_negate_trimends([-7, 12, -7]) == []"}
{"id": "op_evens_square_counteven", "entry_point": "op_evens_square_counteven", "primitives": ["evens", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then return how many values are even.", "solution": "def op_evens_square_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_square_counteven([1, 2, 3, 4]) == 2\nassert op_evens_square_counteven([]) == 0\nassert op_evens_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_square_counteven([5, 5, 5]) == 0\nassert op_evens_square_counteven([3, 1, 2]) == 1\nassert op_evens_square_counteven([10]) == 1\nassert op_evens_square_counteven([2, 4, 6]) == 3\nassert op_evens_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_pos_add10", "entry_point": "op_dropfirst_pos_add10", "primitives": ["dropfirst", "pos", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then add ten to each.", "solution": "def op_dropfirst_pos_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_pos_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_pos_add10([]) == []\nassert op_dropfirst_pos_add10([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_dropfirst_pos_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_pos_add10([3, 1, 2]) == [11, 12]\nassert op_dropfirst_pos_add10([10]) == []\nassert op_dropfirst_pos_add10([2, 4, 6]) == [14, 16]\nassert op_dropfirst_pos_add10([-7, 12, -7]) == [22]"}
{"id": "op_upper_dropshort_anyempty", "entry_point": "op_upper_dropshort_anyempty", "primitives": ["upper", "dropshort", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop strings shorter than three characters, then return whether any string is empty.", "solution": "def op_upper_dropshort_anyempty(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return any(s == '' for s in r)", "tests": "assert op_upper_dropshort_anyempty(['Hello', 'world']) == False\nassert op_upper_dropshort_anyempty([]) == False\nassert op_upper_dropshort_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_upper_dropshort_anyempty(['one', 'one', 'Two']) == False\nassert op_upper_dropshort_anyempty(['x']) == False\nassert op_upper_dropshort_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dropshort_upper_sortlen", "entry_point": "op_dropshort_upper_sortlen", "primitives": ["dropshort", "upper", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string, then sort by length, shortest first.", "solution": "def op_dropshort_upper_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_dropshort_upper_sortlen(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_dropshort_upper_sortlen([]) == []\nassert op_dropshort_upper_sortlen(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_dropshort_upper_sortlen(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_dropshort_upper_sortlen(['x']) == []\nassert op_dropshort_upper_sortlen(['abc', 'de', '']) == ['ABC']"}
{"id": "op_clamp10_padto3_beforezero", "entry_point": "op_clamp10_padto3_beforezero", "primitives": ["clamp10", "padto3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then keep everything before the first zero.", "solution": "def op_clamp10_padto3_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_padto3_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_padto3_beforezero([]) == []\nassert op_clamp10_padto3_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_padto3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3_beforezero([10]) == [10]\nassert op_clamp10_padto3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3_beforezero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_evens_dropzeros_sum", "entry_point": "op_evens_dropzeros_sum", "primitives": ["evens", "dropzeros", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then return their sum.", "solution": "def op_evens_dropzeros_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_evens_dropzeros_sum([1, 2, 3, 4]) == 6\nassert op_evens_dropzeros_sum([]) == 0\nassert op_evens_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_evens_dropzeros_sum([5, 5, 5]) == 0\nassert op_evens_dropzeros_sum([3, 1, 2]) == 2\nassert op_evens_dropzeros_sum([10]) == 10\nassert op_evens_dropzeros_sum([2, 4, 6]) == 12\nassert op_evens_dropzeros_sum([-7, 12, -7]) == 12"}
{"id": "op_inc_last3_pos", "entry_point": "op_inc_last3_pos", "primitives": ["inc", "last3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then keep the positive numbers.", "solution": "def op_inc_last3_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_last3_pos([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_last3_pos([]) == []\nassert op_inc_last3_pos([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_last3_pos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_pos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_last3_pos([10]) == [11]\nassert op_inc_last3_pos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_last3_pos([-7, 12, -7]) == [13]"}
{"id": "op_evens_odds_anyeven", "entry_point": "op_evens_odds_anyeven", "primitives": ["evens", "odds", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then return whether any value is even.", "solution": "def op_evens_odds_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_odds_anyeven([1, 2, 3, 4]) == False\nassert op_evens_odds_anyeven([]) == False\nassert op_evens_odds_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_evens_odds_anyeven([5, 5, 5]) == False\nassert op_evens_odds_anyeven([3, 1, 2]) == False\nassert op_evens_odds_anyeven([10]) == False\nassert op_evens_odds_anyeven([2, 4, 6]) == False\nassert op_evens_odds_anyeven([-7, 12, -7]) == False"}
{"id": "op_first3_dropzeros_oremptyzero", "entry_point": "op_first3_dropzeros_oremptyzero", "primitives": ["first3", "dropzeros", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then if empty, use a single zero.", "solution": "def op_first3_dropzeros_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_dropzeros_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropzeros_oremptyzero([]) == [0]\nassert op_first3_dropzeros_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_dropzeros_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropzeros_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropzeros_oremptyzero([10]) == [10]\nassert op_first3_dropzeros_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropzeros_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_oremptyzero_sorta_max", "entry_point": "op_oremptyzero_sorta_max", "primitives": ["oremptyzero", "sorta", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_oremptyzero_sorta_max(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_oremptyzero_sorta_max([1, 2, 3, 4]) == 4\nassert op_oremptyzero_sorta_max([]) == 0\nassert op_oremptyzero_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_sorta_max([5, 5, 5]) == 5\nassert op_oremptyzero_sorta_max([3, 1, 2]) == 3\nassert op_oremptyzero_sorta_max([10]) == 10\nassert op_oremptyzero_sorta_max([2, 4, 6]) == 6\nassert op_oremptyzero_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_evens_dropzeros_dropfirst", "entry_point": "op_evens_dropzeros_dropfirst", "primitives": ["evens", "dropzeros", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then drop the first element.", "solution": "def op_evens_dropzeros_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return r", "tests": "assert op_evens_dropzeros_dropfirst([1, 2, 3, 4]) == [4]\nassert op_evens_dropzeros_dropfirst([]) == []\nassert op_evens_dropzeros_dropfirst([-2, -1, 0, 1, 2]) == [2]\nassert op_evens_dropzeros_dropfirst([5, 5, 5]) == []\nassert op_evens_dropzeros_dropfirst([3, 1, 2]) == []\nassert op_evens_dropzeros_dropfirst([10]) == []\nassert op_evens_dropzeros_dropfirst([2, 4, 6]) == [4, 6]\nassert op_evens_dropzeros_dropfirst([-7, 12, -7]) == []"}
{"id": "op_dropzeros_takewhilepos_pos", "entry_point": "op_dropzeros_takewhilepos_pos", "primitives": ["dropzeros", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then keep the positive numbers.", "solution": "def op_dropzeros_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_takewhilepos_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_takewhilepos_pos([]) == []\nassert op_dropzeros_takewhilepos_pos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos_pos([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos_pos([10]) == [10]\nassert op_dropzeros_takewhilepos_pos([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos_pos([-7, 12, -7]) == []"}
{"id": "op_neg_inc_last3", "entry_point": "op_neg_inc_last3", "primitives": ["neg", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then keep only the last three.", "solution": "def op_neg_inc_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_neg_inc_last3([1, 2, 3, 4]) == []\nassert op_neg_inc_last3([]) == []\nassert op_neg_inc_last3([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_neg_inc_last3([5, 5, 5]) == []\nassert op_neg_inc_last3([3, 1, 2]) == []\nassert op_neg_inc_last3([10]) == []\nassert op_neg_inc_last3([2, 4, 6]) == []\nassert op_neg_inc_last3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_sortd_neg_rev", "entry_point": "op_sortd_neg_rev", "primitives": ["sortd", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then reverse the order.", "solution": "def op_sortd_neg_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_neg_rev([1, 2, 3, 4]) == []\nassert op_sortd_neg_rev([]) == []\nassert op_sortd_neg_rev([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sortd_neg_rev([5, 5, 5]) == []\nassert op_sortd_neg_rev([3, 1, 2]) == []\nassert op_sortd_neg_rev([10]) == []\nassert op_sortd_neg_rev([2, 4, 6]) == []\nassert op_sortd_neg_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_negate_pos_rev", "entry_point": "op_negate_pos_rev", "primitives": ["negate", "pos", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then reverse the order.", "solution": "def op_negate_pos_rev(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_negate_pos_rev([1, 2, 3, 4]) == []\nassert op_negate_pos_rev([]) == []\nassert op_negate_pos_rev([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_negate_pos_rev([5, 5, 5]) == []\nassert op_negate_pos_rev([3, 1, 2]) == []\nassert op_negate_pos_rev([10]) == []\nassert op_negate_pos_rev([2, 4, 6]) == []\nassert op_negate_pos_rev([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropfirst_sortd_len", "entry_point": "op_dropfirst_sortd_len", "primitives": ["dropfirst", "sortd", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then return how many remain.", "solution": "def op_dropfirst_sortd_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return len(r)", "tests": "assert op_dropfirst_sortd_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_sortd_len([]) == 0\nassert op_dropfirst_sortd_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_sortd_len([5, 5, 5]) == 2\nassert op_dropfirst_sortd_len([3, 1, 2]) == 2\nassert op_dropfirst_sortd_len([10]) == 0\nassert op_dropfirst_sortd_len([2, 4, 6]) == 2\nassert op_dropfirst_sortd_len([-7, 12, -7]) == 2"}
{"id": "op_dropfirst_dec_first3", "entry_point": "op_dropfirst_dec_first3", "primitives": ["dropfirst", "dec", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then keep only the first three.", "solution": "def op_dropfirst_dec_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_dec_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_dec_first3([]) == []\nassert op_dropfirst_dec_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_dropfirst_dec_first3([5, 5, 5]) == [4, 4]\nassert op_dropfirst_dec_first3([3, 1, 2]) == [0, 1]\nassert op_dropfirst_dec_first3([10]) == []\nassert op_dropfirst_dec_first3([2, 4, 6]) == [3, 5]\nassert op_dropfirst_dec_first3([-7, 12, -7]) == [11, -8]"}
{"id": "op_dropwhileneg_neg_dec", "entry_point": "op_dropwhileneg_neg_dec", "primitives": ["dropwhileneg", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then subtract one from each.", "solution": "def op_dropwhileneg_neg_dec(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_neg_dec([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg_dec([]) == []\nassert op_dropwhileneg_neg_dec([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg_dec([5, 5, 5]) == []\nassert op_dropwhileneg_neg_dec([3, 1, 2]) == []\nassert op_dropwhileneg_neg_dec([10]) == []\nassert op_dropwhileneg_neg_dec([2, 4, 6]) == []\nassert op_dropwhileneg_neg_dec([-7, 12, -7]) == [-8]"}
{"id": "op_nonempty_sortlen_upper", "entry_point": "op_nonempty_sortlen_upper", "primitives": ["nonempty", "sortlen", "upper"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort by length, shortest first, then uppercase each string.", "solution": "def op_nonempty_sortlen_upper(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_nonempty_sortlen_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_nonempty_sortlen_upper([]) == []\nassert op_nonempty_sortlen_upper(['  a ', '', 'BC', 'bc']) == ['BC', 'BC', '  A ']\nassert op_nonempty_sortlen_upper(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_nonempty_sortlen_upper(['x']) == ['X']\nassert op_nonempty_sortlen_upper(['abc', 'de', '']) == ['DE', 'ABC']"}
{"id": "op_inc_dec_double", "entry_point": "op_inc_dec_double", "primitives": ["inc", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then double each.", "solution": "def op_inc_dec_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_dec_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_inc_dec_double([]) == []\nassert op_inc_dec_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_inc_dec_double([5, 5, 5]) == [10, 10, 10]\nassert op_inc_dec_double([3, 1, 2]) == [6, 2, 4]\nassert op_inc_dec_double([10]) == [20]\nassert op_inc_dec_double([2, 4, 6]) == [4, 8, 12]\nassert op_inc_dec_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_negate_gt5_allpos", "entry_point": "op_negate_gt5_allpos", "primitives": ["negate", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then return whether all values are positive.", "solution": "def op_negate_gt5_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_negate_gt5_allpos([1, 2, 3, 4]) == True\nassert op_negate_gt5_allpos([]) == True\nassert op_negate_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_negate_gt5_allpos([5, 5, 5]) == True\nassert op_negate_gt5_allpos([3, 1, 2]) == True\nassert op_negate_gt5_allpos([10]) == True\nassert op_negate_gt5_allpos([2, 4, 6]) == True\nassert op_negate_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_sortd_padto3_evens", "entry_point": "op_sortd_padto3_evens", "primitives": ["sortd", "padto3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then keep the even numbers.", "solution": "def op_sortd_padto3_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_padto3_evens([1, 2, 3, 4]) == [4, 2]\nassert op_sortd_padto3_evens([]) == [0, 0, 0]\nassert op_sortd_padto3_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_sortd_padto3_evens([5, 5, 5]) == []\nassert op_sortd_padto3_evens([3, 1, 2]) == [2]\nassert op_sortd_padto3_evens([10]) == [10, 0, 0]\nassert op_sortd_padto3_evens([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_padto3_evens([-7, 12, -7]) == [12]"}
{"id": "op_gt5_neg_oremptyzero", "entry_point": "op_gt5_neg_oremptyzero", "primitives": ["gt5", "neg", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_gt5_neg_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_neg_oremptyzero([]) == [0]\nassert op_gt5_neg_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_neg_oremptyzero([10]) == [0]\nassert op_gt5_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_gt5_neg_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_pos_trimends_last3", "entry_point": "op_pos_trimends_last3", "primitives": ["pos", "trimends", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then keep only the last three.", "solution": "def op_pos_trimends_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = r[-3:]\n    return r", "tests": "assert op_pos_trimends_last3([1, 2, 3, 4]) == [2, 3]\nassert op_pos_trimends_last3([]) == []\nassert op_pos_trimends_last3([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_last3([5, 5, 5]) == [5]\nassert op_pos_trimends_last3([3, 1, 2]) == [1]\nassert op_pos_trimends_last3([10]) == []\nassert op_pos_trimends_last3([2, 4, 6]) == [4]\nassert op_pos_trimends_last3([-7, 12, -7]) == []"}
{"id": "op_absval_uniq_anyeven", "entry_point": "op_absval_uniq_anyeven", "primitives": ["absval", "uniq", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_absval_uniq_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_absval_uniq_anyeven([]) == False\nassert op_absval_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_uniq_anyeven([5, 5, 5]) == False\nassert op_absval_uniq_anyeven([3, 1, 2]) == True\nassert op_absval_uniq_anyeven([10]) == True\nassert op_absval_uniq_anyeven([2, 4, 6]) == True\nassert op_absval_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_double_min", "entry_point": "op_sortd_double_min", "primitives": ["sortd", "double", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then return the minimum (0 if empty).", "solution": "def op_sortd_double_min(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_sortd_double_min([1, 2, 3, 4]) == 2\nassert op_sortd_double_min([]) == 0\nassert op_sortd_double_min([-2, -1, 0, 1, 2]) == -4\nassert op_sortd_double_min([5, 5, 5]) == 10\nassert op_sortd_double_min([3, 1, 2]) == 2\nassert op_sortd_double_min([10]) == 20\nassert op_sortd_double_min([2, 4, 6]) == 4\nassert op_sortd_double_min([-7, 12, -7]) == -14"}
{"id": "op_takewhilepos_dropwhileneg_dec", "entry_point": "op_takewhilepos_dropwhileneg_dec", "primitives": ["takewhilepos", "dropwhileneg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then subtract one from each.", "solution": "def op_takewhilepos_dropwhileneg_dec(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_takewhilepos_dropwhileneg_dec([]) == []\nassert op_takewhilepos_dropwhileneg_dec([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_dec([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_dropwhileneg_dec([3, 1, 2]) == [2, 0, 1]\nassert op_takewhilepos_dropwhileneg_dec([10]) == [9]\nassert op_takewhilepos_dropwhileneg_dec([2, 4, 6]) == [1, 3, 5]\nassert op_takewhilepos_dropwhileneg_dec([-7, 12, -7]) == []"}
{"id": "op_last3_beforezero_absval", "entry_point": "op_last3_beforezero_absval", "primitives": ["last3", "beforezero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_last3_beforezero_absval(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_last3_beforezero_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_beforezero_absval([]) == []\nassert op_last3_beforezero_absval([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_absval([3, 1, 2]) == [3, 1, 2]\nassert op_last3_beforezero_absval([10]) == [10]\nassert op_last3_beforezero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_last3_beforezero_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_negate_uniq", "entry_point": "op_double_negate_uniq", "primitives": ["double", "negate", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_double_negate_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_negate_uniq([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_negate_uniq([]) == []\nassert op_double_negate_uniq([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_negate_uniq([5, 5, 5]) == [-10]\nassert op_double_negate_uniq([3, 1, 2]) == [-6, -2, -4]\nassert op_double_negate_uniq([10]) == [-20]\nassert op_double_negate_uniq([2, 4, 6]) == [-4, -8, -12]\nassert op_double_negate_uniq([-7, 12, -7]) == [14, -24]"}
{"id": "op_absval_sortabs_last3", "entry_point": "op_absval_sortabs_last3", "primitives": ["absval", "sortabs", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then keep only the last three.", "solution": "def op_absval_sortabs_last3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_absval_sortabs_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_sortabs_last3([]) == []\nassert op_absval_sortabs_last3([-2, -1, 0, 1, 2]) == [1, 2, 2]\nassert op_absval_sortabs_last3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortabs_last3([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortabs_last3([10]) == [10]\nassert op_absval_sortabs_last3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortabs_last3([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_inc_sorta_add10", "entry_point": "op_inc_sorta_add10", "primitives": ["inc", "sorta", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then add ten to each.", "solution": "def op_inc_sorta_add10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_inc_sorta_add10([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_sorta_add10([]) == []\nassert op_inc_sorta_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_sorta_add10([5, 5, 5]) == [16, 16, 16]\nassert op_inc_sorta_add10([3, 1, 2]) == [12, 13, 14]\nassert op_inc_sorta_add10([10]) == [21]\nassert op_inc_sorta_add10([2, 4, 6]) == [13, 15, 17]\nassert op_inc_sorta_add10([-7, 12, -7]) == [4, 4, 23]"}
{"id": "op_ages_gt5_add10", "entry_point": "op_ages_gt5_add10", "primitives": ["ages", "gt5", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep values greater than five, then add ten to each.", "solution": "def op_ages_gt5_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_gt5_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_gt5_add10([]) == []\nassert op_ages_gt5_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_gt5_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_gt5_padto3_neg", "entry_point": "op_gt5_padto3_neg", "primitives": ["gt5", "padto3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_gt5_padto3_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_gt5_padto3_neg([1, 2, 3, 4]) == []\nassert op_gt5_padto3_neg([]) == []\nassert op_gt5_padto3_neg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_padto3_neg([5, 5, 5]) == []\nassert op_gt5_padto3_neg([3, 1, 2]) == []\nassert op_gt5_padto3_neg([10]) == []\nassert op_gt5_padto3_neg([2, 4, 6]) == []\nassert op_gt5_padto3_neg([-7, 12, -7]) == []"}
{"id": "op_sortabs_first3_last3", "entry_point": "op_sortabs_first3_last3", "primitives": ["sortabs", "first3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then keep only the last three.", "solution": "def op_sortabs_first3_last3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = r[-3:]\n    return r", "tests": "assert op_sortabs_first3_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_first3_last3([]) == []\nassert op_sortabs_first3_last3([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_sortabs_first3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_first3_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_first3_last3([10]) == [10]\nassert op_sortabs_first3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_first3_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_nonempty_dropshort_firstchar", "entry_point": "op_nonempty_dropshort_firstchar", "primitives": ["nonempty", "dropshort", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop strings shorter than three characters, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_dropshort_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_dropshort_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_nonempty_dropshort_firstchar([]) == []\nassert op_nonempty_dropshort_firstchar(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_nonempty_dropshort_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_nonempty_dropshort_firstchar(['x']) == []\nassert op_nonempty_dropshort_firstchar(['abc', 'de', '']) == ['a']"}
{"id": "op_trimends_double_dropwhileneg", "entry_point": "op_trimends_double_dropwhileneg", "primitives": ["trimends", "double", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then drop the leading negative values.", "solution": "def op_trimends_double_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_double_dropwhileneg([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_double_dropwhileneg([]) == []\nassert op_trimends_double_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_trimends_double_dropwhileneg([5, 5, 5]) == [10]\nassert op_trimends_double_dropwhileneg([3, 1, 2]) == [2]\nassert op_trimends_double_dropwhileneg([10]) == []\nassert op_trimends_double_dropwhileneg([2, 4, 6]) == [8]\nassert op_trimends_double_dropwhileneg([-7, 12, -7]) == [24]"}
{"id": "op_last3_dec_dropzeros", "entry_point": "op_last3_dec_dropzeros", "primitives": ["last3", "dec", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then drop the zeros.", "solution": "def op_last3_dec_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_dec_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_dec_dropzeros([]) == []\nassert op_last3_dec_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_last3_dec_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_last3_dec_dropzeros([3, 1, 2]) == [2, 1]\nassert op_last3_dec_dropzeros([10]) == [9]\nassert op_last3_dec_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_last3_dec_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_gt5_sortabs_anyeven", "entry_point": "op_gt5_sortabs_anyeven", "primitives": ["gt5", "sortabs", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then return whether any value is even.", "solution": "def op_gt5_sortabs_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_sortabs_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_sortabs_anyeven([]) == False\nassert op_gt5_sortabs_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_sortabs_anyeven([5, 5, 5]) == False\nassert op_gt5_sortabs_anyeven([3, 1, 2]) == False\nassert op_gt5_sortabs_anyeven([10]) == True\nassert op_gt5_sortabs_anyeven([2, 4, 6]) == True\nassert op_gt5_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_rev_oremptyzero", "entry_point": "op_sorta_rev_oremptyzero", "primitives": ["sorta", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then if empty, use a single zero.", "solution": "def op_sorta_rev_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_rev_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_rev_oremptyzero([]) == [0]\nassert op_sorta_rev_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_rev_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_rev_oremptyzero([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_rev_oremptyzero([10]) == [10]\nassert op_sorta_rev_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_rev_oremptyzero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_first3_oremptyzero_counteven", "entry_point": "op_first3_oremptyzero_counteven", "primitives": ["first3", "oremptyzero", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then return how many values are even.", "solution": "def op_first3_oremptyzero_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_oremptyzero_counteven([1, 2, 3, 4]) == 1\nassert op_first3_oremptyzero_counteven([]) == 1\nassert op_first3_oremptyzero_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_oremptyzero_counteven([5, 5, 5]) == 0\nassert op_first3_oremptyzero_counteven([3, 1, 2]) == 1\nassert op_first3_oremptyzero_counteven([10]) == 1\nassert op_first3_oremptyzero_counteven([2, 4, 6]) == 3\nassert op_first3_oremptyzero_counteven([-7, 12, -7]) == 1"}
{"id": "op_sorta_padto3_min", "entry_point": "op_sorta_padto3_min", "primitives": ["sorta", "padto3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_sorta_padto3_min(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_sorta_padto3_min([1, 2, 3, 4]) == 1\nassert op_sorta_padto3_min([]) == 0\nassert op_sorta_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_padto3_min([5, 5, 5]) == 5\nassert op_sorta_padto3_min([3, 1, 2]) == 1\nassert op_sorta_padto3_min([10]) == 0\nassert op_sorta_padto3_min([2, 4, 6]) == 2\nassert op_sorta_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_sorta_dropzeros_add10", "entry_point": "op_sorta_dropzeros_add10", "primitives": ["sorta", "dropzeros", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then add ten to each.", "solution": "def op_sorta_dropzeros_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_dropzeros_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sorta_dropzeros_add10([]) == []\nassert op_sorta_dropzeros_add10([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_sorta_dropzeros_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_dropzeros_add10([3, 1, 2]) == [11, 12, 13]\nassert op_sorta_dropzeros_add10([10]) == [20]\nassert op_sorta_dropzeros_add10([2, 4, 6]) == [12, 14, 16]\nassert op_sorta_dropzeros_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_dropwhileneg_inc_double", "entry_point": "op_dropwhileneg_inc_double", "primitives": ["dropwhileneg", "inc", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add one to each, then double each.", "solution": "def op_dropwhileneg_inc_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_inc_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_dropwhileneg_inc_double([]) == []\nassert op_dropwhileneg_inc_double([-2, -1, 0, 1, 2]) == [2, 4, 6]\nassert op_dropwhileneg_inc_double([5, 5, 5]) == [12, 12, 12]\nassert op_dropwhileneg_inc_double([3, 1, 2]) == [8, 4, 6]\nassert op_dropwhileneg_inc_double([10]) == [22]\nassert op_dropwhileneg_inc_double([2, 4, 6]) == [6, 10, 14]\nassert op_dropwhileneg_inc_double([-7, 12, -7]) == [26, -12]"}
{"id": "op_gt5_pos_oremptyzero", "entry_point": "op_gt5_pos_oremptyzero", "primitives": ["gt5", "pos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_gt5_pos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_pos_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_gt5_pos_oremptyzero([]) == [0]\nassert op_gt5_pos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_pos_oremptyzero([5, 5, 5]) == [0]\nassert op_gt5_pos_oremptyzero([3, 1, 2]) == [0]\nassert op_gt5_pos_oremptyzero([10]) == [10]\nassert op_gt5_pos_oremptyzero([2, 4, 6]) == [6]\nassert op_gt5_pos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_dec_inc_absval", "entry_point": "op_dec_inc_absval", "primitives": ["dec", "inc", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then take the absolute value of each.", "solution": "def op_dec_inc_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_inc_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc_absval([]) == []\nassert op_dec_inc_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_dec_inc_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc_absval([10]) == [10]\nassert op_dec_inc_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_uniq_allpos", "entry_point": "op_double_uniq_allpos", "primitives": ["double", "uniq", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_double_uniq_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_double_uniq_allpos([1, 2, 3, 4]) == True\nassert op_double_uniq_allpos([]) == True\nassert op_double_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_double_uniq_allpos([5, 5, 5]) == True\nassert op_double_uniq_allpos([3, 1, 2]) == True\nassert op_double_uniq_allpos([10]) == True\nassert op_double_uniq_allpos([2, 4, 6]) == True\nassert op_double_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_pos_oremptyzero", "entry_point": "op_div3_pos_oremptyzero", "primitives": ["div3", "pos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_div3_pos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_pos_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_div3_pos_oremptyzero([]) == [0]\nassert op_div3_pos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_pos_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_pos_oremptyzero([3, 1, 2]) == [3]\nassert op_div3_pos_oremptyzero([10]) == [0]\nassert op_div3_pos_oremptyzero([2, 4, 6]) == [6]\nassert op_div3_pos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_gt5_dec_allpos", "entry_point": "op_gt5_dec_allpos", "primitives": ["gt5", "dec", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then return whether all values are positive.", "solution": "def op_gt5_dec_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_dec_allpos([1, 2, 3, 4]) == True\nassert op_gt5_dec_allpos([]) == True\nassert op_gt5_dec_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_dec_allpos([5, 5, 5]) == True\nassert op_gt5_dec_allpos([3, 1, 2]) == True\nassert op_gt5_dec_allpos([10]) == True\nassert op_gt5_dec_allpos([2, 4, 6]) == True\nassert op_gt5_dec_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_neg_clamp10", "entry_point": "op_dec_neg_clamp10", "primitives": ["dec", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then cap each value at 10.", "solution": "def op_dec_neg_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_neg_clamp10([1, 2, 3, 4]) == []\nassert op_dec_neg_clamp10([]) == []\nassert op_dec_neg_clamp10([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_neg_clamp10([5, 5, 5]) == []\nassert op_dec_neg_clamp10([3, 1, 2]) == []\nassert op_dec_neg_clamp10([10]) == []\nassert op_dec_neg_clamp10([2, 4, 6]) == []\nassert op_dec_neg_clamp10([-7, 12, -7]) == [-8, -8]"}
{"id": "op_dropfirst_sortabs_neg", "entry_point": "op_dropfirst_sortabs_neg", "primitives": ["dropfirst", "sortabs", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then keep the negative numbers.", "solution": "def op_dropfirst_sortabs_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_sortabs_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_sortabs_neg([]) == []\nassert op_dropfirst_sortabs_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_sortabs_neg([5, 5, 5]) == []\nassert op_dropfirst_sortabs_neg([3, 1, 2]) == []\nassert op_dropfirst_sortabs_neg([10]) == []\nassert op_dropfirst_sortabs_neg([2, 4, 6]) == []\nassert op_dropfirst_sortabs_neg([-7, 12, -7]) == [-7]"}
{"id": "op_double_oremptyzero_padto3", "entry_point": "op_double_oremptyzero_padto3", "primitives": ["double", "oremptyzero", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_double_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_double_oremptyzero_padto3([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_double_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_oremptyzero_padto3([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_padto3([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_padto3([10]) == [20, 0, 0]\nassert op_double_oremptyzero_padto3([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_padto3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_pos_last3_square", "entry_point": "op_pos_last3_square", "primitives": ["pos", "last3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then square each.", "solution": "def op_pos_last3_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_last3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_pos_last3_square([]) == []\nassert op_pos_last3_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_last3_square([5, 5, 5]) == [25, 25, 25]\nassert op_pos_last3_square([3, 1, 2]) == [9, 1, 4]\nassert op_pos_last3_square([10]) == [100]\nassert op_pos_last3_square([2, 4, 6]) == [4, 16, 36]\nassert op_pos_last3_square([-7, 12, -7]) == [144]"}
{"id": "op_clamp10_negate_anyeven", "entry_point": "op_clamp10_negate_anyeven", "primitives": ["clamp10", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then return whether any value is even.", "solution": "def op_clamp10_negate_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_negate_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_negate_anyeven([]) == False\nassert op_clamp10_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_negate_anyeven([5, 5, 5]) == False\nassert op_clamp10_negate_anyeven([3, 1, 2]) == True\nassert op_clamp10_negate_anyeven([10]) == True\nassert op_clamp10_negate_anyeven([2, 4, 6]) == True\nassert op_clamp10_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_evens_absval", "entry_point": "op_sortd_evens_absval", "primitives": ["sortd", "evens", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then take the absolute value of each.", "solution": "def op_sortd_evens_absval(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortd_evens_absval([1, 2, 3, 4]) == [4, 2]\nassert op_sortd_evens_absval([]) == []\nassert op_sortd_evens_absval([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_sortd_evens_absval([5, 5, 5]) == []\nassert op_sortd_evens_absval([3, 1, 2]) == [2]\nassert op_sortd_evens_absval([10]) == [10]\nassert op_sortd_evens_absval([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_evens_absval([-7, 12, -7]) == [12]"}
{"id": "op_negate_pos_odds", "entry_point": "op_negate_pos_odds", "primitives": ["negate", "pos", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_negate_pos_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_pos_odds([1, 2, 3, 4]) == []\nassert op_negate_pos_odds([]) == []\nassert op_negate_pos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_negate_pos_odds([5, 5, 5]) == []\nassert op_negate_pos_odds([3, 1, 2]) == []\nassert op_negate_pos_odds([10]) == []\nassert op_negate_pos_odds([2, 4, 6]) == []\nassert op_negate_pos_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_gt5_double_takewhilepos", "entry_point": "op_gt5_double_takewhilepos", "primitives": ["gt5", "double", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then take values while they are positive.", "solution": "def op_gt5_double_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_double_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_double_takewhilepos([]) == []\nassert op_gt5_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_double_takewhilepos([5, 5, 5]) == []\nassert op_gt5_double_takewhilepos([3, 1, 2]) == []\nassert op_gt5_double_takewhilepos([10]) == [20]\nassert op_gt5_double_takewhilepos([2, 4, 6]) == [12]\nassert op_gt5_double_takewhilepos([-7, 12, -7]) == [24]"}
{"id": "op_ages_dec_clamp10", "entry_point": "op_ages_dec_clamp10", "primitives": ["ages", "dec", "clamp10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then cap each value at 10.", "solution": "def op_ages_dec_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_dec_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_dec_clamp10([]) == []\nassert op_ages_dec_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_dec_clamp10([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_trimends_first3_allpos", "entry_point": "op_trimends_first3_allpos", "primitives": ["trimends", "first3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then return whether all values are positive.", "solution": "def op_trimends_first3_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_first3_allpos([1, 2, 3, 4]) == True\nassert op_trimends_first3_allpos([]) == True\nassert op_trimends_first3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_first3_allpos([5, 5, 5]) == True\nassert op_trimends_first3_allpos([3, 1, 2]) == True\nassert op_trimends_first3_allpos([10]) == True\nassert op_trimends_first3_allpos([2, 4, 6]) == True\nassert op_trimends_first3_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_evens_gt5", "entry_point": "op_takewhilepos_evens_gt5", "primitives": ["takewhilepos", "evens", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers, then keep values greater than five.", "solution": "def op_takewhilepos_evens_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_evens_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_evens_gt5([]) == []\nassert op_takewhilepos_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens_gt5([5, 5, 5]) == []\nassert op_takewhilepos_evens_gt5([3, 1, 2]) == []\nassert op_takewhilepos_evens_gt5([10]) == [10]\nassert op_takewhilepos_evens_gt5([2, 4, 6]) == [6]\nassert op_takewhilepos_evens_gt5([-7, 12, -7]) == []"}
{"id": "op_negate_div3_oremptyzero", "entry_point": "op_negate_div3_oremptyzero", "primitives": ["negate", "div3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then if empty, use a single zero.", "solution": "def op_negate_div3_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_div3_oremptyzero([1, 2, 3, 4]) == [-3]\nassert op_negate_div3_oremptyzero([]) == [0]\nassert op_negate_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_negate_div3_oremptyzero([3, 1, 2]) == [-3]\nassert op_negate_div3_oremptyzero([10]) == [0]\nassert op_negate_div3_oremptyzero([2, 4, 6]) == [-6]\nassert op_negate_div3_oremptyzero([-7, 12, -7]) == [-12]"}
{"id": "op_dropwhileneg_oremptyzero_evens", "entry_point": "op_dropwhileneg_oremptyzero_evens", "primitives": ["dropwhileneg", "oremptyzero", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_dropwhileneg_oremptyzero_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropwhileneg_oremptyzero_evens([]) == [0]\nassert op_dropwhileneg_oremptyzero_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropwhileneg_oremptyzero_evens([5, 5, 5]) == []\nassert op_dropwhileneg_oremptyzero_evens([3, 1, 2]) == [2]\nassert op_dropwhileneg_oremptyzero_evens([10]) == [10]\nassert op_dropwhileneg_oremptyzero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_oremptyzero_evens([-7, 12, -7]) == [12]"}
{"id": "op_dec_sorta_dropfirst", "entry_point": "op_dec_sorta_dropfirst", "primitives": ["dec", "sorta", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then drop the first element.", "solution": "def op_dec_sorta_dropfirst(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    r = r[1:]\n    return r", "tests": "assert op_dec_sorta_dropfirst([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_sorta_dropfirst([]) == []\nassert op_dec_sorta_dropfirst([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1]\nassert op_dec_sorta_dropfirst([5, 5, 5]) == [4, 4]\nassert op_dec_sorta_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dec_sorta_dropfirst([10]) == []\nassert op_dec_sorta_dropfirst([2, 4, 6]) == [3, 5]\nassert op_dec_sorta_dropfirst([-7, 12, -7]) == [-8, 11]"}
{"id": "op_last3_gt5_sortabs", "entry_point": "op_last3_gt5_sortabs", "primitives": ["last3", "gt5", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep values greater than five, then sort by absolute value.", "solution": "def op_last3_gt5_sortabs(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_last3_gt5_sortabs([1, 2, 3, 4]) == []\nassert op_last3_gt5_sortabs([]) == []\nassert op_last3_gt5_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_last3_gt5_sortabs([5, 5, 5]) == []\nassert op_last3_gt5_sortabs([3, 1, 2]) == []\nassert op_last3_gt5_sortabs([10]) == [10]\nassert op_last3_gt5_sortabs([2, 4, 6]) == [6]\nassert op_last3_gt5_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_inc_sortd_min", "entry_point": "op_inc_sortd_min", "primitives": ["inc", "sortd", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then return the minimum (0 if empty).", "solution": "def op_inc_sortd_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_inc_sortd_min([1, 2, 3, 4]) == 2\nassert op_inc_sortd_min([]) == 0\nassert op_inc_sortd_min([-2, -1, 0, 1, 2]) == -1\nassert op_inc_sortd_min([5, 5, 5]) == 6\nassert op_inc_sortd_min([3, 1, 2]) == 2\nassert op_inc_sortd_min([10]) == 11\nassert op_inc_sortd_min([2, 4, 6]) == 3\nassert op_inc_sortd_min([-7, 12, -7]) == -6"}
{"id": "op_odds_last3_gt5", "entry_point": "op_odds_last3_gt5", "primitives": ["odds", "last3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then keep values greater than five.", "solution": "def op_odds_last3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_last3_gt5([1, 2, 3, 4]) == []\nassert op_odds_last3_gt5([]) == []\nassert op_odds_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_last3_gt5([5, 5, 5]) == []\nassert op_odds_last3_gt5([3, 1, 2]) == []\nassert op_odds_last3_gt5([10]) == []\nassert op_odds_last3_gt5([2, 4, 6]) == []\nassert op_odds_last3_gt5([-7, 12, -7]) == []"}
{"id": "op_dec_double_evens", "entry_point": "op_dec_double_evens", "primitives": ["dec", "double", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then keep the even numbers.", "solution": "def op_dec_double_evens(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dec_double_evens([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_dec_double_evens([]) == []\nassert op_dec_double_evens([-2, -1, 0, 1, 2]) == [-6, -4, -2, 0, 2]\nassert op_dec_double_evens([5, 5, 5]) == [8, 8, 8]\nassert op_dec_double_evens([3, 1, 2]) == [4, 0, 2]\nassert op_dec_double_evens([10]) == [18]\nassert op_dec_double_evens([2, 4, 6]) == [2, 6, 10]\nassert op_dec_double_evens([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_dropzeros_add10_counteven", "entry_point": "op_dropzeros_add10_counteven", "primitives": ["dropzeros", "add10", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then return how many values are even.", "solution": "def op_dropzeros_add10_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_add10_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_add10_counteven([]) == 0\nassert op_dropzeros_add10_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_add10_counteven([5, 5, 5]) == 0\nassert op_dropzeros_add10_counteven([3, 1, 2]) == 1\nassert op_dropzeros_add10_counteven([10]) == 1\nassert op_dropzeros_add10_counteven([2, 4, 6]) == 3\nassert op_dropzeros_add10_counteven([-7, 12, -7]) == 1"}
{"id": "op_double_neg_dec", "entry_point": "op_double_neg_dec", "primitives": ["double", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the negative numbers, then subtract one from each.", "solution": "def op_double_neg_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_neg_dec([1, 2, 3, 4]) == []\nassert op_double_neg_dec([]) == []\nassert op_double_neg_dec([-2, -1, 0, 1, 2]) == [-5, -3]\nassert op_double_neg_dec([5, 5, 5]) == []\nassert op_double_neg_dec([3, 1, 2]) == []\nassert op_double_neg_dec([10]) == []\nassert op_double_neg_dec([2, 4, 6]) == []\nassert op_double_neg_dec([-7, 12, -7]) == [-15, -15]"}
{"id": "op_oremptyzero_square_inc", "entry_point": "op_oremptyzero_square_inc", "primitives": ["oremptyzero", "square", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then add one to each.", "solution": "def op_oremptyzero_square_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_square_inc([1, 2, 3, 4]) == [2, 5, 10, 17]\nassert op_oremptyzero_square_inc([]) == [1]\nassert op_oremptyzero_square_inc([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_oremptyzero_square_inc([5, 5, 5]) == [26, 26, 26]\nassert op_oremptyzero_square_inc([3, 1, 2]) == [10, 2, 5]\nassert op_oremptyzero_square_inc([10]) == [101]\nassert op_oremptyzero_square_inc([2, 4, 6]) == [5, 17, 37]\nassert op_oremptyzero_square_inc([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_absval_add10_double", "entry_point": "op_absval_add10_double", "primitives": ["absval", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then double each.", "solution": "def op_absval_add10_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_add10_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_absval_add10_double([]) == []\nassert op_absval_add10_double([-2, -1, 0, 1, 2]) == [24, 22, 20, 22, 24]\nassert op_absval_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_absval_add10_double([3, 1, 2]) == [26, 22, 24]\nassert op_absval_add10_double([10]) == [40]\nassert op_absval_add10_double([2, 4, 6]) == [24, 28, 32]\nassert op_absval_add10_double([-7, 12, -7]) == [34, 44, 34]"}
{"id": "op_ages_add10_last3", "entry_point": "op_ages_add10_last3", "primitives": ["ages", "add10", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then keep only the last three.", "solution": "def op_ages_add10_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_add10_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_add10_last3([]) == []\nassert op_ages_add10_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_add10_last3([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_ages_add10_gt5", "entry_point": "op_ages_add10_gt5", "primitives": ["ages", "add10", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then keep values greater than five.", "solution": "def op_ages_add10_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_add10_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_add10_gt5([]) == []\nassert op_ages_add10_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_add10_gt5([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_strip_uniqs_upper", "entry_point": "op_strip_uniqs_upper", "primitives": ["strip", "uniqs", "upper"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first, then uppercase each string.", "solution": "def op_strip_uniqs_upper(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_strip_uniqs_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_strip_uniqs_upper([]) == []\nassert op_strip_uniqs_upper(['  a ', '', 'BC', 'bc']) == ['A', '', 'BC', 'BC']\nassert op_strip_uniqs_upper(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_strip_uniqs_upper(['x']) == ['X']\nassert op_strip_uniqs_upper(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_dec_oremptyzero_len", "entry_point": "op_dec_oremptyzero_len", "primitives": ["dec", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then return how many remain.", "solution": "def op_dec_oremptyzero_len(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_dec_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_dec_oremptyzero_len([]) == 1\nassert op_dec_oremptyzero_len([-2, -1, 0, 1, 2]) == 5\nassert op_dec_oremptyzero_len([5, 5, 5]) == 3\nassert op_dec_oremptyzero_len([3, 1, 2]) == 3\nassert op_dec_oremptyzero_len([10]) == 1\nassert op_dec_oremptyzero_len([2, 4, 6]) == 3\nassert op_dec_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_last3_inc", "entry_point": "op_sortd_last3_inc", "primitives": ["sortd", "last3", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three, then add one to each.", "solution": "def op_sortd_last3_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_last3_inc([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortd_last3_inc([]) == []\nassert op_sortd_last3_inc([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortd_last3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_last3_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_last3_inc([10]) == [11]\nassert op_sortd_last3_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_last3_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_absval_pos_dropwhileneg", "entry_point": "op_absval_pos_dropwhileneg", "primitives": ["absval", "pos", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then drop the leading negative values.", "solution": "def op_absval_pos_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_pos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_pos_dropwhileneg([]) == []\nassert op_absval_pos_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_absval_pos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_pos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_absval_pos_dropwhileneg([10]) == [10]\nassert op_absval_pos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_absval_pos_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_oremptyzero_uniq_counteven", "entry_point": "op_oremptyzero_uniq_counteven", "primitives": ["oremptyzero", "uniq", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_oremptyzero_uniq_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_uniq_counteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_uniq_counteven([]) == 1\nassert op_oremptyzero_uniq_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_oremptyzero_uniq_counteven([5, 5, 5]) == 0\nassert op_oremptyzero_uniq_counteven([3, 1, 2]) == 1\nassert op_oremptyzero_uniq_counteven([10]) == 1\nassert op_oremptyzero_uniq_counteven([2, 4, 6]) == 3\nassert op_oremptyzero_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_sortabs_square", "entry_point": "op_first3_sortabs_square", "primitives": ["first3", "sortabs", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then square each.", "solution": "def op_first3_sortabs_square(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_first3_sortabs_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_sortabs_square([]) == []\nassert op_first3_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_first3_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_first3_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_first3_sortabs_square([10]) == [100]\nassert op_first3_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_first3_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dropfirst_dropzeros_trimends", "entry_point": "op_dropfirst_dropzeros_trimends", "primitives": ["dropfirst", "dropzeros", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then drop the first and last elements.", "solution": "def op_dropfirst_dropzeros_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_dropzeros_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_dropzeros_trimends([]) == []\nassert op_dropfirst_dropzeros_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_dropzeros_trimends([5, 5, 5]) == []\nassert op_dropfirst_dropzeros_trimends([3, 1, 2]) == []\nassert op_dropfirst_dropzeros_trimends([10]) == []\nassert op_dropfirst_dropzeros_trimends([2, 4, 6]) == []\nassert op_dropfirst_dropzeros_trimends([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dropzeros_max", "entry_point": "op_takewhilepos_dropzeros_max", "primitives": ["takewhilepos", "dropzeros", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_dropzeros_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_dropzeros_max([1, 2, 3, 4]) == 4\nassert op_takewhilepos_dropzeros_max([]) == 0\nassert op_takewhilepos_dropzeros_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropzeros_max([5, 5, 5]) == 5\nassert op_takewhilepos_dropzeros_max([3, 1, 2]) == 3\nassert op_takewhilepos_dropzeros_max([10]) == 10\nassert op_takewhilepos_dropzeros_max([2, 4, 6]) == 6\nassert op_takewhilepos_dropzeros_max([-7, 12, -7]) == 0"}
{"id": "op_first3_sortd_haszero", "entry_point": "op_first3_sortd_haszero", "primitives": ["first3", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then return whether the list contains a zero.", "solution": "def op_first3_sortd_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_first3_sortd_haszero([1, 2, 3, 4]) == False\nassert op_first3_sortd_haszero([]) == False\nassert op_first3_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_first3_sortd_haszero([5, 5, 5]) == False\nassert op_first3_sortd_haszero([3, 1, 2]) == False\nassert op_first3_sortd_haszero([10]) == False\nassert op_first3_sortd_haszero([2, 4, 6]) == False\nassert op_first3_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_square_inc_takewhilepos", "entry_point": "op_square_inc_takewhilepos", "primitives": ["square", "inc", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each, then take values while they are positive.", "solution": "def op_square_inc_takewhilepos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_square_inc_takewhilepos([1, 2, 3, 4]) == [2, 5, 10, 17]\nassert op_square_inc_takewhilepos([]) == []\nassert op_square_inc_takewhilepos([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_square_inc_takewhilepos([5, 5, 5]) == [26, 26, 26]\nassert op_square_inc_takewhilepos([3, 1, 2]) == [10, 2, 5]\nassert op_square_inc_takewhilepos([10]) == [101]\nassert op_square_inc_takewhilepos([2, 4, 6]) == [5, 17, 37]\nassert op_square_inc_takewhilepos([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_sorta_uniq_clamp10", "entry_point": "op_sorta_uniq_clamp10", "primitives": ["sorta", "uniq", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_sorta_uniq_clamp10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sorta_uniq_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_uniq_clamp10([]) == []\nassert op_sorta_uniq_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_uniq_clamp10([5, 5, 5]) == [5]\nassert op_sorta_uniq_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_uniq_clamp10([10]) == [10]\nassert op_sorta_uniq_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_uniq_clamp10([-7, 12, -7]) == [-7, 10]"}
{"id": "op_odds_pos_gt5", "entry_point": "op_odds_pos_gt5", "primitives": ["odds", "pos", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then keep values greater than five.", "solution": "def op_odds_pos_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_pos_gt5([1, 2, 3, 4]) == []\nassert op_odds_pos_gt5([]) == []\nassert op_odds_pos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_pos_gt5([5, 5, 5]) == []\nassert op_odds_pos_gt5([3, 1, 2]) == []\nassert op_odds_pos_gt5([10]) == []\nassert op_odds_pos_gt5([2, 4, 6]) == []\nassert op_odds_pos_gt5([-7, 12, -7]) == []"}
{"id": "op_padto3_takewhilepos_prod", "entry_point": "op_padto3_takewhilepos_prod", "primitives": ["padto3", "takewhilepos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then return their product.", "solution": "def op_padto3_takewhilepos_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_padto3_takewhilepos_prod([1, 2, 3, 4]) == 24\nassert op_padto3_takewhilepos_prod([]) == 1\nassert op_padto3_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_padto3_takewhilepos_prod([5, 5, 5]) == 125\nassert op_padto3_takewhilepos_prod([3, 1, 2]) == 6\nassert op_padto3_takewhilepos_prod([10]) == 10\nassert op_padto3_takewhilepos_prod([2, 4, 6]) == 48\nassert op_padto3_takewhilepos_prod([-7, 12, -7]) == 1"}
{"id": "op_double_beforezero_issorted", "entry_point": "op_double_beforezero_issorted", "primitives": ["double", "beforezero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero, then return whether the list is sorted ascending.", "solution": "def op_double_beforezero_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r == sorted(r)", "tests": "assert op_double_beforezero_issorted([1, 2, 3, 4]) == True\nassert op_double_beforezero_issorted([]) == True\nassert op_double_beforezero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_beforezero_issorted([5, 5, 5]) == True\nassert op_double_beforezero_issorted([3, 1, 2]) == False\nassert op_double_beforezero_issorted([10]) == True\nassert op_double_beforezero_issorted([2, 4, 6]) == True\nassert op_double_beforezero_issorted([-7, 12, -7]) == False"}
{"id": "op_clamp10_dropzeros_square", "entry_point": "op_clamp10_dropzeros_square", "primitives": ["clamp10", "dropzeros", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then square each.", "solution": "def op_clamp10_dropzeros_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_dropzeros_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_dropzeros_square([]) == []\nassert op_clamp10_dropzeros_square([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_clamp10_dropzeros_square([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_dropzeros_square([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_dropzeros_square([10]) == [100]\nassert op_clamp10_dropzeros_square([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_dropzeros_square([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_dropzeros_dropwhileneg_haszero", "entry_point": "op_dropzeros_dropwhileneg_haszero", "primitives": ["dropzeros", "dropwhileneg", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_dropzeros_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_dropzeros_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_dropwhileneg_haszero([]) == False\nassert op_dropzeros_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_dropzeros_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_dropzeros_dropwhileneg_haszero([10]) == False\nassert op_dropzeros_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_dropzeros_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_first3_counteven", "entry_point": "op_trimends_first3_counteven", "primitives": ["trimends", "first3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then return how many values are even.", "solution": "def op_trimends_first3_counteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_trimends_first3_counteven([1, 2, 3, 4]) == 1\nassert op_trimends_first3_counteven([]) == 0\nassert op_trimends_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_first3_counteven([5, 5, 5]) == 0\nassert op_trimends_first3_counteven([3, 1, 2]) == 0\nassert op_trimends_first3_counteven([10]) == 0\nassert op_trimends_first3_counteven([2, 4, 6]) == 1\nassert op_trimends_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_inc_dropwhileneg_last3", "entry_point": "op_inc_dropwhileneg_last3", "primitives": ["inc", "dropwhileneg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the leading negative values, then keep only the last three.", "solution": "def op_inc_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_dropwhileneg_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_dropwhileneg_last3([]) == []\nassert op_inc_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_dropwhileneg_last3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropwhileneg_last3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_dropwhileneg_last3([10]) == [11]\nassert op_inc_dropwhileneg_last3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropwhileneg_last3([-7, 12, -7]) == [13, -6]"}
{"id": "op_trimends_absval_pos", "entry_point": "op_trimends_absval_pos", "primitives": ["trimends", "absval", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then keep the positive numbers.", "solution": "def op_trimends_absval_pos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_trimends_absval_pos([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_absval_pos([]) == []\nassert op_trimends_absval_pos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_trimends_absval_pos([5, 5, 5]) == [5]\nassert op_trimends_absval_pos([3, 1, 2]) == [1]\nassert op_trimends_absval_pos([10]) == []\nassert op_trimends_absval_pos([2, 4, 6]) == [4]\nassert op_trimends_absval_pos([-7, 12, -7]) == [12]"}
{"id": "op_prefixup_firstchar_dropshort", "entry_point": "op_prefixup_firstchar_dropshort", "primitives": ["prefixup", "firstchar", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then keep the first character of each (dropping empties), then drop strings shorter than three characters.", "solution": "def op_prefixup_firstchar_dropshort(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s[0] for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_prefixup_firstchar_dropshort(['Hello', 'world']) == []\nassert op_prefixup_firstchar_dropshort([]) == []\nassert op_prefixup_firstchar_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_prefixup_firstchar_dropshort(['one', 'one', 'Two']) == []\nassert op_prefixup_firstchar_dropshort(['x']) == []\nassert op_prefixup_firstchar_dropshort(['abc', 'de', '']) == []"}
{"id": "op_gt5_oremptyzero_inc", "entry_point": "op_gt5_oremptyzero_inc", "primitives": ["gt5", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then add one to each.", "solution": "def op_gt5_oremptyzero_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_gt5_oremptyzero_inc([1, 2, 3, 4]) == [1]\nassert op_gt5_oremptyzero_inc([]) == [1]\nassert op_gt5_oremptyzero_inc([-2, -1, 0, 1, 2]) == [1]\nassert op_gt5_oremptyzero_inc([5, 5, 5]) == [1]\nassert op_gt5_oremptyzero_inc([3, 1, 2]) == [1]\nassert op_gt5_oremptyzero_inc([10]) == [11]\nassert op_gt5_oremptyzero_inc([2, 4, 6]) == [7]\nassert op_gt5_oremptyzero_inc([-7, 12, -7]) == [13]"}
{"id": "op_pos_neg_anyeven", "entry_point": "op_pos_neg_anyeven", "primitives": ["pos", "neg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the negative numbers, then return whether any value is even.", "solution": "def op_pos_neg_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_neg_anyeven([1, 2, 3, 4]) == False\nassert op_pos_neg_anyeven([]) == False\nassert op_pos_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_pos_neg_anyeven([5, 5, 5]) == False\nassert op_pos_neg_anyeven([3, 1, 2]) == False\nassert op_pos_neg_anyeven([10]) == False\nassert op_pos_neg_anyeven([2, 4, 6]) == False\nassert op_pos_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_lower_dropshort_firstchar", "entry_point": "op_lower_dropshort_firstchar", "primitives": ["lower", "dropshort", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop strings shorter than three characters, then keep the first character of each (dropping empties).", "solution": "def op_lower_dropshort_firstchar(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_lower_dropshort_firstchar(['Hello', 'world']) == ['h', 'w']\nassert op_lower_dropshort_firstchar([]) == []\nassert op_lower_dropshort_firstchar(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_lower_dropshort_firstchar(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_lower_dropshort_firstchar(['x']) == []\nassert op_lower_dropshort_firstchar(['abc', 'de', '']) == ['a']"}
{"id": "op_rev_square_div3", "entry_point": "op_rev_square_div3", "primitives": ["rev", "square", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then keep multiples of three.", "solution": "def op_rev_square_div3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_rev_square_div3([1, 2, 3, 4]) == [9]\nassert op_rev_square_div3([]) == []\nassert op_rev_square_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_rev_square_div3([5, 5, 5]) == []\nassert op_rev_square_div3([3, 1, 2]) == [9]\nassert op_rev_square_div3([10]) == []\nassert op_rev_square_div3([2, 4, 6]) == [36]\nassert op_rev_square_div3([-7, 12, -7]) == [144]"}
{"id": "op_padto3_uniq_len", "entry_point": "op_padto3_uniq_len", "primitives": ["padto3", "uniq", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_padto3_uniq_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_padto3_uniq_len([1, 2, 3, 4]) == 4\nassert op_padto3_uniq_len([]) == 1\nassert op_padto3_uniq_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_uniq_len([5, 5, 5]) == 1\nassert op_padto3_uniq_len([3, 1, 2]) == 3\nassert op_padto3_uniq_len([10]) == 2\nassert op_padto3_uniq_len([2, 4, 6]) == 3\nassert op_padto3_uniq_len([-7, 12, -7]) == 2"}
{"id": "op_pos_add10_sorta", "entry_point": "op_pos_add10_sorta", "primitives": ["pos", "add10", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add ten to each, then sort ascending.", "solution": "def op_pos_add10_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_pos_add10_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_add10_sorta([]) == []\nassert op_pos_add10_sorta([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_add10_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_pos_add10_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_pos_add10_sorta([10]) == [20]\nassert op_pos_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_pos_add10_sorta([-7, 12, -7]) == [22]"}
{"id": "op_dropwhileneg_takewhilepos_alldistinct", "entry_point": "op_dropwhileneg_takewhilepos_alldistinct", "primitives": ["dropwhileneg", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_dropwhileneg_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([10]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_uniq_clamp10_issorted", "entry_point": "op_uniq_clamp10_issorted", "primitives": ["uniq", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_uniq_clamp10_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_uniq_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_uniq_clamp10_issorted([]) == True\nassert op_uniq_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_clamp10_issorted([5, 5, 5]) == True\nassert op_uniq_clamp10_issorted([3, 1, 2]) == False\nassert op_uniq_clamp10_issorted([10]) == True\nassert op_uniq_clamp10_issorted([2, 4, 6]) == True\nassert op_uniq_clamp10_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_trimends_sortabs", "entry_point": "op_sorta_trimends_sortabs", "primitives": ["sorta", "trimends", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first and last elements, then sort by absolute value.", "solution": "def op_sorta_trimends_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_trimends_sortabs([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_trimends_sortabs([]) == []\nassert op_sorta_trimends_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_sorta_trimends_sortabs([5, 5, 5]) == [5]\nassert op_sorta_trimends_sortabs([3, 1, 2]) == [2]\nassert op_sorta_trimends_sortabs([10]) == []\nassert op_sorta_trimends_sortabs([2, 4, 6]) == [4]\nassert op_sorta_trimends_sortabs([-7, 12, -7]) == [-7]"}
{"id": "op_dropshort_upper_lower", "entry_point": "op_dropshort_upper_lower", "primitives": ["dropshort", "upper", "lower"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string, then lowercase each string.", "solution": "def op_dropshort_upper_lower(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_dropshort_upper_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_dropshort_upper_lower([]) == []\nassert op_dropshort_upper_lower(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_dropshort_upper_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_dropshort_upper_lower(['x']) == []\nassert op_dropshort_upper_lower(['abc', 'de', '']) == ['abc']"}
{"id": "op_inc_uniq_evens", "entry_point": "op_inc_uniq_evens", "primitives": ["inc", "uniq", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_inc_uniq_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_uniq_evens([1, 2, 3, 4]) == [2, 4]\nassert op_inc_uniq_evens([]) == []\nassert op_inc_uniq_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_inc_uniq_evens([5, 5, 5]) == [6]\nassert op_inc_uniq_evens([3, 1, 2]) == [4, 2]\nassert op_inc_uniq_evens([10]) == []\nassert op_inc_uniq_evens([2, 4, 6]) == []\nassert op_inc_uniq_evens([-7, 12, -7]) == [-6]"}
{"id": "op_first3_square_haszero", "entry_point": "op_first3_square_haszero", "primitives": ["first3", "square", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each, then return whether the list contains a zero.", "solution": "def op_first3_square_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_first3_square_haszero([1, 2, 3, 4]) == False\nassert op_first3_square_haszero([]) == False\nassert op_first3_square_haszero([-2, -1, 0, 1, 2]) == True\nassert op_first3_square_haszero([5, 5, 5]) == False\nassert op_first3_square_haszero([3, 1, 2]) == False\nassert op_first3_square_haszero([10]) == False\nassert op_first3_square_haszero([2, 4, 6]) == False\nassert op_first3_square_haszero([-7, 12, -7]) == False"}
{"id": "op_first3_dropwhileneg_last3", "entry_point": "op_first3_dropwhileneg_last3", "primitives": ["first3", "dropwhileneg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values, then keep only the last three.", "solution": "def op_first3_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_dropwhileneg_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_dropwhileneg_last3([]) == []\nassert op_first3_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropwhileneg_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_dropwhileneg_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_dropwhileneg_last3([10]) == [10]\nassert op_first3_dropwhileneg_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_dropwhileneg_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_double_dropwhileneg_sum", "entry_point": "op_double_dropwhileneg_sum", "primitives": ["double", "dropwhileneg", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then return their sum.", "solution": "def op_double_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_double_dropwhileneg_sum([1, 2, 3, 4]) == 20\nassert op_double_dropwhileneg_sum([]) == 0\nassert op_double_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 6\nassert op_double_dropwhileneg_sum([5, 5, 5]) == 30\nassert op_double_dropwhileneg_sum([3, 1, 2]) == 12\nassert op_double_dropwhileneg_sum([10]) == 20\nassert op_double_dropwhileneg_sum([2, 4, 6]) == 24\nassert op_double_dropwhileneg_sum([-7, 12, -7]) == 10"}
{"id": "op_div3_oremptyzero_max", "entry_point": "op_div3_oremptyzero_max", "primitives": ["div3", "oremptyzero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_div3_oremptyzero_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_div3_oremptyzero_max([1, 2, 3, 4]) == 3\nassert op_div3_oremptyzero_max([]) == 0\nassert op_div3_oremptyzero_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_oremptyzero_max([5, 5, 5]) == 0\nassert op_div3_oremptyzero_max([3, 1, 2]) == 3\nassert op_div3_oremptyzero_max([10]) == 0\nassert op_div3_oremptyzero_max([2, 4, 6]) == 6\nassert op_div3_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_beforezero_absval_sum", "entry_point": "op_beforezero_absval_sum", "primitives": ["beforezero", "absval", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then return their sum.", "solution": "def op_beforezero_absval_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_beforezero_absval_sum([1, 2, 3, 4]) == 10\nassert op_beforezero_absval_sum([]) == 0\nassert op_beforezero_absval_sum([-2, -1, 0, 1, 2]) == 3\nassert op_beforezero_absval_sum([5, 5, 5]) == 15\nassert op_beforezero_absval_sum([3, 1, 2]) == 6\nassert op_beforezero_absval_sum([10]) == 10\nassert op_beforezero_absval_sum([2, 4, 6]) == 12\nassert op_beforezero_absval_sum([-7, 12, -7]) == 26"}
{"id": "op_add10_sortabs_clamp10", "entry_point": "op_add10_sortabs_clamp10", "primitives": ["add10", "sortabs", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then cap each value at 10.", "solution": "def op_add10_sortabs_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_sortabs_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_sortabs_clamp10([]) == []\nassert op_add10_sortabs_clamp10([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_sortabs_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_add10_sortabs_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_add10_sortabs_clamp10([10]) == [10]\nassert op_add10_sortabs_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_add10_sortabs_clamp10([-7, 12, -7]) == [3, 3, 10]"}
{"id": "op_oremptyzero_clamp10_max", "entry_point": "op_oremptyzero_clamp10_max", "primitives": ["oremptyzero", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_oremptyzero_clamp10_max(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_oremptyzero_clamp10_max([1, 2, 3, 4]) == 4\nassert op_oremptyzero_clamp10_max([]) == 0\nassert op_oremptyzero_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_clamp10_max([5, 5, 5]) == 5\nassert op_oremptyzero_clamp10_max([3, 1, 2]) == 3\nassert op_oremptyzero_clamp10_max([10]) == 10\nassert op_oremptyzero_clamp10_max([2, 4, 6]) == 6\nassert op_oremptyzero_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_dropwhileneg_takewhilepos_square", "entry_point": "op_dropwhileneg_takewhilepos_square", "primitives": ["dropwhileneg", "takewhilepos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive, then square each.", "solution": "def op_dropwhileneg_takewhilepos_square(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropwhileneg_takewhilepos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropwhileneg_takewhilepos_square([]) == []\nassert op_dropwhileneg_takewhilepos_square([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_takewhilepos_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_takewhilepos_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_takewhilepos_square([10]) == [100]\nassert op_dropwhileneg_takewhilepos_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_takewhilepos_square([-7, 12, -7]) == [144]"}
{"id": "op_add10_last3_prod", "entry_point": "op_add10_last3_prod", "primitives": ["add10", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return their product.", "solution": "def op_add10_last3_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_add10_last3_prod([1, 2, 3, 4]) == 2184\nassert op_add10_last3_prod([]) == 1\nassert op_add10_last3_prod([-2, -1, 0, 1, 2]) == 1320\nassert op_add10_last3_prod([5, 5, 5]) == 3375\nassert op_add10_last3_prod([3, 1, 2]) == 1716\nassert op_add10_last3_prod([10]) == 20\nassert op_add10_last3_prod([2, 4, 6]) == 2688\nassert op_add10_last3_prod([-7, 12, -7]) == 198"}
{"id": "op_dec_square_issorted", "entry_point": "op_dec_square_issorted", "primitives": ["dec", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then return whether the list is sorted ascending.", "solution": "def op_dec_square_issorted(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_dec_square_issorted([1, 2, 3, 4]) == True\nassert op_dec_square_issorted([]) == True\nassert op_dec_square_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dec_square_issorted([5, 5, 5]) == True\nassert op_dec_square_issorted([3, 1, 2]) == False\nassert op_dec_square_issorted([10]) == True\nassert op_dec_square_issorted([2, 4, 6]) == True\nassert op_dec_square_issorted([-7, 12, -7]) == False"}
{"id": "op_padto3_takewhilepos_dropfirst", "entry_point": "op_padto3_takewhilepos_dropfirst", "primitives": ["padto3", "takewhilepos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then drop the first element.", "solution": "def op_padto3_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_padto3_takewhilepos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_takewhilepos_dropfirst([]) == []\nassert op_padto3_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_takewhilepos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_padto3_takewhilepos_dropfirst([10]) == []\nassert op_padto3_takewhilepos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_takewhilepos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_double_inc_sum", "entry_point": "op_double_inc_sum", "primitives": ["double", "inc", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each, then return their sum.", "solution": "def op_double_inc_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_double_inc_sum([1, 2, 3, 4]) == 24\nassert op_double_inc_sum([]) == 0\nassert op_double_inc_sum([-2, -1, 0, 1, 2]) == 5\nassert op_double_inc_sum([5, 5, 5]) == 33\nassert op_double_inc_sum([3, 1, 2]) == 15\nassert op_double_inc_sum([10]) == 21\nassert op_double_inc_sum([2, 4, 6]) == 27\nassert op_double_inc_sum([-7, 12, -7]) == -1"}
{"id": "op_trimends_dropwhileneg_square", "entry_point": "op_trimends_dropwhileneg_square", "primitives": ["trimends", "dropwhileneg", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values, then square each.", "solution": "def op_trimends_dropwhileneg_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_dropwhileneg_square([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_dropwhileneg_square([]) == []\nassert op_trimends_dropwhileneg_square([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_dropwhileneg_square([5, 5, 5]) == [25]\nassert op_trimends_dropwhileneg_square([3, 1, 2]) == [1]\nassert op_trimends_dropwhileneg_square([10]) == []\nassert op_trimends_dropwhileneg_square([2, 4, 6]) == [16]\nassert op_trimends_dropwhileneg_square([-7, 12, -7]) == [144]"}
{"id": "op_dropwhileneg_neg_anyeven", "entry_point": "op_dropwhileneg_neg_anyeven", "primitives": ["dropwhileneg", "neg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then return whether any value is even.", "solution": "def op_dropwhileneg_neg_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_neg_anyeven([1, 2, 3, 4]) == False\nassert op_dropwhileneg_neg_anyeven([]) == False\nassert op_dropwhileneg_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_neg_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_neg_anyeven([3, 1, 2]) == False\nassert op_dropwhileneg_neg_anyeven([10]) == False\nassert op_dropwhileneg_neg_anyeven([2, 4, 6]) == False\nassert op_dropwhileneg_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_trimends_dropzeros_allpos", "entry_point": "op_trimends_dropzeros_allpos", "primitives": ["trimends", "dropzeros", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then return whether all values are positive.", "solution": "def op_trimends_dropzeros_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_trimends_dropzeros_allpos([]) == True\nassert op_trimends_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_dropzeros_allpos([5, 5, 5]) == True\nassert op_trimends_dropzeros_allpos([3, 1, 2]) == True\nassert op_trimends_dropzeros_allpos([10]) == True\nassert op_trimends_dropzeros_allpos([2, 4, 6]) == True\nassert op_trimends_dropzeros_allpos([-7, 12, -7]) == True"}
{"id": "op_square_double_allpos", "entry_point": "op_square_double_allpos", "primitives": ["square", "double", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then return whether all values are positive.", "solution": "def op_square_double_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_square_double_allpos([1, 2, 3, 4]) == True\nassert op_square_double_allpos([]) == True\nassert op_square_double_allpos([-2, -1, 0, 1, 2]) == False\nassert op_square_double_allpos([5, 5, 5]) == True\nassert op_square_double_allpos([3, 1, 2]) == True\nassert op_square_double_allpos([10]) == True\nassert op_square_double_allpos([2, 4, 6]) == True\nassert op_square_double_allpos([-7, 12, -7]) == True"}
{"id": "op_padto3_odds_len", "entry_point": "op_padto3_odds_len", "primitives": ["padto3", "odds", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then return how many remain.", "solution": "def op_padto3_odds_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_padto3_odds_len([1, 2, 3, 4]) == 2\nassert op_padto3_odds_len([]) == 0\nassert op_padto3_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_odds_len([5, 5, 5]) == 3\nassert op_padto3_odds_len([3, 1, 2]) == 2\nassert op_padto3_odds_len([10]) == 0\nassert op_padto3_odds_len([2, 4, 6]) == 0\nassert op_padto3_odds_len([-7, 12, -7]) == 2"}
{"id": "op_oremptyzero_double_beforezero", "entry_point": "op_oremptyzero_double_beforezero", "primitives": ["oremptyzero", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then keep everything before the first zero.", "solution": "def op_oremptyzero_double_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_oremptyzero_double_beforezero([]) == []\nassert op_oremptyzero_double_beforezero([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_oremptyzero_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_oremptyzero_double_beforezero([10]) == [20]\nassert op_oremptyzero_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_oremptyzero_double_beforezero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_ages_neg_beforezero", "entry_point": "op_ages_neg_beforezero", "primitives": ["ages", "neg", "beforezero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then keep everything before the first zero.", "solution": "def op_ages_neg_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_neg_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg_beforezero([]) == []\nassert op_ages_neg_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg_beforezero([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_evens_last3_dropfirst", "entry_point": "op_evens_last3_dropfirst", "primitives": ["evens", "last3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then drop the first element.", "solution": "def op_evens_last3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = r[1:]\n    return r", "tests": "assert op_evens_last3_dropfirst([1, 2, 3, 4]) == [4]\nassert op_evens_last3_dropfirst([]) == []\nassert op_evens_last3_dropfirst([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_last3_dropfirst([5, 5, 5]) == []\nassert op_evens_last3_dropfirst([3, 1, 2]) == []\nassert op_evens_last3_dropfirst([10]) == []\nassert op_evens_last3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_evens_last3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sorta_uniq_padto3", "entry_point": "op_sorta_uniq_padto3", "primitives": ["sorta", "uniq", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_sorta_uniq_padto3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sorta_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_uniq_padto3([]) == [0, 0, 0]\nassert op_sorta_uniq_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sorta_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_sorta_uniq_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_uniq_padto3([10]) == [10, 0, 0]\nassert op_sorta_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_uniq_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_inc_rev_haszero", "entry_point": "op_inc_rev_haszero", "primitives": ["inc", "rev", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then return whether the list contains a zero.", "solution": "def op_inc_rev_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return 0 in r", "tests": "assert op_inc_rev_haszero([1, 2, 3, 4]) == False\nassert op_inc_rev_haszero([]) == False\nassert op_inc_rev_haszero([-2, -1, 0, 1, 2]) == True\nassert op_inc_rev_haszero([5, 5, 5]) == False\nassert op_inc_rev_haszero([3, 1, 2]) == False\nassert op_inc_rev_haszero([10]) == False\nassert op_inc_rev_haszero([2, 4, 6]) == False\nassert op_inc_rev_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_padto3_dropwhileneg", "entry_point": "op_trimends_padto3_dropwhileneg", "primitives": ["trimends", "padto3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_trimends_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_padto3_dropwhileneg([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_trimends_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_padto3_dropwhileneg([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_padto3_dropwhileneg([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_padto3_dropwhileneg([10]) == [0, 0, 0]\nassert op_trimends_padto3_dropwhileneg([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_padto3_dropwhileneg([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_inc_dropfirst_max", "entry_point": "op_inc_dropfirst_max", "primitives": ["inc", "dropfirst", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_inc_dropfirst_max(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_inc_dropfirst_max([1, 2, 3, 4]) == 5\nassert op_inc_dropfirst_max([]) == 0\nassert op_inc_dropfirst_max([-2, -1, 0, 1, 2]) == 3\nassert op_inc_dropfirst_max([5, 5, 5]) == 6\nassert op_inc_dropfirst_max([3, 1, 2]) == 3\nassert op_inc_dropfirst_max([10]) == 0\nassert op_inc_dropfirst_max([2, 4, 6]) == 7\nassert op_inc_dropfirst_max([-7, 12, -7]) == 13"}
{"id": "op_rev_takewhilepos_clamp10", "entry_point": "op_rev_takewhilepos_clamp10", "primitives": ["rev", "takewhilepos", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take values while they are positive, then cap each value at 10.", "solution": "def op_rev_takewhilepos_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_takewhilepos_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_takewhilepos_clamp10([]) == []\nassert op_rev_takewhilepos_clamp10([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_takewhilepos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_rev_takewhilepos_clamp10([3, 1, 2]) == [2, 1, 3]\nassert op_rev_takewhilepos_clamp10([10]) == [10]\nassert op_rev_takewhilepos_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_rev_takewhilepos_clamp10([-7, 12, -7]) == []"}
{"id": "op_dropzeros_gt5_pos", "entry_point": "op_dropzeros_gt5_pos", "primitives": ["dropzeros", "gt5", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five, then keep the positive numbers.", "solution": "def op_dropzeros_gt5_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropzeros_gt5_pos([1, 2, 3, 4]) == []\nassert op_dropzeros_gt5_pos([]) == []\nassert op_dropzeros_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_gt5_pos([5, 5, 5]) == []\nassert op_dropzeros_gt5_pos([3, 1, 2]) == []\nassert op_dropzeros_gt5_pos([10]) == [10]\nassert op_dropzeros_gt5_pos([2, 4, 6]) == [6]\nassert op_dropzeros_gt5_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_dec_clamp10", "entry_point": "op_dropzeros_dec_clamp10", "primitives": ["dropzeros", "dec", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then subtract one from each, then cap each value at 10.", "solution": "def op_dropzeros_dec_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_dec_clamp10([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dropzeros_dec_clamp10([]) == []\nassert op_dropzeros_dec_clamp10([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_dropzeros_dec_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dropzeros_dec_clamp10([3, 1, 2]) == [2, 0, 1]\nassert op_dropzeros_dec_clamp10([10]) == [9]\nassert op_dropzeros_dec_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dropzeros_dec_clamp10([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_last3_odds_first3", "entry_point": "op_last3_odds_first3", "primitives": ["last3", "odds", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then keep only the first three.", "solution": "def op_last3_odds_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    return r", "tests": "assert op_last3_odds_first3([1, 2, 3, 4]) == [3]\nassert op_last3_odds_first3([]) == []\nassert op_last3_odds_first3([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_odds_first3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_odds_first3([3, 1, 2]) == [3, 1]\nassert op_last3_odds_first3([10]) == []\nassert op_last3_odds_first3([2, 4, 6]) == []\nassert op_last3_odds_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_evens_inc", "entry_point": "op_uniq_evens_inc", "primitives": ["uniq", "evens", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then add one to each.", "solution": "def op_uniq_evens_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_evens_inc([1, 2, 3, 4]) == [3, 5]\nassert op_uniq_evens_inc([]) == []\nassert op_uniq_evens_inc([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_uniq_evens_inc([5, 5, 5]) == []\nassert op_uniq_evens_inc([3, 1, 2]) == [3]\nassert op_uniq_evens_inc([10]) == [11]\nassert op_uniq_evens_inc([2, 4, 6]) == [3, 5, 7]\nassert op_uniq_evens_inc([-7, 12, -7]) == [13]"}
{"id": "op_sorta_clamp10_beforezero", "entry_point": "op_sorta_clamp10_beforezero", "primitives": ["sorta", "clamp10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then keep everything before the first zero.", "solution": "def op_sorta_clamp10_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_clamp10_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10_beforezero([]) == []\nassert op_sorta_clamp10_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_clamp10_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_beforezero([10]) == [10]\nassert op_sorta_clamp10_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_beforezero([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_padto3_neg_counteven", "entry_point": "op_padto3_neg_counteven", "primitives": ["padto3", "neg", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then return how many values are even.", "solution": "def op_padto3_neg_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_neg_counteven([1, 2, 3, 4]) == 0\nassert op_padto3_neg_counteven([]) == 0\nassert op_padto3_neg_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_padto3_neg_counteven([5, 5, 5]) == 0\nassert op_padto3_neg_counteven([3, 1, 2]) == 0\nassert op_padto3_neg_counteven([10]) == 0\nassert op_padto3_neg_counteven([2, 4, 6]) == 0\nassert op_padto3_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_div3_sortabs_dec", "entry_point": "op_div3_sortabs_dec", "primitives": ["div3", "sortabs", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value, then subtract one from each.", "solution": "def op_div3_sortabs_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_sortabs_dec([1, 2, 3, 4]) == [2]\nassert op_div3_sortabs_dec([]) == []\nassert op_div3_sortabs_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_sortabs_dec([5, 5, 5]) == []\nassert op_div3_sortabs_dec([3, 1, 2]) == [2]\nassert op_div3_sortabs_dec([10]) == []\nassert op_div3_sortabs_dec([2, 4, 6]) == [5]\nassert op_div3_sortabs_dec([-7, 12, -7]) == [11]"}
{"id": "op_uniq_inc_last3", "entry_point": "op_uniq_inc_last3", "primitives": ["uniq", "inc", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then keep only the last three.", "solution": "def op_uniq_inc_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_inc_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_uniq_inc_last3([]) == []\nassert op_uniq_inc_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_uniq_inc_last3([5, 5, 5]) == [6]\nassert op_uniq_inc_last3([3, 1, 2]) == [4, 2, 3]\nassert op_uniq_inc_last3([10]) == [11]\nassert op_uniq_inc_last3([2, 4, 6]) == [3, 5, 7]\nassert op_uniq_inc_last3([-7, 12, -7]) == [-6, 13]"}
{"id": "op_double_add10_dropfirst", "entry_point": "op_double_add10_dropfirst", "primitives": ["double", "add10", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then drop the first element.", "solution": "def op_double_add10_dropfirst(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_double_add10_dropfirst([1, 2, 3, 4]) == [14, 16, 18]\nassert op_double_add10_dropfirst([]) == []\nassert op_double_add10_dropfirst([-2, -1, 0, 1, 2]) == [8, 10, 12, 14]\nassert op_double_add10_dropfirst([5, 5, 5]) == [20, 20]\nassert op_double_add10_dropfirst([3, 1, 2]) == [12, 14]\nassert op_double_add10_dropfirst([10]) == []\nassert op_double_add10_dropfirst([2, 4, 6]) == [18, 22]\nassert op_double_add10_dropfirst([-7, 12, -7]) == [34, -4]"}
{"id": "op_ages_dropfirst_oremptyzero", "entry_point": "op_ages_dropfirst_oremptyzero", "primitives": ["ages", "dropfirst", "oremptyzero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then if empty, use a single zero.", "solution": "def op_ages_dropfirst_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_dropfirst_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_dropfirst_oremptyzero([]) == [0]\nassert op_ages_dropfirst_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_dropfirst_oremptyzero([{'name': 'Fi', 'age': 41}]) == [0]"}
{"id": "op_uniq_odds_dec", "entry_point": "op_uniq_odds_dec", "primitives": ["uniq", "odds", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then subtract one from each.", "solution": "def op_uniq_odds_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_odds_dec([1, 2, 3, 4]) == [0, 2]\nassert op_uniq_odds_dec([]) == []\nassert op_uniq_odds_dec([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_uniq_odds_dec([5, 5, 5]) == [4]\nassert op_uniq_odds_dec([3, 1, 2]) == [2, 0]\nassert op_uniq_odds_dec([10]) == []\nassert op_uniq_odds_dec([2, 4, 6]) == []\nassert op_uniq_odds_dec([-7, 12, -7]) == [-8]"}
{"id": "op_gt5_dropzeros_add10", "entry_point": "op_gt5_dropzeros_add10", "primitives": ["gt5", "dropzeros", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros, then add ten to each.", "solution": "def op_gt5_dropzeros_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_gt5_dropzeros_add10([1, 2, 3, 4]) == []\nassert op_gt5_dropzeros_add10([]) == []\nassert op_gt5_dropzeros_add10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropzeros_add10([5, 5, 5]) == []\nassert op_gt5_dropzeros_add10([3, 1, 2]) == []\nassert op_gt5_dropzeros_add10([10]) == [20]\nassert op_gt5_dropzeros_add10([2, 4, 6]) == [16]\nassert op_gt5_dropzeros_add10([-7, 12, -7]) == [22]"}
{"id": "op_last3_absval_gt5", "entry_point": "op_last3_absval_gt5", "primitives": ["last3", "absval", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then keep values greater than five.", "solution": "def op_last3_absval_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_absval_gt5([1, 2, 3, 4]) == []\nassert op_last3_absval_gt5([]) == []\nassert op_last3_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_absval_gt5([5, 5, 5]) == []\nassert op_last3_absval_gt5([3, 1, 2]) == []\nassert op_last3_absval_gt5([10]) == [10]\nassert op_last3_absval_gt5([2, 4, 6]) == [6]\nassert op_last3_absval_gt5([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sortabs_absval_allpos", "entry_point": "op_sortabs_absval_allpos", "primitives": ["sortabs", "absval", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_sortabs_absval_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_absval_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_absval_allpos([]) == True\nassert op_sortabs_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_absval_allpos([5, 5, 5]) == True\nassert op_sortabs_absval_allpos([3, 1, 2]) == True\nassert op_sortabs_absval_allpos([10]) == True\nassert op_sortabs_absval_allpos([2, 4, 6]) == True\nassert op_sortabs_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_neg_sorta_double", "entry_point": "op_neg_sorta_double", "primitives": ["neg", "sorta", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then double each.", "solution": "def op_neg_sorta_double(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_neg_sorta_double([1, 2, 3, 4]) == []\nassert op_neg_sorta_double([]) == []\nassert op_neg_sorta_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_neg_sorta_double([5, 5, 5]) == []\nassert op_neg_sorta_double([3, 1, 2]) == []\nassert op_neg_sorta_double([10]) == []\nassert op_neg_sorta_double([2, 4, 6]) == []\nassert op_neg_sorta_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_last3_padto3_rev", "entry_point": "op_last3_padto3_rev", "primitives": ["last3", "padto3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_last3_padto3_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_padto3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_padto3_rev([]) == [0, 0, 0]\nassert op_last3_padto3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_padto3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_padto3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_padto3_rev([10]) == [0, 0, 10]\nassert op_last3_padto3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_padto3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dec_sorta_clamp10", "entry_point": "op_dec_sorta_clamp10", "primitives": ["dec", "sorta", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then cap each value at 10.", "solution": "def op_dec_sorta_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_sorta_clamp10([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sorta_clamp10([]) == []\nassert op_dec_sorta_clamp10([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_dec_sorta_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sorta_clamp10([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sorta_clamp10([10]) == [9]\nassert op_dec_sorta_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sorta_clamp10([-7, 12, -7]) == [-8, -8, 10]"}
{"id": "op_absval_takewhilepos_padto3", "entry_point": "op_absval_takewhilepos_padto3", "primitives": ["absval", "takewhilepos", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_absval_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_takewhilepos_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_absval_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_takewhilepos_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_absval_takewhilepos_padto3([10]) == [10, 0, 0]\nassert op_absval_takewhilepos_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_padto3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_uniqs_upper_prefixup", "entry_point": "op_uniqs_upper_prefixup", "primitives": ["uniqs", "upper", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then uppercase each string, then prefix each with a hash.", "solution": "def op_uniqs_upper_prefixup(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.upper() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_uniqs_upper_prefixup(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_uniqs_upper_prefixup([]) == []\nassert op_uniqs_upper_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ', '#', '#BC', '#BC']\nassert op_uniqs_upper_prefixup(['one', 'one', 'Two']) == ['#ONE', '#TWO']\nassert op_uniqs_upper_prefixup(['x']) == ['#X']\nassert op_uniqs_upper_prefixup(['abc', 'de', '']) == ['#ABC', '#DE', '#']"}
{"id": "op_sortabs_uniq_last3", "entry_point": "op_sortabs_uniq_last3", "primitives": ["sortabs", "uniq", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence, then keep only the last three.", "solution": "def op_sortabs_uniq_last3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r", "tests": "assert op_sortabs_uniq_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_uniq_last3([]) == []\nassert op_sortabs_uniq_last3([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_sortabs_uniq_last3([5, 5, 5]) == [5]\nassert op_sortabs_uniq_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_uniq_last3([10]) == [10]\nassert op_sortabs_uniq_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_uniq_last3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_double_dec_gt5", "entry_point": "op_double_dec_gt5", "primitives": ["double", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then keep values greater than five.", "solution": "def op_double_dec_gt5(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_double_dec_gt5([1, 2, 3, 4]) == [7]\nassert op_double_dec_gt5([]) == []\nassert op_double_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_double_dec_gt5([5, 5, 5]) == [9, 9, 9]\nassert op_double_dec_gt5([3, 1, 2]) == []\nassert op_double_dec_gt5([10]) == [19]\nassert op_double_dec_gt5([2, 4, 6]) == [7, 11]\nassert op_double_dec_gt5([-7, 12, -7]) == [23]"}
{"id": "op_ages_evens_firsteven", "entry_point": "op_ages_evens_firsteven", "primitives": ["ages", "evens", "firsteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then return the first even value (0 if none).", "solution": "def op_ages_evens_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_evens_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_evens_firsteven([]) == 0\nassert op_ages_evens_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 18\nassert op_ages_evens_firsteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_double_oremptyzero_evens", "entry_point": "op_double_oremptyzero_evens", "primitives": ["double", "oremptyzero", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_double_oremptyzero_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_oremptyzero_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_evens([]) == [0]\nassert op_double_oremptyzero_evens([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_oremptyzero_evens([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_evens([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_evens([10]) == [20]\nassert op_double_oremptyzero_evens([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_evens([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_sortd_uniq_prod", "entry_point": "op_sortd_uniq_prod", "primitives": ["sortd", "uniq", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then return their product.", "solution": "def op_sortd_uniq_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_sortd_uniq_prod([1, 2, 3, 4]) == 24\nassert op_sortd_uniq_prod([]) == 1\nassert op_sortd_uniq_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_uniq_prod([5, 5, 5]) == 5\nassert op_sortd_uniq_prod([3, 1, 2]) == 6\nassert op_sortd_uniq_prod([10]) == 10\nassert op_sortd_uniq_prod([2, 4, 6]) == 48\nassert op_sortd_uniq_prod([-7, 12, -7]) == -84"}
{"id": "op_first3_odds_pos", "entry_point": "op_first3_odds_pos", "primitives": ["first3", "odds", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then keep the positive numbers.", "solution": "def op_first3_odds_pos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_first3_odds_pos([1, 2, 3, 4]) == [1, 3]\nassert op_first3_odds_pos([]) == []\nassert op_first3_odds_pos([-2, -1, 0, 1, 2]) == []\nassert op_first3_odds_pos([5, 5, 5]) == [5, 5, 5]\nassert op_first3_odds_pos([3, 1, 2]) == [3, 1]\nassert op_first3_odds_pos([10]) == []\nassert op_first3_odds_pos([2, 4, 6]) == []\nassert op_first3_odds_pos([-7, 12, -7]) == []"}
{"id": "op_odds_rev_uniq", "entry_point": "op_odds_rev_uniq", "primitives": ["odds", "rev", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then drop duplicates keeping first occurrence.", "solution": "def op_odds_rev_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_odds_rev_uniq([1, 2, 3, 4]) == [3, 1]\nassert op_odds_rev_uniq([]) == []\nassert op_odds_rev_uniq([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_rev_uniq([5, 5, 5]) == [5]\nassert op_odds_rev_uniq([3, 1, 2]) == [1, 3]\nassert op_odds_rev_uniq([10]) == []\nassert op_odds_rev_uniq([2, 4, 6]) == []\nassert op_odds_rev_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_dropzeros_div3_alldistinct", "entry_point": "op_dropzeros_div3_alldistinct", "primitives": ["dropzeros", "div3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then return whether all values are distinct.", "solution": "def op_dropzeros_div3_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_dropzeros_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_dropzeros_div3_alldistinct([]) == True\nassert op_dropzeros_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_div3_alldistinct([5, 5, 5]) == True\nassert op_dropzeros_div3_alldistinct([3, 1, 2]) == True\nassert op_dropzeros_div3_alldistinct([10]) == True\nassert op_dropzeros_div3_alldistinct([2, 4, 6]) == True\nassert op_dropzeros_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropzeros_oremptyzero_negate", "entry_point": "op_dropzeros_oremptyzero_negate", "primitives": ["dropzeros", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then negate each.", "solution": "def op_dropzeros_oremptyzero_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropzeros_oremptyzero_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropzeros_oremptyzero_negate([]) == [0]\nassert op_dropzeros_oremptyzero_negate([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_oremptyzero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_oremptyzero_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_dropzeros_oremptyzero_negate([10]) == [-10]\nassert op_dropzeros_oremptyzero_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_oremptyzero_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_beforezero_dec_issorted", "entry_point": "op_beforezero_dec_issorted", "primitives": ["beforezero", "dec", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then return whether the list is sorted ascending.", "solution": "def op_beforezero_dec_issorted(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_beforezero_dec_issorted([1, 2, 3, 4]) == True\nassert op_beforezero_dec_issorted([]) == True\nassert op_beforezero_dec_issorted([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_dec_issorted([5, 5, 5]) == True\nassert op_beforezero_dec_issorted([3, 1, 2]) == False\nassert op_beforezero_dec_issorted([10]) == True\nassert op_beforezero_dec_issorted([2, 4, 6]) == True\nassert op_beforezero_dec_issorted([-7, 12, -7]) == False"}
{"id": "op_uniq_div3_padto3", "entry_point": "op_uniq_div3_padto3", "primitives": ["uniq", "div3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then pad with zeros to at least three elements.", "solution": "def op_uniq_div3_padto3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_uniq_div3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_uniq_div3_padto3([]) == [0, 0, 0]\nassert op_uniq_div3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_uniq_div3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_uniq_div3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_uniq_div3_padto3([10]) == [0, 0, 0]\nassert op_uniq_div3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_uniq_div3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_ages_rev_pos", "entry_point": "op_ages_rev_pos", "primitives": ["ages", "rev", "pos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then keep the positive numbers.", "solution": "def op_ages_rev_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_rev_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_rev_pos([]) == []\nassert op_ages_rev_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_rev_pos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_sortabs_beforezero_absval", "entry_point": "op_sortabs_beforezero_absval", "primitives": ["sortabs", "beforezero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_sortabs_beforezero_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_beforezero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_beforezero_absval([]) == []\nassert op_sortabs_beforezero_absval([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_beforezero_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_beforezero_absval([10]) == [10]\nassert op_sortabs_beforezero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_beforezero_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_negate_trimends_counteven", "entry_point": "op_negate_trimends_counteven", "primitives": ["negate", "trimends", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first and last elements, then return how many values are even.", "solution": "def op_negate_trimends_counteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_negate_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_negate_trimends_counteven([]) == 0\nassert op_negate_trimends_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_negate_trimends_counteven([5, 5, 5]) == 0\nassert op_negate_trimends_counteven([3, 1, 2]) == 0\nassert op_negate_trimends_counteven([10]) == 0\nassert op_negate_trimends_counteven([2, 4, 6]) == 1\nassert op_negate_trimends_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_dropzeros_takewhilepos", "entry_point": "op_rev_dropzeros_takewhilepos", "primitives": ["rev", "dropzeros", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then take values while they are positive.", "solution": "def op_rev_dropzeros_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_dropzeros_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropzeros_takewhilepos([]) == []\nassert op_rev_dropzeros_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_dropzeros_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_dropzeros_takewhilepos([10]) == [10]\nassert op_rev_dropzeros_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropzeros_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_pos_negate_sortd", "entry_point": "op_pos_negate_sortd", "primitives": ["pos", "negate", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then sort descending.", "solution": "def op_pos_negate_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_pos_negate_sortd([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_negate_sortd([]) == []\nassert op_pos_negate_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_negate_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_negate_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_pos_negate_sortd([10]) == [-10]\nassert op_pos_negate_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_negate_sortd([-7, 12, -7]) == [-12]"}
{"id": "op_trimends_rev_len", "entry_point": "op_trimends_rev_len", "primitives": ["trimends", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then return how many remain.", "solution": "def op_trimends_rev_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_trimends_rev_len([1, 2, 3, 4]) == 2\nassert op_trimends_rev_len([]) == 0\nassert op_trimends_rev_len([-2, -1, 0, 1, 2]) == 3\nassert op_trimends_rev_len([5, 5, 5]) == 1\nassert op_trimends_rev_len([3, 1, 2]) == 1\nassert op_trimends_rev_len([10]) == 0\nassert op_trimends_rev_len([2, 4, 6]) == 1\nassert op_trimends_rev_len([-7, 12, -7]) == 1"}
{"id": "op_strip_uniqs_anyempty", "entry_point": "op_strip_uniqs_anyempty", "primitives": ["strip", "uniqs", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_strip_uniqs_anyempty(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_strip_uniqs_anyempty(['Hello', 'world']) == False\nassert op_strip_uniqs_anyempty([]) == False\nassert op_strip_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_strip_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_strip_uniqs_anyempty(['x']) == False\nassert op_strip_uniqs_anyempty(['abc', 'de', '']) == True"}
{"id": "op_takewhilepos_padto3_issorted", "entry_point": "op_takewhilepos_padto3_issorted", "primitives": ["takewhilepos", "padto3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_takewhilepos_padto3_issorted(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_takewhilepos_padto3_issorted([1, 2, 3, 4]) == True\nassert op_takewhilepos_padto3_issorted([]) == True\nassert op_takewhilepos_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_padto3_issorted([5, 5, 5]) == True\nassert op_takewhilepos_padto3_issorted([3, 1, 2]) == False\nassert op_takewhilepos_padto3_issorted([10]) == False\nassert op_takewhilepos_padto3_issorted([2, 4, 6]) == True\nassert op_takewhilepos_padto3_issorted([-7, 12, -7]) == True"}
{"id": "op_odds_absval_allpos", "entry_point": "op_odds_absval_allpos", "primitives": ["odds", "absval", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_odds_absval_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_odds_absval_allpos([1, 2, 3, 4]) == True\nassert op_odds_absval_allpos([]) == True\nassert op_odds_absval_allpos([-2, -1, 0, 1, 2]) == True\nassert op_odds_absval_allpos([5, 5, 5]) == True\nassert op_odds_absval_allpos([3, 1, 2]) == True\nassert op_odds_absval_allpos([10]) == True\nassert op_odds_absval_allpos([2, 4, 6]) == True\nassert op_odds_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_double_trimends_alldistinct", "entry_point": "op_double_trimends_alldistinct", "primitives": ["double", "trimends", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_double_trimends_alldistinct(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_double_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_double_trimends_alldistinct([]) == True\nassert op_double_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_double_trimends_alldistinct([5, 5, 5]) == True\nassert op_double_trimends_alldistinct([3, 1, 2]) == True\nassert op_double_trimends_alldistinct([10]) == True\nassert op_double_trimends_alldistinct([2, 4, 6]) == True\nassert op_double_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_inc_len", "entry_point": "op_div3_inc_len", "primitives": ["div3", "inc", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then return how many remain.", "solution": "def op_div3_inc_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return len(r)", "tests": "assert op_div3_inc_len([1, 2, 3, 4]) == 1\nassert op_div3_inc_len([]) == 0\nassert op_div3_inc_len([-2, -1, 0, 1, 2]) == 1\nassert op_div3_inc_len([5, 5, 5]) == 0\nassert op_div3_inc_len([3, 1, 2]) == 1\nassert op_div3_inc_len([10]) == 0\nassert op_div3_inc_len([2, 4, 6]) == 1\nassert op_div3_inc_len([-7, 12, -7]) == 1"}
{"id": "op_sortd_odds_counteven", "entry_point": "op_sortd_odds_counteven", "primitives": ["sortd", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then return how many values are even.", "solution": "def op_sortd_odds_counteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortd_odds_counteven([1, 2, 3, 4]) == 0\nassert op_sortd_odds_counteven([]) == 0\nassert op_sortd_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_odds_counteven([5, 5, 5]) == 0\nassert op_sortd_odds_counteven([3, 1, 2]) == 0\nassert op_sortd_odds_counteven([10]) == 0\nassert op_sortd_odds_counteven([2, 4, 6]) == 0\nassert op_sortd_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_padto3_dec_len", "entry_point": "op_padto3_dec_len", "primitives": ["padto3", "dec", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then return how many remain.", "solution": "def op_padto3_dec_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return len(r)", "tests": "assert op_padto3_dec_len([1, 2, 3, 4]) == 4\nassert op_padto3_dec_len([]) == 3\nassert op_padto3_dec_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_dec_len([5, 5, 5]) == 3\nassert op_padto3_dec_len([3, 1, 2]) == 3\nassert op_padto3_dec_len([10]) == 3\nassert op_padto3_dec_len([2, 4, 6]) == 3\nassert op_padto3_dec_len([-7, 12, -7]) == 3"}
{"id": "op_dropzeros_first3_odds", "entry_point": "op_dropzeros_first3_odds", "primitives": ["dropzeros", "first3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then keep the odd numbers.", "solution": "def op_dropzeros_first3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropzeros_first3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_first3_odds([]) == []\nassert op_dropzeros_first3_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_first3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3_odds([3, 1, 2]) == [3, 1]\nassert op_dropzeros_first3_odds([10]) == []\nassert op_dropzeros_first3_odds([2, 4, 6]) == []\nassert op_dropzeros_first3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_clamp10_sum", "entry_point": "op_evens_clamp10_sum", "primitives": ["evens", "clamp10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10, then return their sum.", "solution": "def op_evens_clamp10_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_evens_clamp10_sum([1, 2, 3, 4]) == 6\nassert op_evens_clamp10_sum([]) == 0\nassert op_evens_clamp10_sum([-2, -1, 0, 1, 2]) == 0\nassert op_evens_clamp10_sum([5, 5, 5]) == 0\nassert op_evens_clamp10_sum([3, 1, 2]) == 2\nassert op_evens_clamp10_sum([10]) == 10\nassert op_evens_clamp10_sum([2, 4, 6]) == 12\nassert op_evens_clamp10_sum([-7, 12, -7]) == 10"}
{"id": "op_dropwhileneg_dropfirst_len", "entry_point": "op_dropwhileneg_dropfirst_len", "primitives": ["dropwhileneg", "dropfirst", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then return how many remain.", "solution": "def op_dropwhileneg_dropfirst_len(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return len(r)", "tests": "assert op_dropwhileneg_dropfirst_len([1, 2, 3, 4]) == 3\nassert op_dropwhileneg_dropfirst_len([]) == 0\nassert op_dropwhileneg_dropfirst_len([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_dropfirst_len([5, 5, 5]) == 2\nassert op_dropwhileneg_dropfirst_len([3, 1, 2]) == 2\nassert op_dropwhileneg_dropfirst_len([10]) == 0\nassert op_dropwhileneg_dropfirst_len([2, 4, 6]) == 2\nassert op_dropwhileneg_dropfirst_len([-7, 12, -7]) == 1"}
{"id": "op_rev_sortd_neg", "entry_point": "op_rev_sortd_neg", "primitives": ["rev", "sortd", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then keep the negative numbers.", "solution": "def op_rev_sortd_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_sortd_neg([1, 2, 3, 4]) == []\nassert op_rev_sortd_neg([]) == []\nassert op_rev_sortd_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_rev_sortd_neg([5, 5, 5]) == []\nassert op_rev_sortd_neg([3, 1, 2]) == []\nassert op_rev_sortd_neg([10]) == []\nassert op_rev_sortd_neg([2, 4, 6]) == []\nassert op_rev_sortd_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_takewhilepos_padto3_beforezero", "entry_point": "op_takewhilepos_padto3_beforezero", "primitives": ["takewhilepos", "padto3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then keep everything before the first zero.", "solution": "def op_takewhilepos_padto3_beforezero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_takewhilepos_padto3_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_padto3_beforezero([]) == []\nassert op_takewhilepos_padto3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_padto3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_padto3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_padto3_beforezero([10]) == [10]\nassert op_takewhilepos_padto3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_padto3_beforezero([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_trimends_add10", "entry_point": "op_takewhilepos_trimends_add10", "primitives": ["takewhilepos", "trimends", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then add ten to each.", "solution": "def op_takewhilepos_trimends_add10(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_takewhilepos_trimends_add10([1, 2, 3, 4]) == [12, 13]\nassert op_takewhilepos_trimends_add10([]) == []\nassert op_takewhilepos_trimends_add10([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_trimends_add10([5, 5, 5]) == [15]\nassert op_takewhilepos_trimends_add10([3, 1, 2]) == [11]\nassert op_takewhilepos_trimends_add10([10]) == []\nassert op_takewhilepos_trimends_add10([2, 4, 6]) == [14]\nassert op_takewhilepos_trimends_add10([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_div3_dec", "entry_point": "op_oremptyzero_div3_dec", "primitives": ["oremptyzero", "div3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep multiples of three, then subtract one from each.", "solution": "def op_oremptyzero_div3_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_div3_dec([1, 2, 3, 4]) == [2]\nassert op_oremptyzero_div3_dec([]) == [-1]\nassert op_oremptyzero_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_oremptyzero_div3_dec([5, 5, 5]) == []\nassert op_oremptyzero_div3_dec([3, 1, 2]) == [2]\nassert op_oremptyzero_div3_dec([10]) == []\nassert op_oremptyzero_div3_dec([2, 4, 6]) == [5]\nassert op_oremptyzero_div3_dec([-7, 12, -7]) == [11]"}
{"id": "op_inc_add10_min", "entry_point": "op_inc_add10_min", "primitives": ["inc", "add10", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_inc_add10_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_inc_add10_min([1, 2, 3, 4]) == 12\nassert op_inc_add10_min([]) == 0\nassert op_inc_add10_min([-2, -1, 0, 1, 2]) == 9\nassert op_inc_add10_min([5, 5, 5]) == 16\nassert op_inc_add10_min([3, 1, 2]) == 12\nassert op_inc_add10_min([10]) == 21\nassert op_inc_add10_min([2, 4, 6]) == 13\nassert op_inc_add10_min([-7, 12, -7]) == 4"}
{"id": "op_last3_first3_dropwhileneg", "entry_point": "op_last3_first3_dropwhileneg", "primitives": ["last3", "first3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then drop the leading negative values.", "solution": "def op_last3_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_first3_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_first3_dropwhileneg([]) == []\nassert op_last3_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_last3_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_last3_first3_dropwhileneg([10]) == [10]\nassert op_last3_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_last3_first3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_uniq_neg_dropzeros", "entry_point": "op_uniq_neg_dropzeros", "primitives": ["uniq", "neg", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers, then drop the zeros.", "solution": "def op_uniq_neg_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_uniq_neg_dropzeros([]) == []\nassert op_uniq_neg_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_neg_dropzeros([5, 5, 5]) == []\nassert op_uniq_neg_dropzeros([3, 1, 2]) == []\nassert op_uniq_neg_dropzeros([10]) == []\nassert op_uniq_neg_dropzeros([2, 4, 6]) == []\nassert op_uniq_neg_dropzeros([-7, 12, -7]) == [-7]"}
{"id": "op_clamp10_absval_gt5", "entry_point": "op_clamp10_absval_gt5", "primitives": ["clamp10", "absval", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then keep values greater than five.", "solution": "def op_clamp10_absval_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_absval_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_absval_gt5([]) == []\nassert op_clamp10_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_absval_gt5([5, 5, 5]) == []\nassert op_clamp10_absval_gt5([3, 1, 2]) == []\nassert op_clamp10_absval_gt5([10]) == [10]\nassert op_clamp10_absval_gt5([2, 4, 6]) == [6]\nassert op_clamp10_absval_gt5([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_double_square_sortd", "entry_point": "op_double_square_sortd", "primitives": ["double", "square", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then sort descending.", "solution": "def op_double_square_sortd(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_double_square_sortd([1, 2, 3, 4]) == [64, 36, 16, 4]\nassert op_double_square_sortd([]) == []\nassert op_double_square_sortd([-2, -1, 0, 1, 2]) == [16, 16, 4, 4, 0]\nassert op_double_square_sortd([5, 5, 5]) == [100, 100, 100]\nassert op_double_square_sortd([3, 1, 2]) == [36, 16, 4]\nassert op_double_square_sortd([10]) == [400]\nassert op_double_square_sortd([2, 4, 6]) == [144, 64, 16]\nassert op_double_square_sortd([-7, 12, -7]) == [576, 196, 196]"}
{"id": "op_gt5_sorta_neg", "entry_point": "op_gt5_sorta_neg", "primitives": ["gt5", "sorta", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then keep the negative numbers.", "solution": "def op_gt5_sorta_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_gt5_sorta_neg([1, 2, 3, 4]) == []\nassert op_gt5_sorta_neg([]) == []\nassert op_gt5_sorta_neg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_neg([5, 5, 5]) == []\nassert op_gt5_sorta_neg([3, 1, 2]) == []\nassert op_gt5_sorta_neg([10]) == []\nassert op_gt5_sorta_neg([2, 4, 6]) == []\nassert op_gt5_sorta_neg([-7, 12, -7]) == []"}
{"id": "op_padto3_last3_beforezero", "entry_point": "op_padto3_last3_beforezero", "primitives": ["padto3", "last3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then keep everything before the first zero.", "solution": "def op_padto3_last3_beforezero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_padto3_last3_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_last3_beforezero([]) == []\nassert op_padto3_last3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_padto3_last3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_last3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_last3_beforezero([10]) == [10]\nassert op_padto3_last3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3_beforezero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sorta_inc_oremptyzero", "entry_point": "op_sorta_inc_oremptyzero", "primitives": ["sorta", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then if empty, use a single zero.", "solution": "def op_sorta_inc_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_inc_oremptyzero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_inc_oremptyzero([]) == [0]\nassert op_sorta_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_sorta_inc_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_oremptyzero([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_inc_oremptyzero([10]) == [11]\nassert op_sorta_inc_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_inc_oremptyzero([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_ages_pos_double", "entry_point": "op_ages_pos_double", "primitives": ["ages", "pos", "double"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers, then double each.", "solution": "def op_ages_pos_double(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_ages_pos_double([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [72, 24]\nassert op_ages_pos_double([]) == []\nassert op_ages_pos_double([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [36, 130, 34]\nassert op_ages_pos_double([{'name': 'Fi', 'age': 41}]) == [82]"}
{"id": "op_sortd_uniq_alldistinct", "entry_point": "op_sortd_uniq_alldistinct", "primitives": ["sortd", "uniq", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_sortd_uniq_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_sortd_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_uniq_alldistinct([]) == True\nassert op_sortd_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_uniq_alldistinct([5, 5, 5]) == True\nassert op_sortd_uniq_alldistinct([3, 1, 2]) == True\nassert op_sortd_uniq_alldistinct([10]) == True\nassert op_sortd_uniq_alldistinct([2, 4, 6]) == True\nassert op_sortd_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_beforezero_sorta", "entry_point": "op_oremptyzero_beforezero_sorta", "primitives": ["oremptyzero", "beforezero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero, then sort ascending.", "solution": "def op_oremptyzero_beforezero_sorta(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_oremptyzero_beforezero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_beforezero_sorta([]) == []\nassert op_oremptyzero_beforezero_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_beforezero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_beforezero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_beforezero_sorta([10]) == [10]\nassert op_oremptyzero_beforezero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_beforezero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropwhileneg_negate_prod", "entry_point": "op_dropwhileneg_negate_prod", "primitives": ["dropwhileneg", "negate", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then return their product.", "solution": "def op_dropwhileneg_negate_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_negate_prod([1, 2, 3, 4]) == 24\nassert op_dropwhileneg_negate_prod([]) == 1\nassert op_dropwhileneg_negate_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_negate_prod([5, 5, 5]) == -125\nassert op_dropwhileneg_negate_prod([3, 1, 2]) == -6\nassert op_dropwhileneg_negate_prod([10]) == -10\nassert op_dropwhileneg_negate_prod([2, 4, 6]) == -48\nassert op_dropwhileneg_negate_prod([-7, 12, -7]) == -84"}
{"id": "op_evens_inc_neg", "entry_point": "op_evens_inc_neg", "primitives": ["evens", "inc", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then keep the negative numbers.", "solution": "def op_evens_inc_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_inc_neg([1, 2, 3, 4]) == []\nassert op_evens_inc_neg([]) == []\nassert op_evens_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_evens_inc_neg([5, 5, 5]) == []\nassert op_evens_inc_neg([3, 1, 2]) == []\nassert op_evens_inc_neg([10]) == []\nassert op_evens_inc_neg([2, 4, 6]) == []\nassert op_evens_inc_neg([-7, 12, -7]) == []"}
{"id": "op_beforezero_negate_last3", "entry_point": "op_beforezero_negate_last3", "primitives": ["beforezero", "negate", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then keep only the last three.", "solution": "def op_beforezero_negate_last3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_beforezero_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_beforezero_negate_last3([]) == []\nassert op_beforezero_negate_last3([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_beforezero_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_beforezero_negate_last3([10]) == [-10]\nassert op_beforezero_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_beforezero_negate_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_sorta_gt5_add10", "entry_point": "op_sorta_gt5_add10", "primitives": ["sorta", "gt5", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five, then add ten to each.", "solution": "def op_sorta_gt5_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_gt5_add10([1, 2, 3, 4]) == []\nassert op_sorta_gt5_add10([]) == []\nassert op_sorta_gt5_add10([-2, -1, 0, 1, 2]) == []\nassert op_sorta_gt5_add10([5, 5, 5]) == []\nassert op_sorta_gt5_add10([3, 1, 2]) == []\nassert op_sorta_gt5_add10([10]) == [20]\nassert op_sorta_gt5_add10([2, 4, 6]) == [16]\nassert op_sorta_gt5_add10([-7, 12, -7]) == [22]"}
{"id": "op_negate_beforezero_dropfirst", "entry_point": "op_negate_beforezero_dropfirst", "primitives": ["negate", "beforezero", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then drop the first element.", "solution": "def op_negate_beforezero_dropfirst(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return r", "tests": "assert op_negate_beforezero_dropfirst([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_beforezero_dropfirst([]) == []\nassert op_negate_beforezero_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_negate_beforezero_dropfirst([5, 5, 5]) == [-5, -5]\nassert op_negate_beforezero_dropfirst([3, 1, 2]) == [-1, -2]\nassert op_negate_beforezero_dropfirst([10]) == []\nassert op_negate_beforezero_dropfirst([2, 4, 6]) == [-4, -6]\nassert op_negate_beforezero_dropfirst([-7, 12, -7]) == [-12, 7]"}
{"id": "op_inc_div3_sortd", "entry_point": "op_inc_div3_sortd", "primitives": ["inc", "div3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then sort descending.", "solution": "def op_inc_div3_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_div3_sortd([1, 2, 3, 4]) == [3]\nassert op_inc_div3_sortd([]) == []\nassert op_inc_div3_sortd([-2, -1, 0, 1, 2]) == [3, 0]\nassert op_inc_div3_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_inc_div3_sortd([3, 1, 2]) == [3]\nassert op_inc_div3_sortd([10]) == []\nassert op_inc_div3_sortd([2, 4, 6]) == [3]\nassert op_inc_div3_sortd([-7, 12, -7]) == [-6, -6]"}
{"id": "op_beforezero_pos_allpos", "entry_point": "op_beforezero_pos_allpos", "primitives": ["beforezero", "pos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_beforezero_pos_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_pos_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_pos_allpos([]) == True\nassert op_beforezero_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_pos_allpos([5, 5, 5]) == True\nassert op_beforezero_pos_allpos([3, 1, 2]) == True\nassert op_beforezero_pos_allpos([10]) == True\nassert op_beforezero_pos_allpos([2, 4, 6]) == True\nassert op_beforezero_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_beforezero_dec_anyeven", "entry_point": "op_beforezero_dec_anyeven", "primitives": ["beforezero", "dec", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then return whether any value is even.", "solution": "def op_beforezero_dec_anyeven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_beforezero_dec_anyeven([1, 2, 3, 4]) == True\nassert op_beforezero_dec_anyeven([]) == False\nassert op_beforezero_dec_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_dec_anyeven([5, 5, 5]) == True\nassert op_beforezero_dec_anyeven([3, 1, 2]) == True\nassert op_beforezero_dec_anyeven([10]) == False\nassert op_beforezero_dec_anyeven([2, 4, 6]) == False\nassert op_beforezero_dec_anyeven([-7, 12, -7]) == True"}
{"id": "op_neg_clamp10_absval", "entry_point": "op_neg_clamp10_absval", "primitives": ["neg", "clamp10", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then take the absolute value of each.", "solution": "def op_neg_clamp10_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_neg_clamp10_absval([1, 2, 3, 4]) == []\nassert op_neg_clamp10_absval([]) == []\nassert op_neg_clamp10_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_clamp10_absval([5, 5, 5]) == []\nassert op_neg_clamp10_absval([3, 1, 2]) == []\nassert op_neg_clamp10_absval([10]) == []\nassert op_neg_clamp10_absval([2, 4, 6]) == []\nassert op_neg_clamp10_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropwhileneg_sorta_absval", "entry_point": "op_dropwhileneg_sorta_absval", "primitives": ["dropwhileneg", "sorta", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort ascending, then take the absolute value of each.", "solution": "def op_dropwhileneg_sorta_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_sorta_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_sorta_absval([]) == []\nassert op_dropwhileneg_sorta_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_dropwhileneg_sorta_absval([10]) == [10]\nassert op_dropwhileneg_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_sorta_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_padto3_gt5_absval", "entry_point": "op_padto3_gt5_absval", "primitives": ["padto3", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then take the absolute value of each.", "solution": "def op_padto3_gt5_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_gt5_absval([1, 2, 3, 4]) == []\nassert op_padto3_gt5_absval([]) == []\nassert op_padto3_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_padto3_gt5_absval([5, 5, 5]) == []\nassert op_padto3_gt5_absval([3, 1, 2]) == []\nassert op_padto3_gt5_absval([10]) == [10]\nassert op_padto3_gt5_absval([2, 4, 6]) == [6]\nassert op_padto3_gt5_absval([-7, 12, -7]) == [12]"}
{"id": "op_neg_negate_add10", "entry_point": "op_neg_negate_add10", "primitives": ["neg", "negate", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then add ten to each.", "solution": "def op_neg_negate_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_neg_negate_add10([1, 2, 3, 4]) == []\nassert op_neg_negate_add10([]) == []\nassert op_neg_negate_add10([-2, -1, 0, 1, 2]) == [12, 11]\nassert op_neg_negate_add10([5, 5, 5]) == []\nassert op_neg_negate_add10([3, 1, 2]) == []\nassert op_neg_negate_add10([10]) == []\nassert op_neg_negate_add10([2, 4, 6]) == []\nassert op_neg_negate_add10([-7, 12, -7]) == [17, 17]"}
{"id": "op_inc_gt5_len", "entry_point": "op_inc_gt5_len", "primitives": ["inc", "gt5", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then return how many remain.", "solution": "def op_inc_gt5_len(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_inc_gt5_len([1, 2, 3, 4]) == 0\nassert op_inc_gt5_len([]) == 0\nassert op_inc_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_inc_gt5_len([5, 5, 5]) == 3\nassert op_inc_gt5_len([3, 1, 2]) == 0\nassert op_inc_gt5_len([10]) == 1\nassert op_inc_gt5_len([2, 4, 6]) == 1\nassert op_inc_gt5_len([-7, 12, -7]) == 1"}
{"id": "op_sortd_odds_uniq", "entry_point": "op_sortd_odds_uniq", "primitives": ["sortd", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_sortd_odds_uniq(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortd_odds_uniq([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_odds_uniq([]) == []\nassert op_sortd_odds_uniq([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_odds_uniq([5, 5, 5]) == [5]\nassert op_sortd_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_sortd_odds_uniq([10]) == []\nassert op_sortd_odds_uniq([2, 4, 6]) == []\nassert op_sortd_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_trimends_dropfirst_negate", "entry_point": "op_trimends_dropfirst_negate", "primitives": ["trimends", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the first element, then negate each.", "solution": "def op_trimends_dropfirst_negate(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_trimends_dropfirst_negate([1, 2, 3, 4]) == [-3]\nassert op_trimends_dropfirst_negate([]) == []\nassert op_trimends_dropfirst_negate([-2, -1, 0, 1, 2]) == [0, -1]\nassert op_trimends_dropfirst_negate([5, 5, 5]) == []\nassert op_trimends_dropfirst_negate([3, 1, 2]) == []\nassert op_trimends_dropfirst_negate([10]) == []\nassert op_trimends_dropfirst_negate([2, 4, 6]) == []\nassert op_trimends_dropfirst_negate([-7, 12, -7]) == []"}
{"id": "op_trimends_neg_evens", "entry_point": "op_trimends_neg_evens", "primitives": ["trimends", "neg", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then keep the even numbers.", "solution": "def op_trimends_neg_evens(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_trimends_neg_evens([1, 2, 3, 4]) == []\nassert op_trimends_neg_evens([]) == []\nassert op_trimends_neg_evens([-2, -1, 0, 1, 2]) == []\nassert op_trimends_neg_evens([5, 5, 5]) == []\nassert op_trimends_neg_evens([3, 1, 2]) == []\nassert op_trimends_neg_evens([10]) == []\nassert op_trimends_neg_evens([2, 4, 6]) == []\nassert op_trimends_neg_evens([-7, 12, -7]) == []"}
{"id": "op_inc_first3_negate", "entry_point": "op_inc_first3_negate", "primitives": ["inc", "first3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then negate each.", "solution": "def op_inc_first3_negate(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_inc_first3_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_inc_first3_negate([]) == []\nassert op_inc_first3_negate([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_inc_first3_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_inc_first3_negate([3, 1, 2]) == [-4, -2, -3]\nassert op_inc_first3_negate([10]) == [-11]\nassert op_inc_first3_negate([2, 4, 6]) == [-3, -5, -7]\nassert op_inc_first3_negate([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_pos_gt5_div3", "entry_point": "op_pos_gt5_div3", "primitives": ["pos", "gt5", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep values greater than five, then keep multiples of three.", "solution": "def op_pos_gt5_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_pos_gt5_div3([1, 2, 3, 4]) == []\nassert op_pos_gt5_div3([]) == []\nassert op_pos_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_pos_gt5_div3([5, 5, 5]) == []\nassert op_pos_gt5_div3([3, 1, 2]) == []\nassert op_pos_gt5_div3([10]) == []\nassert op_pos_gt5_div3([2, 4, 6]) == [6]\nassert op_pos_gt5_div3([-7, 12, -7]) == [12]"}
{"id": "op_div3_negate_inc", "entry_point": "op_div3_negate_inc", "primitives": ["div3", "negate", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then add one to each.", "solution": "def op_div3_negate_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_div3_negate_inc([1, 2, 3, 4]) == [-2]\nassert op_div3_negate_inc([]) == []\nassert op_div3_negate_inc([-2, -1, 0, 1, 2]) == [1]\nassert op_div3_negate_inc([5, 5, 5]) == []\nassert op_div3_negate_inc([3, 1, 2]) == [-2]\nassert op_div3_negate_inc([10]) == []\nassert op_div3_negate_inc([2, 4, 6]) == [-5]\nassert op_div3_negate_inc([-7, 12, -7]) == [-11]"}
{"id": "op_first3_double_sortabs", "entry_point": "op_first3_double_sortabs", "primitives": ["first3", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then sort by absolute value.", "solution": "def op_first3_double_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_double_sortabs([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_double_sortabs([]) == []\nassert op_first3_double_sortabs([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_first3_double_sortabs([5, 5, 5]) == [10, 10, 10]\nassert op_first3_double_sortabs([3, 1, 2]) == [2, 4, 6]\nassert op_first3_double_sortabs([10]) == [20]\nassert op_first3_double_sortabs([2, 4, 6]) == [4, 8, 12]\nassert op_first3_double_sortabs([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropfirst_evens_takewhilepos", "entry_point": "op_dropfirst_evens_takewhilepos", "primitives": ["dropfirst", "evens", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then take values while they are positive.", "solution": "def op_dropfirst_evens_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_dropfirst_evens_takewhilepos([]) == []\nassert op_dropfirst_evens_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_evens_takewhilepos([5, 5, 5]) == []\nassert op_dropfirst_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_dropfirst_evens_takewhilepos([10]) == []\nassert op_dropfirst_evens_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_lower_sortalpha_uniqs", "entry_point": "op_lower_sortalpha_uniqs", "primitives": ["lower", "sortalpha", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort alphabetically, then drop duplicate strings keeping the first.", "solution": "def op_lower_sortalpha_uniqs(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_lower_sortalpha_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortalpha_uniqs([]) == []\nassert op_lower_sortalpha_uniqs(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc']\nassert op_lower_sortalpha_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_lower_sortalpha_uniqs(['x']) == ['x']\nassert op_lower_sortalpha_uniqs(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_padto3_last3_evens", "entry_point": "op_padto3_last3_evens", "primitives": ["padto3", "last3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then keep the even numbers.", "solution": "def op_padto3_last3_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_last3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_last3_evens([]) == [0, 0, 0]\nassert op_padto3_last3_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_padto3_last3_evens([5, 5, 5]) == []\nassert op_padto3_last3_evens([3, 1, 2]) == [2]\nassert op_padto3_last3_evens([10]) == [10, 0, 0]\nassert op_padto3_last3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_dropfirst_rev", "entry_point": "op_sortabs_dropfirst_rev", "primitives": ["sortabs", "dropfirst", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element, then reverse the order.", "solution": "def op_sortabs_dropfirst_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_dropfirst_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_sortabs_dropfirst_rev([]) == []\nassert op_sortabs_dropfirst_rev([-2, -1, 0, 1, 2]) == [2, -2, 1, -1]\nassert op_sortabs_dropfirst_rev([5, 5, 5]) == [5, 5]\nassert op_sortabs_dropfirst_rev([3, 1, 2]) == [3, 2]\nassert op_sortabs_dropfirst_rev([10]) == []\nassert op_sortabs_dropfirst_rev([2, 4, 6]) == [6, 4]\nassert op_sortabs_dropfirst_rev([-7, 12, -7]) == [12, -7]"}
{"id": "op_pos_square_add10", "entry_point": "op_pos_square_add10", "primitives": ["pos", "square", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then add ten to each.", "solution": "def op_pos_square_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_square_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_pos_square_add10([]) == []\nassert op_pos_square_add10([-2, -1, 0, 1, 2]) == [11, 14]\nassert op_pos_square_add10([5, 5, 5]) == [35, 35, 35]\nassert op_pos_square_add10([3, 1, 2]) == [19, 11, 14]\nassert op_pos_square_add10([10]) == [110]\nassert op_pos_square_add10([2, 4, 6]) == [14, 26, 46]\nassert op_pos_square_add10([-7, 12, -7]) == [154]"}
{"id": "op_firstchar_prefixup_lower", "entry_point": "op_firstchar_prefixup_lower", "primitives": ["firstchar", "prefixup", "lower"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then prefix each with a hash, then lowercase each string.", "solution": "def op_firstchar_prefixup_lower(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_firstchar_prefixup_lower(['Hello', 'world']) == ['#h', '#w']\nassert op_firstchar_prefixup_lower([]) == []\nassert op_firstchar_prefixup_lower(['  a ', '', 'BC', 'bc']) == ['# ', '#b', '#b']\nassert op_firstchar_prefixup_lower(['one', 'one', 'Two']) == ['#o', '#o', '#t']\nassert op_firstchar_prefixup_lower(['x']) == ['#x']\nassert op_firstchar_prefixup_lower(['abc', 'de', '']) == ['#a', '#d']"}
{"id": "op_odds_div3_negate", "entry_point": "op_odds_div3_negate", "primitives": ["odds", "div3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then negate each.", "solution": "def op_odds_div3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_div3_negate([1, 2, 3, 4]) == [-3]\nassert op_odds_div3_negate([]) == []\nassert op_odds_div3_negate([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_negate([5, 5, 5]) == []\nassert op_odds_div3_negate([3, 1, 2]) == [-3]\nassert op_odds_div3_negate([10]) == []\nassert op_odds_div3_negate([2, 4, 6]) == []\nassert op_odds_div3_negate([-7, 12, -7]) == []"}
{"id": "op_last3_first3_takewhilepos", "entry_point": "op_last3_first3_takewhilepos", "primitives": ["last3", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then take values while they are positive.", "solution": "def op_last3_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_first3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_first3_takewhilepos([]) == []\nassert op_last3_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_last3_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_first3_takewhilepos([10]) == [10]\nassert op_last3_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_first3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_rev_sortabs_len", "entry_point": "op_rev_sortabs_len", "primitives": ["rev", "sortabs", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then return how many remain.", "solution": "def op_rev_sortabs_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return len(r)", "tests": "assert op_rev_sortabs_len([1, 2, 3, 4]) == 4\nassert op_rev_sortabs_len([]) == 0\nassert op_rev_sortabs_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_sortabs_len([5, 5, 5]) == 3\nassert op_rev_sortabs_len([3, 1, 2]) == 3\nassert op_rev_sortabs_len([10]) == 1\nassert op_rev_sortabs_len([2, 4, 6]) == 3\nassert op_rev_sortabs_len([-7, 12, -7]) == 3"}
{"id": "op_lower_strip_joinc", "entry_point": "op_lower_strip_joinc", "primitives": ["lower", "strip", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then trim whitespace from each, then join them with commas.", "solution": "def op_lower_strip_joinc(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    return ','.join(r)", "tests": "assert op_lower_strip_joinc(['Hello', 'world']) == 'hello,world'\nassert op_lower_strip_joinc([]) == ''\nassert op_lower_strip_joinc(['  a ', '', 'BC', 'bc']) == 'a,,bc,bc'\nassert op_lower_strip_joinc(['one', 'one', 'Two']) == 'one,one,two'\nassert op_lower_strip_joinc(['x']) == 'x'\nassert op_lower_strip_joinc(['abc', 'de', '']) == 'abc,de,'"}
{"id": "op_absval_first3_uniq", "entry_point": "op_absval_first3_uniq", "primitives": ["absval", "first3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_absval_first3_uniq(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_absval_first3_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_first3_uniq([]) == []\nassert op_absval_first3_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_first3_uniq([5, 5, 5]) == [5]\nassert op_absval_first3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_absval_first3_uniq([10]) == [10]\nassert op_absval_first3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_absval_first3_uniq([-7, 12, -7]) == [7, 12]"}
{"id": "op_beforezero_last3_sortd", "entry_point": "op_beforezero_last3_sortd", "primitives": ["beforezero", "last3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then sort descending.", "solution": "def op_beforezero_last3_sortd(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_beforezero_last3_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_beforezero_last3_sortd([]) == []\nassert op_beforezero_last3_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_last3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_last3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_beforezero_last3_sortd([10]) == [10]\nassert op_beforezero_last3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_last3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_beforezero_gt5_sum", "entry_point": "op_beforezero_gt5_sum", "primitives": ["beforezero", "gt5", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then return their sum.", "solution": "def op_beforezero_gt5_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_beforezero_gt5_sum([1, 2, 3, 4]) == 0\nassert op_beforezero_gt5_sum([]) == 0\nassert op_beforezero_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_gt5_sum([5, 5, 5]) == 0\nassert op_beforezero_gt5_sum([3, 1, 2]) == 0\nassert op_beforezero_gt5_sum([10]) == 10\nassert op_beforezero_gt5_sum([2, 4, 6]) == 6\nassert op_beforezero_gt5_sum([-7, 12, -7]) == 12"}
{"id": "op_ages_last3_gt5", "entry_point": "op_ages_last3_gt5", "primitives": ["ages", "last3", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then keep values greater than five.", "solution": "def op_ages_last3_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_last3_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_last3_gt5([]) == []\nassert op_ages_last3_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_last3_gt5([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_trimends_padto3_sortabs", "entry_point": "op_trimends_padto3_sortabs", "primitives": ["trimends", "padto3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_trimends_padto3_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_padto3_sortabs([1, 2, 3, 4]) == [0, 2, 3]\nassert op_trimends_padto3_sortabs([]) == [0, 0, 0]\nassert op_trimends_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_trimends_padto3_sortabs([5, 5, 5]) == [0, 0, 5]\nassert op_trimends_padto3_sortabs([3, 1, 2]) == [0, 0, 1]\nassert op_trimends_padto3_sortabs([10]) == [0, 0, 0]\nassert op_trimends_padto3_sortabs([2, 4, 6]) == [0, 0, 4]\nassert op_trimends_padto3_sortabs([-7, 12, -7]) == [0, 0, 12]"}
{"id": "op_evens_negate_len", "entry_point": "op_evens_negate_len", "primitives": ["evens", "negate", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then negate each, then return how many remain.", "solution": "def op_evens_negate_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_evens_negate_len([1, 2, 3, 4]) == 2\nassert op_evens_negate_len([]) == 0\nassert op_evens_negate_len([-2, -1, 0, 1, 2]) == 3\nassert op_evens_negate_len([5, 5, 5]) == 0\nassert op_evens_negate_len([3, 1, 2]) == 1\nassert op_evens_negate_len([10]) == 1\nassert op_evens_negate_len([2, 4, 6]) == 3\nassert op_evens_negate_len([-7, 12, -7]) == 1"}
{"id": "op_first3_last3_padto3", "entry_point": "op_first3_last3_padto3", "primitives": ["first3", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_first3_last3_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_last3_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_last3_padto3([]) == [0, 0, 0]\nassert op_first3_last3_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_last3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_last3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_last3_padto3([10]) == [10, 0, 0]\nassert op_first3_last3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_last3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sorta_double_absval", "entry_point": "op_sorta_double_absval", "primitives": ["sorta", "double", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each, then take the absolute value of each.", "solution": "def op_sorta_double_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_double_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sorta_double_absval([]) == []\nassert op_sorta_double_absval([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_sorta_double_absval([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_double_absval([3, 1, 2]) == [2, 4, 6]\nassert op_sorta_double_absval([10]) == [20]\nassert op_sorta_double_absval([2, 4, 6]) == [4, 8, 12]\nassert op_sorta_double_absval([-7, 12, -7]) == [14, 14, 24]"}
{"id": "op_beforezero_negate_trimends", "entry_point": "op_beforezero_negate_trimends", "primitives": ["beforezero", "negate", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then drop the first and last elements.", "solution": "def op_beforezero_negate_trimends(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_beforezero_negate_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_beforezero_negate_trimends([]) == []\nassert op_beforezero_negate_trimends([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_negate_trimends([5, 5, 5]) == [-5]\nassert op_beforezero_negate_trimends([3, 1, 2]) == [-1]\nassert op_beforezero_negate_trimends([10]) == []\nassert op_beforezero_negate_trimends([2, 4, 6]) == [-4]\nassert op_beforezero_negate_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_double_neg_rev", "entry_point": "op_double_neg_rev", "primitives": ["double", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the negative numbers, then reverse the order.", "solution": "def op_double_neg_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_neg_rev([1, 2, 3, 4]) == []\nassert op_double_neg_rev([]) == []\nassert op_double_neg_rev([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_double_neg_rev([5, 5, 5]) == []\nassert op_double_neg_rev([3, 1, 2]) == []\nassert op_double_neg_rev([10]) == []\nassert op_double_neg_rev([2, 4, 6]) == []\nassert op_double_neg_rev([-7, 12, -7]) == [-14, -14]"}
{"id": "op_ages_square_sum", "entry_point": "op_ages_square_sum", "primitives": ["ages", "square", "sum"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then return their sum.", "solution": "def op_ages_square_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_ages_square_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 1440\nassert op_ages_square_sum([]) == 0\nassert op_ages_square_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 4838\nassert op_ages_square_sum([{'name': 'Fi', 'age': 41}]) == 1681"}
{"id": "op_dec_clamp10_gt5", "entry_point": "op_dec_clamp10_gt5", "primitives": ["dec", "clamp10", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cap each value at 10, then keep values greater than five.", "solution": "def op_dec_clamp10_gt5(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dec_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_dec_clamp10_gt5([]) == []\nassert op_dec_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dec_clamp10_gt5([5, 5, 5]) == []\nassert op_dec_clamp10_gt5([3, 1, 2]) == []\nassert op_dec_clamp10_gt5([10]) == [9]\nassert op_dec_clamp10_gt5([2, 4, 6]) == []\nassert op_dec_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_trimends_beforezero_oremptyzero", "entry_point": "op_trimends_beforezero_oremptyzero", "primitives": ["trimends", "beforezero", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_trimends_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_beforezero_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_beforezero_oremptyzero([]) == [0]\nassert op_trimends_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero_oremptyzero([5, 5, 5]) == [5]\nassert op_trimends_beforezero_oremptyzero([3, 1, 2]) == [1]\nassert op_trimends_beforezero_oremptyzero([10]) == [0]\nassert op_trimends_beforezero_oremptyzero([2, 4, 6]) == [4]\nassert op_trimends_beforezero_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_lower_sortalpha", "entry_point": "op_uniqs_lower_sortalpha", "primitives": ["uniqs", "lower", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then lowercase each string, then sort alphabetically.", "solution": "def op_uniqs_lower_sortalpha(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s.lower() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_uniqs_lower_sortalpha(['Hello', 'world']) == ['hello', 'world']\nassert op_uniqs_lower_sortalpha([]) == []\nassert op_uniqs_lower_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc', 'bc']\nassert op_uniqs_lower_sortalpha(['one', 'one', 'Two']) == ['one', 'two']\nassert op_uniqs_lower_sortalpha(['x']) == ['x']\nassert op_uniqs_lower_sortalpha(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_evens_dropwhileneg_negate", "entry_point": "op_evens_dropwhileneg_negate", "primitives": ["evens", "dropwhileneg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then negate each.", "solution": "def op_evens_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_dropwhileneg_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_evens_dropwhileneg_negate([]) == []\nassert op_evens_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_evens_dropwhileneg_negate([5, 5, 5]) == []\nassert op_evens_dropwhileneg_negate([3, 1, 2]) == [-2]\nassert op_evens_dropwhileneg_negate([10]) == [-10]\nassert op_evens_dropwhileneg_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_evens_dropwhileneg_negate([-7, 12, -7]) == [-12]"}
{"id": "op_neg_sortd_issorted", "entry_point": "op_neg_sortd_issorted", "primitives": ["neg", "sortd", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_neg_sortd_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_neg_sortd_issorted([1, 2, 3, 4]) == True\nassert op_neg_sortd_issorted([]) == True\nassert op_neg_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_neg_sortd_issorted([5, 5, 5]) == True\nassert op_neg_sortd_issorted([3, 1, 2]) == True\nassert op_neg_sortd_issorted([10]) == True\nassert op_neg_sortd_issorted([2, 4, 6]) == True\nassert op_neg_sortd_issorted([-7, 12, -7]) == True"}
{"id": "op_neg_absval_div3", "entry_point": "op_neg_absval_div3", "primitives": ["neg", "absval", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then keep multiples of three.", "solution": "def op_neg_absval_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_neg_absval_div3([1, 2, 3, 4]) == []\nassert op_neg_absval_div3([]) == []\nassert op_neg_absval_div3([-2, -1, 0, 1, 2]) == []\nassert op_neg_absval_div3([5, 5, 5]) == []\nassert op_neg_absval_div3([3, 1, 2]) == []\nassert op_neg_absval_div3([10]) == []\nassert op_neg_absval_div3([2, 4, 6]) == []\nassert op_neg_absval_div3([-7, 12, -7]) == []"}
{"id": "op_ages_div3_dropwhileneg", "entry_point": "op_ages_div3_dropwhileneg", "primitives": ["ages", "div3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three, then drop the leading negative values.", "solution": "def op_ages_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_ages_div3_dropwhileneg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_div3_dropwhileneg([]) == []\nassert op_ages_div3_dropwhileneg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_div3_dropwhileneg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_first3_double_prod", "entry_point": "op_first3_double_prod", "primitives": ["first3", "double", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then return their product.", "solution": "def op_first3_double_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_first3_double_prod([1, 2, 3, 4]) == 48\nassert op_first3_double_prod([]) == 1\nassert op_first3_double_prod([-2, -1, 0, 1, 2]) == 0\nassert op_first3_double_prod([5, 5, 5]) == 1000\nassert op_first3_double_prod([3, 1, 2]) == 48\nassert op_first3_double_prod([10]) == 20\nassert op_first3_double_prod([2, 4, 6]) == 384\nassert op_first3_double_prod([-7, 12, -7]) == 4704"}
{"id": "op_square_odds_dropfirst", "entry_point": "op_square_odds_dropfirst", "primitives": ["square", "odds", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then drop the first element.", "solution": "def op_square_odds_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_square_odds_dropfirst([1, 2, 3, 4]) == [9]\nassert op_square_odds_dropfirst([]) == []\nassert op_square_odds_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_square_odds_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_odds_dropfirst([3, 1, 2]) == [1]\nassert op_square_odds_dropfirst([10]) == []\nassert op_square_odds_dropfirst([2, 4, 6]) == []\nassert op_square_odds_dropfirst([-7, 12, -7]) == [49]"}
{"id": "op_square_dropwhileneg_haszero", "entry_point": "op_square_dropwhileneg_haszero", "primitives": ["square", "dropwhileneg", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_square_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_square_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_square_dropwhileneg_haszero([]) == False\nassert op_square_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == True\nassert op_square_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_square_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_square_dropwhileneg_haszero([10]) == False\nassert op_square_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_square_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_absval_alldistinct", "entry_point": "op_uniq_absval_alldistinct", "primitives": ["uniq", "absval", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then return whether all values are distinct.", "solution": "def op_uniq_absval_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_uniq_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_absval_alldistinct([]) == True\nassert op_uniq_absval_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_uniq_absval_alldistinct([5, 5, 5]) == True\nassert op_uniq_absval_alldistinct([3, 1, 2]) == True\nassert op_uniq_absval_alldistinct([10]) == True\nassert op_uniq_absval_alldistinct([2, 4, 6]) == True\nassert op_uniq_absval_alldistinct([-7, 12, -7]) == True"}
{"id": "op_beforezero_sorta_sum", "entry_point": "op_beforezero_sorta_sum", "primitives": ["beforezero", "sorta", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then return their sum.", "solution": "def op_beforezero_sorta_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_beforezero_sorta_sum([1, 2, 3, 4]) == 10\nassert op_beforezero_sorta_sum([]) == 0\nassert op_beforezero_sorta_sum([-2, -1, 0, 1, 2]) == -3\nassert op_beforezero_sorta_sum([5, 5, 5]) == 15\nassert op_beforezero_sorta_sum([3, 1, 2]) == 6\nassert op_beforezero_sorta_sum([10]) == 10\nassert op_beforezero_sorta_sum([2, 4, 6]) == 12\nassert op_beforezero_sorta_sum([-7, 12, -7]) == -2"}
{"id": "op_clamp10_last3_prod", "entry_point": "op_clamp10_last3_prod", "primitives": ["clamp10", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three, then return their product.", "solution": "def op_clamp10_last3_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_last3_prod([1, 2, 3, 4]) == 24\nassert op_clamp10_last3_prod([]) == 1\nassert op_clamp10_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_last3_prod([5, 5, 5]) == 125\nassert op_clamp10_last3_prod([3, 1, 2]) == 6\nassert op_clamp10_last3_prod([10]) == 10\nassert op_clamp10_last3_prod([2, 4, 6]) == 48\nassert op_clamp10_last3_prod([-7, 12, -7]) == 490"}
{"id": "op_dropzeros_negate_last3", "entry_point": "op_dropzeros_negate_last3", "primitives": ["dropzeros", "negate", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then keep only the last three.", "solution": "def op_dropzeros_negate_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropzeros_negate_last3([]) == []\nassert op_dropzeros_negate_last3([-2, -1, 0, 1, 2]) == [1, -1, -2]\nassert op_dropzeros_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_dropzeros_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_dropzeros_negate_last3([10]) == [-10]\nassert op_dropzeros_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_dropzeros_negate_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_beforezero_dec_haszero", "entry_point": "op_beforezero_dec_haszero", "primitives": ["beforezero", "dec", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_beforezero_dec_haszero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_beforezero_dec_haszero([1, 2, 3, 4]) == True\nassert op_beforezero_dec_haszero([]) == False\nassert op_beforezero_dec_haszero([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_dec_haszero([5, 5, 5]) == False\nassert op_beforezero_dec_haszero([3, 1, 2]) == True\nassert op_beforezero_dec_haszero([10]) == False\nassert op_beforezero_dec_haszero([2, 4, 6]) == False\nassert op_beforezero_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_ages_uniq_evens", "entry_point": "op_ages_uniq_evens", "primitives": ["ages", "uniq", "evens"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then keep the even numbers.", "solution": "def op_ages_uniq_evens(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_ages_uniq_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_uniq_evens([]) == []\nassert op_ages_uniq_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_uniq_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_double_odds_sortabs", "entry_point": "op_double_odds_sortabs", "primitives": ["double", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then sort by absolute value.", "solution": "def op_double_odds_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_odds_sortabs([1, 2, 3, 4]) == []\nassert op_double_odds_sortabs([]) == []\nassert op_double_odds_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_double_odds_sortabs([5, 5, 5]) == []\nassert op_double_odds_sortabs([3, 1, 2]) == []\nassert op_double_odds_sortabs([10]) == []\nassert op_double_odds_sortabs([2, 4, 6]) == []\nassert op_double_odds_sortabs([-7, 12, -7]) == []"}
{"id": "op_sortd_dropzeros_haszero", "entry_point": "op_sortd_dropzeros_haszero", "primitives": ["sortd", "dropzeros", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then return whether the list contains a zero.", "solution": "def op_sortd_dropzeros_haszero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_sortd_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_sortd_dropzeros_haszero([]) == False\nassert op_sortd_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortd_dropzeros_haszero([5, 5, 5]) == False\nassert op_sortd_dropzeros_haszero([3, 1, 2]) == False\nassert op_sortd_dropzeros_haszero([10]) == False\nassert op_sortd_dropzeros_haszero([2, 4, 6]) == False\nassert op_sortd_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_odds_counteven", "entry_point": "op_uniq_odds_counteven", "primitives": ["uniq", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then return how many values are even.", "solution": "def op_uniq_odds_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_odds_counteven([1, 2, 3, 4]) == 0\nassert op_uniq_odds_counteven([]) == 0\nassert op_uniq_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_odds_counteven([5, 5, 5]) == 0\nassert op_uniq_odds_counteven([3, 1, 2]) == 0\nassert op_uniq_odds_counteven([10]) == 0\nassert op_uniq_odds_counteven([2, 4, 6]) == 0\nassert op_uniq_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_last3_inc_beforezero", "entry_point": "op_last3_inc_beforezero", "primitives": ["last3", "inc", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then keep everything before the first zero.", "solution": "def op_last3_inc_beforezero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_last3_inc_beforezero([1, 2, 3, 4]) == [3, 4, 5]\nassert op_last3_inc_beforezero([]) == []\nassert op_last3_inc_beforezero([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_last3_inc_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_last3_inc_beforezero([3, 1, 2]) == [4, 2, 3]\nassert op_last3_inc_beforezero([10]) == [11]\nassert op_last3_inc_beforezero([2, 4, 6]) == [3, 5, 7]\nassert op_last3_inc_beforezero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortd_sortabs_alldistinct", "entry_point": "op_sortd_sortabs_alldistinct", "primitives": ["sortd", "sortabs", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_sortd_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_sortd_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_sortabs_alldistinct([]) == True\nassert op_sortd_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_sortabs_alldistinct([5, 5, 5]) == False\nassert op_sortd_sortabs_alldistinct([3, 1, 2]) == True\nassert op_sortd_sortabs_alldistinct([10]) == True\nassert op_sortd_sortabs_alldistinct([2, 4, 6]) == True\nassert op_sortd_sortabs_alldistinct([-7, 12, -7]) == False"}
{"id": "op_beforezero_gt5_dropfirst", "entry_point": "op_beforezero_gt5_dropfirst", "primitives": ["beforezero", "gt5", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then drop the first element.", "solution": "def op_beforezero_gt5_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_beforezero_gt5_dropfirst([]) == []\nassert op_beforezero_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5_dropfirst([5, 5, 5]) == []\nassert op_beforezero_gt5_dropfirst([3, 1, 2]) == []\nassert op_beforezero_gt5_dropfirst([10]) == []\nassert op_beforezero_gt5_dropfirst([2, 4, 6]) == []\nassert op_beforezero_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_last3_beforezero_odds", "entry_point": "op_last3_beforezero_odds", "primitives": ["last3", "beforezero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_last3_beforezero_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_beforezero_odds([1, 2, 3, 4]) == [3]\nassert op_last3_beforezero_odds([]) == []\nassert op_last3_beforezero_odds([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_odds([3, 1, 2]) == [3, 1]\nassert op_last3_beforezero_odds([10]) == []\nassert op_last3_beforezero_odds([2, 4, 6]) == []\nassert op_last3_beforezero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_double_odds_pos", "entry_point": "op_double_odds_pos", "primitives": ["double", "odds", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then keep the positive numbers.", "solution": "def op_double_odds_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_odds_pos([1, 2, 3, 4]) == []\nassert op_double_odds_pos([]) == []\nassert op_double_odds_pos([-2, -1, 0, 1, 2]) == []\nassert op_double_odds_pos([5, 5, 5]) == []\nassert op_double_odds_pos([3, 1, 2]) == []\nassert op_double_odds_pos([10]) == []\nassert op_double_odds_pos([2, 4, 6]) == []\nassert op_double_odds_pos([-7, 12, -7]) == []"}
{"id": "op_pos_dropfirst_allpos", "entry_point": "op_pos_dropfirst_allpos", "primitives": ["pos", "dropfirst", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first element, then return whether all values are positive.", "solution": "def op_pos_dropfirst_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_pos_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_pos_dropfirst_allpos([]) == True\nassert op_pos_dropfirst_allpos([-2, -1, 0, 1, 2]) == True\nassert op_pos_dropfirst_allpos([5, 5, 5]) == True\nassert op_pos_dropfirst_allpos([3, 1, 2]) == True\nassert op_pos_dropfirst_allpos([10]) == True\nassert op_pos_dropfirst_allpos([2, 4, 6]) == True\nassert op_pos_dropfirst_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_gt5_haszero", "entry_point": "op_oremptyzero_gt5_haszero", "primitives": ["oremptyzero", "gt5", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then return whether the list contains a zero.", "solution": "def op_oremptyzero_gt5_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_oremptyzero_gt5_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_gt5_haszero([]) == False\nassert op_oremptyzero_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_gt5_haszero([5, 5, 5]) == False\nassert op_oremptyzero_gt5_haszero([3, 1, 2]) == False\nassert op_oremptyzero_gt5_haszero([10]) == False\nassert op_oremptyzero_gt5_haszero([2, 4, 6]) == False\nassert op_oremptyzero_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_double_gt5_first3", "entry_point": "op_double_gt5_first3", "primitives": ["double", "gt5", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then keep only the first three.", "solution": "def op_double_gt5_first3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_double_gt5_first3([1, 2, 3, 4]) == [6, 8]\nassert op_double_gt5_first3([]) == []\nassert op_double_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_first3([5, 5, 5]) == [10, 10, 10]\nassert op_double_gt5_first3([3, 1, 2]) == [6]\nassert op_double_gt5_first3([10]) == [20]\nassert op_double_gt5_first3([2, 4, 6]) == [8, 12]\nassert op_double_gt5_first3([-7, 12, -7]) == [24]"}
{"id": "op_dec_absval_negate", "entry_point": "op_dec_absval_negate", "primitives": ["dec", "absval", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then negate each.", "solution": "def op_dec_absval_negate(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dec_absval_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_dec_absval_negate([]) == []\nassert op_dec_absval_negate([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, -1]\nassert op_dec_absval_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_absval_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_dec_absval_negate([10]) == [-9]\nassert op_dec_absval_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_absval_negate([-7, 12, -7]) == [-8, -11, -8]"}
{"id": "op_sorta_sortd_takewhilepos", "entry_point": "op_sorta_sortd_takewhilepos", "primitives": ["sorta", "sortd", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then take values while they are positive.", "solution": "def op_sorta_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sorta_sortd_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_sortd_takewhilepos([]) == []\nassert op_sorta_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sorta_sortd_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortd_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_sortd_takewhilepos([10]) == [10]\nassert op_sorta_sortd_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_sortd_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_pos_gt5_min", "entry_point": "op_pos_gt5_min", "primitives": ["pos", "gt5", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_pos_gt5_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_pos_gt5_min([1, 2, 3, 4]) == 0\nassert op_pos_gt5_min([]) == 0\nassert op_pos_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_pos_gt5_min([5, 5, 5]) == 0\nassert op_pos_gt5_min([3, 1, 2]) == 0\nassert op_pos_gt5_min([10]) == 10\nassert op_pos_gt5_min([2, 4, 6]) == 6\nassert op_pos_gt5_min([-7, 12, -7]) == 12"}
{"id": "op_evens_sortabs_prod", "entry_point": "op_evens_sortabs_prod", "primitives": ["evens", "sortabs", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then return their product.", "solution": "def op_evens_sortabs_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_evens_sortabs_prod([1, 2, 3, 4]) == 8\nassert op_evens_sortabs_prod([]) == 1\nassert op_evens_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_sortabs_prod([5, 5, 5]) == 1\nassert op_evens_sortabs_prod([3, 1, 2]) == 2\nassert op_evens_sortabs_prod([10]) == 10\nassert op_evens_sortabs_prod([2, 4, 6]) == 48\nassert op_evens_sortabs_prod([-7, 12, -7]) == 12"}
{"id": "op_evens_sorta_haszero", "entry_point": "op_evens_sorta_haszero", "primitives": ["evens", "sorta", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then return whether the list contains a zero.", "solution": "def op_evens_sorta_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return 0 in r", "tests": "assert op_evens_sorta_haszero([1, 2, 3, 4]) == False\nassert op_evens_sorta_haszero([]) == False\nassert op_evens_sorta_haszero([-2, -1, 0, 1, 2]) == True\nassert op_evens_sorta_haszero([5, 5, 5]) == False\nassert op_evens_sorta_haszero([3, 1, 2]) == False\nassert op_evens_sorta_haszero([10]) == False\nassert op_evens_sorta_haszero([2, 4, 6]) == False\nassert op_evens_sorta_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_sortd_firsteven", "entry_point": "op_padto3_sortd_firsteven", "primitives": ["padto3", "sortd", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then return the first even value (0 if none).", "solution": "def op_padto3_sortd_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_sortd_firsteven([1, 2, 3, 4]) == 4\nassert op_padto3_sortd_firsteven([]) == 0\nassert op_padto3_sortd_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_sortd_firsteven([5, 5, 5]) == 0\nassert op_padto3_sortd_firsteven([3, 1, 2]) == 2\nassert op_padto3_sortd_firsteven([10]) == 10\nassert op_padto3_sortd_firsteven([2, 4, 6]) == 6\nassert op_padto3_sortd_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dec_odds_haszero", "entry_point": "op_dec_odds_haszero", "primitives": ["dec", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_dec_odds_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_dec_odds_haszero([1, 2, 3, 4]) == False\nassert op_dec_odds_haszero([]) == False\nassert op_dec_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dec_odds_haszero([5, 5, 5]) == False\nassert op_dec_odds_haszero([3, 1, 2]) == False\nassert op_dec_odds_haszero([10]) == False\nassert op_dec_odds_haszero([2, 4, 6]) == False\nassert op_dec_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_absval_dec", "entry_point": "op_padto3_absval_dec", "primitives": ["padto3", "absval", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then subtract one from each.", "solution": "def op_padto3_absval_dec(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_padto3_absval_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_padto3_absval_dec([]) == [-1, -1, -1]\nassert op_padto3_absval_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, 0, 1]\nassert op_padto3_absval_dec([5, 5, 5]) == [4, 4, 4]\nassert op_padto3_absval_dec([3, 1, 2]) == [2, 0, 1]\nassert op_padto3_absval_dec([10]) == [9, -1, -1]\nassert op_padto3_absval_dec([2, 4, 6]) == [1, 3, 5]\nassert op_padto3_absval_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_absval_dropzeros_inc", "entry_point": "op_absval_dropzeros_inc", "primitives": ["absval", "dropzeros", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then add one to each.", "solution": "def op_absval_dropzeros_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_dropzeros_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_dropzeros_inc([]) == []\nassert op_absval_dropzeros_inc([-2, -1, 0, 1, 2]) == [3, 2, 2, 3]\nassert op_absval_dropzeros_inc([5, 5, 5]) == [6, 6, 6]\nassert op_absval_dropzeros_inc([3, 1, 2]) == [4, 2, 3]\nassert op_absval_dropzeros_inc([10]) == [11]\nassert op_absval_dropzeros_inc([2, 4, 6]) == [3, 5, 7]\nassert op_absval_dropzeros_inc([-7, 12, -7]) == [8, 13, 8]"}
{"id": "op_oremptyzero_dropfirst_div3", "entry_point": "op_oremptyzero_dropfirst_div3", "primitives": ["oremptyzero", "dropfirst", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then keep multiples of three.", "solution": "def op_oremptyzero_dropfirst_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_dropfirst_div3([]) == []\nassert op_oremptyzero_dropfirst_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_dropfirst_div3([5, 5, 5]) == []\nassert op_oremptyzero_dropfirst_div3([3, 1, 2]) == []\nassert op_oremptyzero_dropfirst_div3([10]) == []\nassert op_oremptyzero_dropfirst_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_dropfirst_div3([-7, 12, -7]) == [12]"}
{"id": "op_dec_takewhilepos_absval", "entry_point": "op_dec_takewhilepos_absval", "primitives": ["dec", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then take the absolute value of each.", "solution": "def op_dec_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_takewhilepos_absval([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos_absval([]) == []\nassert op_dec_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_takewhilepos_absval([3, 1, 2]) == [2]\nassert op_dec_takewhilepos_absval([10]) == [9]\nassert op_dec_takewhilepos_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_dropfirst_uniq_inc", "entry_point": "op_dropfirst_uniq_inc", "primitives": ["dropfirst", "uniq", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then add one to each.", "solution": "def op_dropfirst_uniq_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_uniq_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_dropfirst_uniq_inc([]) == []\nassert op_dropfirst_uniq_inc([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_dropfirst_uniq_inc([5, 5, 5]) == [6]\nassert op_dropfirst_uniq_inc([3, 1, 2]) == [2, 3]\nassert op_dropfirst_uniq_inc([10]) == []\nassert op_dropfirst_uniq_inc([2, 4, 6]) == [5, 7]\nassert op_dropfirst_uniq_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_nonempty_sortalpha_joinc", "entry_point": "op_nonempty_sortalpha_joinc", "primitives": ["nonempty", "sortalpha", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then sort alphabetically, then join them with commas.", "solution": "def op_nonempty_sortalpha_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = sorted(r)\n    return ','.join(r)", "tests": "assert op_nonempty_sortalpha_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_nonempty_sortalpha_joinc([]) == ''\nassert op_nonempty_sortalpha_joinc(['  a ', '', 'BC', 'bc']) == '  a ,BC,bc'\nassert op_nonempty_sortalpha_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_nonempty_sortalpha_joinc(['x']) == 'x'\nassert op_nonempty_sortalpha_joinc(['abc', 'de', '']) == 'abc,de'"}
{"id": "op_sortalpha_strip_sortlen", "entry_point": "op_sortalpha_strip_sortlen", "primitives": ["sortalpha", "strip", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then trim whitespace from each, then sort by length, shortest first.", "solution": "def op_sortalpha_strip_sortlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_sortalpha_strip_sortlen(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_strip_sortlen([]) == []\nassert op_sortalpha_strip_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'a', 'BC', 'bc']\nassert op_sortalpha_strip_sortlen(['one', 'one', 'Two']) == ['Two', 'one', 'one']\nassert op_sortalpha_strip_sortlen(['x']) == ['x']\nassert op_sortalpha_strip_sortlen(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_last3_sorta_dropzeros", "entry_point": "op_last3_sorta_dropzeros", "primitives": ["last3", "sorta", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then drop the zeros.", "solution": "def op_last3_sorta_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_sorta_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sorta_dropzeros([]) == []\nassert op_last3_sorta_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_sorta_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sorta_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sorta_dropzeros([10]) == [10]\nassert op_last3_sorta_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sorta_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_trimends_dropzeros_last3", "entry_point": "op_trimends_dropzeros_last3", "primitives": ["trimends", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then keep only the last three.", "solution": "def op_trimends_dropzeros_last3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_trimends_dropzeros_last3([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_dropzeros_last3([]) == []\nassert op_trimends_dropzeros_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_dropzeros_last3([5, 5, 5]) == [5]\nassert op_trimends_dropzeros_last3([3, 1, 2]) == [1]\nassert op_trimends_dropzeros_last3([10]) == []\nassert op_trimends_dropzeros_last3([2, 4, 6]) == [4]\nassert op_trimends_dropzeros_last3([-7, 12, -7]) == [12]"}
{"id": "op_neg_square_allpos", "entry_point": "op_neg_square_allpos", "primitives": ["neg", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each, then return whether all values are positive.", "solution": "def op_neg_square_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_neg_square_allpos([1, 2, 3, 4]) == True\nassert op_neg_square_allpos([]) == True\nassert op_neg_square_allpos([-2, -1, 0, 1, 2]) == True\nassert op_neg_square_allpos([5, 5, 5]) == True\nassert op_neg_square_allpos([3, 1, 2]) == True\nassert op_neg_square_allpos([10]) == True\nassert op_neg_square_allpos([2, 4, 6]) == True\nassert op_neg_square_allpos([-7, 12, -7]) == True"}
{"id": "op_double_oremptyzero_pos", "entry_point": "op_double_oremptyzero_pos", "primitives": ["double", "oremptyzero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_double_oremptyzero_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_oremptyzero_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_pos([]) == []\nassert op_double_oremptyzero_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_oremptyzero_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_pos([10]) == [20]\nassert op_double_oremptyzero_pos([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_pos([-7, 12, -7]) == [24]"}
{"id": "op_sortd_div3_negate", "entry_point": "op_sortd_div3_negate", "primitives": ["sortd", "div3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep multiples of three, then negate each.", "solution": "def op_sortd_div3_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_div3_negate([1, 2, 3, 4]) == [-3]\nassert op_sortd_div3_negate([]) == []\nassert op_sortd_div3_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_div3_negate([5, 5, 5]) == []\nassert op_sortd_div3_negate([3, 1, 2]) == [-3]\nassert op_sortd_div3_negate([10]) == []\nassert op_sortd_div3_negate([2, 4, 6]) == [-6]\nassert op_sortd_div3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_div3_sortd_dropzeros", "entry_point": "op_div3_sortd_dropzeros", "primitives": ["div3", "sortd", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending, then drop the zeros.", "solution": "def op_div3_sortd_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_div3_sortd_dropzeros([1, 2, 3, 4]) == [3]\nassert op_div3_sortd_dropzeros([]) == []\nassert op_div3_sortd_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_div3_sortd_dropzeros([5, 5, 5]) == []\nassert op_div3_sortd_dropzeros([3, 1, 2]) == [3]\nassert op_div3_sortd_dropzeros([10]) == []\nassert op_div3_sortd_dropzeros([2, 4, 6]) == [6]\nassert op_div3_sortd_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_strip_prefixup_uniqs", "entry_point": "op_strip_prefixup_uniqs", "primitives": ["strip", "prefixup", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then prefix each with a hash, then drop duplicate strings keeping the first.", "solution": "def op_strip_prefixup_uniqs(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_strip_prefixup_uniqs(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_prefixup_uniqs([]) == []\nassert op_strip_prefixup_uniqs(['  a ', '', 'BC', 'bc']) == ['#a', '#', '#BC', '#bc']\nassert op_strip_prefixup_uniqs(['one', 'one', 'Two']) == ['#one', '#Two']\nassert op_strip_prefixup_uniqs(['x']) == ['#x']\nassert op_strip_prefixup_uniqs(['abc', 'de', '']) == ['#abc', '#de', '#']"}
{"id": "op_odds_rev_neg", "entry_point": "op_odds_rev_neg", "primitives": ["odds", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then keep the negative numbers.", "solution": "def op_odds_rev_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_rev_neg([1, 2, 3, 4]) == []\nassert op_odds_rev_neg([]) == []\nassert op_odds_rev_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_rev_neg([5, 5, 5]) == []\nassert op_odds_rev_neg([3, 1, 2]) == []\nassert op_odds_rev_neg([10]) == []\nassert op_odds_rev_neg([2, 4, 6]) == []\nassert op_odds_rev_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_dropzeros_sorta", "entry_point": "op_uniq_dropzeros_sorta", "primitives": ["uniq", "dropzeros", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then sort ascending.", "solution": "def op_uniq_dropzeros_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_dropzeros_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_dropzeros_sorta([]) == []\nassert op_uniq_dropzeros_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_uniq_dropzeros_sorta([5, 5, 5]) == [5]\nassert op_uniq_dropzeros_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_dropzeros_sorta([10]) == [10]\nassert op_uniq_dropzeros_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_dropzeros_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_oremptyzero_gt5_min", "entry_point": "op_oremptyzero_gt5_min", "primitives": ["oremptyzero", "gt5", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_oremptyzero_gt5_min(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_oremptyzero_gt5_min([1, 2, 3, 4]) == 0\nassert op_oremptyzero_gt5_min([]) == 0\nassert op_oremptyzero_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_gt5_min([5, 5, 5]) == 0\nassert op_oremptyzero_gt5_min([3, 1, 2]) == 0\nassert op_oremptyzero_gt5_min([10]) == 10\nassert op_oremptyzero_gt5_min([2, 4, 6]) == 6\nassert op_oremptyzero_gt5_min([-7, 12, -7]) == 12"}
{"id": "op_negate_absval_gt5", "entry_point": "op_negate_absval_gt5", "primitives": ["negate", "absval", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then keep values greater than five.", "solution": "def op_negate_absval_gt5(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_negate_absval_gt5([1, 2, 3, 4]) == []\nassert op_negate_absval_gt5([]) == []\nassert op_negate_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_negate_absval_gt5([5, 5, 5]) == []\nassert op_negate_absval_gt5([3, 1, 2]) == []\nassert op_negate_absval_gt5([10]) == [10]\nassert op_negate_absval_gt5([2, 4, 6]) == [6]\nassert op_negate_absval_gt5([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_oremptyzero_odds_alldistinct", "entry_point": "op_oremptyzero_odds_alldistinct", "primitives": ["oremptyzero", "odds", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then return whether all values are distinct.", "solution": "def op_oremptyzero_odds_alldistinct(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_oremptyzero_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_oremptyzero_odds_alldistinct([]) == True\nassert op_oremptyzero_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_odds_alldistinct([5, 5, 5]) == False\nassert op_oremptyzero_odds_alldistinct([3, 1, 2]) == True\nassert op_oremptyzero_odds_alldistinct([10]) == True\nassert op_oremptyzero_odds_alldistinct([2, 4, 6]) == True\nassert op_oremptyzero_odds_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_evens_haszero", "entry_point": "op_dropwhileneg_evens_haszero", "primitives": ["dropwhileneg", "evens", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_evens_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return 0 in r", "tests": "assert op_dropwhileneg_evens_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_evens_haszero([]) == False\nassert op_dropwhileneg_evens_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_evens_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_evens_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_evens_haszero([10]) == False\nassert op_dropwhileneg_evens_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_evens_haszero([-7, 12, -7]) == False"}
{"id": "op_neg_first3_evens", "entry_point": "op_neg_first3_evens", "primitives": ["neg", "first3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three, then keep the even numbers.", "solution": "def op_neg_first3_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_first3_evens([1, 2, 3, 4]) == []\nassert op_neg_first3_evens([]) == []\nassert op_neg_first3_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_first3_evens([5, 5, 5]) == []\nassert op_neg_first3_evens([3, 1, 2]) == []\nassert op_neg_first3_evens([10]) == []\nassert op_neg_first3_evens([2, 4, 6]) == []\nassert op_neg_first3_evens([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_oremptyzero_double", "entry_point": "op_dropwhileneg_oremptyzero_double", "primitives": ["dropwhileneg", "oremptyzero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then double each.", "solution": "def op_dropwhileneg_oremptyzero_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_oremptyzero_double([]) == [0]\nassert op_dropwhileneg_oremptyzero_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropwhileneg_oremptyzero_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_oremptyzero_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_oremptyzero_double([10]) == [20]\nassert op_dropwhileneg_oremptyzero_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_oremptyzero_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_names_dropshort_firstchar", "entry_point": "op_names_dropshort_firstchar", "primitives": ["names", "dropshort", "firstchar"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop strings shorter than three characters, then keep the first character of each (dropping empties).", "solution": "def op_names_dropshort_firstchar(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_names_dropshort_firstchar([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['A']\nassert op_names_dropshort_firstchar([]) == []\nassert op_names_dropshort_firstchar([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['D']\nassert op_names_dropshort_firstchar([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dropfirst_takewhilepos_sorta", "entry_point": "op_dropfirst_takewhilepos_sorta", "primitives": ["dropfirst", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then sort ascending.", "solution": "def op_dropfirst_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_dropfirst_takewhilepos_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_takewhilepos_sorta([]) == []\nassert op_dropfirst_takewhilepos_sorta([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_takewhilepos_sorta([5, 5, 5]) == [5, 5]\nassert op_dropfirst_takewhilepos_sorta([3, 1, 2]) == [1, 2]\nassert op_dropfirst_takewhilepos_sorta([10]) == []\nassert op_dropfirst_takewhilepos_sorta([2, 4, 6]) == [4, 6]\nassert op_dropfirst_takewhilepos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_pos_odds_prod", "entry_point": "op_pos_odds_prod", "primitives": ["pos", "odds", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then return their product.", "solution": "def op_pos_odds_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return __import__('math').prod(r)", "tests": "assert op_pos_odds_prod([1, 2, 3, 4]) == 3\nassert op_pos_odds_prod([]) == 1\nassert op_pos_odds_prod([-2, -1, 0, 1, 2]) == 1\nassert op_pos_odds_prod([5, 5, 5]) == 125\nassert op_pos_odds_prod([3, 1, 2]) == 3\nassert op_pos_odds_prod([10]) == 1\nassert op_pos_odds_prod([2, 4, 6]) == 1\nassert op_pos_odds_prod([-7, 12, -7]) == 1"}
{"id": "op_dec_evens_anyeven", "entry_point": "op_dec_evens_anyeven", "primitives": ["dec", "evens", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then return whether any value is even.", "solution": "def op_dec_evens_anyeven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dec_evens_anyeven([1, 2, 3, 4]) == True\nassert op_dec_evens_anyeven([]) == False\nassert op_dec_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dec_evens_anyeven([5, 5, 5]) == True\nassert op_dec_evens_anyeven([3, 1, 2]) == True\nassert op_dec_evens_anyeven([10]) == False\nassert op_dec_evens_anyeven([2, 4, 6]) == False\nassert op_dec_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_dec_oremptyzero_negate", "entry_point": "op_dec_oremptyzero_negate", "primitives": ["dec", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then negate each.", "solution": "def op_dec_oremptyzero_negate(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dec_oremptyzero_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_dec_oremptyzero_negate([]) == [0]\nassert op_dec_oremptyzero_negate([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_dec_oremptyzero_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_oremptyzero_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_dec_oremptyzero_negate([10]) == [-9]\nassert op_dec_oremptyzero_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_oremptyzero_negate([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_dropzeros_sortd_first3", "entry_point": "op_dropzeros_sortd_first3", "primitives": ["dropzeros", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending, then keep only the first three.", "solution": "def op_dropzeros_sortd_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_sortd_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropzeros_sortd_first3([]) == []\nassert op_dropzeros_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_dropzeros_sortd_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortd_first3([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_sortd_first3([10]) == [10]\nassert op_dropzeros_sortd_first3([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_sortd_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_negate_odds_dec", "entry_point": "op_negate_odds_dec", "primitives": ["negate", "odds", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then subtract one from each.", "solution": "def op_negate_odds_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_odds_dec([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_odds_dec([]) == []\nassert op_negate_odds_dec([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_negate_odds_dec([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_odds_dec([3, 1, 2]) == [-4, -2]\nassert op_negate_odds_dec([10]) == []\nassert op_negate_odds_dec([2, 4, 6]) == []\nassert op_negate_odds_dec([-7, 12, -7]) == [6, 6]"}
{"id": "op_sortabs_div3_prod", "entry_point": "op_sortabs_div3_prod", "primitives": ["sortabs", "div3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then return their product.", "solution": "def op_sortabs_div3_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_div3_prod([1, 2, 3, 4]) == 3\nassert op_sortabs_div3_prod([]) == 1\nassert op_sortabs_div3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_div3_prod([5, 5, 5]) == 1\nassert op_sortabs_div3_prod([3, 1, 2]) == 3\nassert op_sortabs_div3_prod([10]) == 1\nassert op_sortabs_div3_prod([2, 4, 6]) == 6\nassert op_sortabs_div3_prod([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_sortabs_firsteven", "entry_point": "op_takewhilepos_sortabs_firsteven", "primitives": ["takewhilepos", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_takewhilepos_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_sortabs_firsteven([]) == 0\nassert op_takewhilepos_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sortabs_firsteven([5, 5, 5]) == 0\nassert op_takewhilepos_sortabs_firsteven([3, 1, 2]) == 2\nassert op_takewhilepos_sortabs_firsteven([10]) == 10\nassert op_takewhilepos_sortabs_firsteven([2, 4, 6]) == 2\nassert op_takewhilepos_sortabs_firsteven([-7, 12, -7]) == 0"}
{"id": "op_square_dropwhileneg_first3", "entry_point": "op_square_dropwhileneg_first3", "primitives": ["square", "dropwhileneg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then keep only the first three.", "solution": "def op_square_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_square_dropwhileneg_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_square_dropwhileneg_first3([]) == []\nassert op_square_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_dropwhileneg_first3([5, 5, 5]) == [25, 25, 25]\nassert op_square_dropwhileneg_first3([3, 1, 2]) == [9, 1, 4]\nassert op_square_dropwhileneg_first3([10]) == [100]\nassert op_square_dropwhileneg_first3([2, 4, 6]) == [4, 16, 36]\nassert op_square_dropwhileneg_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_double_sortd_min", "entry_point": "op_double_sortd_min", "primitives": ["double", "sortd", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending, then return the minimum (0 if empty).", "solution": "def op_double_sortd_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_double_sortd_min([1, 2, 3, 4]) == 2\nassert op_double_sortd_min([]) == 0\nassert op_double_sortd_min([-2, -1, 0, 1, 2]) == -4\nassert op_double_sortd_min([5, 5, 5]) == 10\nassert op_double_sortd_min([3, 1, 2]) == 2\nassert op_double_sortd_min([10]) == 20\nassert op_double_sortd_min([2, 4, 6]) == 4\nassert op_double_sortd_min([-7, 12, -7]) == -14"}
{"id": "op_last3_inc_odds", "entry_point": "op_last3_inc_odds", "primitives": ["last3", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then keep the odd numbers.", "solution": "def op_last3_inc_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_inc_odds([1, 2, 3, 4]) == [3, 5]\nassert op_last3_inc_odds([]) == []\nassert op_last3_inc_odds([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_last3_inc_odds([5, 5, 5]) == []\nassert op_last3_inc_odds([3, 1, 2]) == [3]\nassert op_last3_inc_odds([10]) == [11]\nassert op_last3_inc_odds([2, 4, 6]) == [3, 5, 7]\nassert op_last3_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_dropwhileneg_sortd_anyeven", "entry_point": "op_dropwhileneg_sortd_anyeven", "primitives": ["dropwhileneg", "sortd", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending, then return whether any value is even.", "solution": "def op_dropwhileneg_sortd_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_sortd_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_sortd_anyeven([]) == False\nassert op_dropwhileneg_sortd_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_sortd_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_sortd_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_sortd_anyeven([10]) == True\nassert op_dropwhileneg_sortd_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_sortd_anyeven([-7, 12, -7]) == True"}
{"id": "op_pos_odds_last3", "entry_point": "op_pos_odds_last3", "primitives": ["pos", "odds", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then keep only the last three.", "solution": "def op_pos_odds_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_pos_odds_last3([1, 2, 3, 4]) == [1, 3]\nassert op_pos_odds_last3([]) == []\nassert op_pos_odds_last3([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_odds_last3([5, 5, 5]) == [5, 5, 5]\nassert op_pos_odds_last3([3, 1, 2]) == [3, 1]\nassert op_pos_odds_last3([10]) == []\nassert op_pos_odds_last3([2, 4, 6]) == []\nassert op_pos_odds_last3([-7, 12, -7]) == []"}
{"id": "op_add10_first3_sorta", "entry_point": "op_add10_first3_sorta", "primitives": ["add10", "first3", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then sort ascending.", "solution": "def op_add10_first3_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_add10_first3_sorta([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_first3_sorta([]) == []\nassert op_add10_first3_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_first3_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_first3_sorta([10]) == [20]\nassert op_add10_first3_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_first3_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_gt5_dropwhileneg_firsteven", "entry_point": "op_gt5_dropwhileneg_firsteven", "primitives": ["gt5", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_gt5_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_dropwhileneg_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_dropwhileneg_firsteven([]) == 0\nassert op_gt5_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_gt5_dropwhileneg_firsteven([3, 1, 2]) == 0\nassert op_gt5_dropwhileneg_firsteven([10]) == 10\nassert op_gt5_dropwhileneg_firsteven([2, 4, 6]) == 6\nassert op_gt5_dropwhileneg_firsteven([-7, 12, -7]) == 12"}
{"id": "op_add10_beforezero_rev", "entry_point": "op_add10_beforezero_rev", "primitives": ["add10", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero, then reverse the order.", "solution": "def op_add10_beforezero_rev(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_add10_beforezero_rev([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_beforezero_rev([]) == []\nassert op_add10_beforezero_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_beforezero_rev([5, 5, 5]) == [15, 15, 15]\nassert op_add10_beforezero_rev([3, 1, 2]) == [12, 11, 13]\nassert op_add10_beforezero_rev([10]) == [20]\nassert op_add10_beforezero_rev([2, 4, 6]) == [16, 14, 12]\nassert op_add10_beforezero_rev([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_padto3_div3_dropzeros", "entry_point": "op_padto3_div3_dropzeros", "primitives": ["padto3", "div3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep multiples of three, then drop the zeros.", "solution": "def op_padto3_div3_dropzeros(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_padto3_div3_dropzeros([1, 2, 3, 4]) == [3]\nassert op_padto3_div3_dropzeros([]) == []\nassert op_padto3_div3_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_padto3_div3_dropzeros([5, 5, 5]) == []\nassert op_padto3_div3_dropzeros([3, 1, 2]) == [3]\nassert op_padto3_div3_dropzeros([10]) == []\nassert op_padto3_div3_dropzeros([2, 4, 6]) == [6]\nassert op_padto3_div3_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_trimends_first3_issorted", "entry_point": "op_trimends_first3_issorted", "primitives": ["trimends", "first3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_trimends_first3_issorted(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_trimends_first3_issorted([1, 2, 3, 4]) == True\nassert op_trimends_first3_issorted([]) == True\nassert op_trimends_first3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_trimends_first3_issorted([5, 5, 5]) == True\nassert op_trimends_first3_issorted([3, 1, 2]) == True\nassert op_trimends_first3_issorted([10]) == True\nassert op_trimends_first3_issorted([2, 4, 6]) == True\nassert op_trimends_first3_issorted([-7, 12, -7]) == True"}
{"id": "op_double_pos_dec", "entry_point": "op_double_pos_dec", "primitives": ["double", "pos", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then subtract one from each.", "solution": "def op_double_pos_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_pos_dec([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_double_pos_dec([]) == []\nassert op_double_pos_dec([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_double_pos_dec([5, 5, 5]) == [9, 9, 9]\nassert op_double_pos_dec([3, 1, 2]) == [5, 1, 3]\nassert op_double_pos_dec([10]) == [19]\nassert op_double_pos_dec([2, 4, 6]) == [3, 7, 11]\nassert op_double_pos_dec([-7, 12, -7]) == [23]"}
{"id": "op_add10_padto3_sortabs", "entry_point": "op_add10_padto3_sortabs", "primitives": ["add10", "padto3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_add10_padto3_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_padto3_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_padto3_sortabs([]) == [0, 0, 0]\nassert op_add10_padto3_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_padto3_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_padto3_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_add10_padto3_sortabs([10]) == [0, 0, 20]\nassert op_add10_padto3_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_add10_padto3_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_beforezero_double_first3", "entry_point": "op_beforezero_double_first3", "primitives": ["beforezero", "double", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then keep only the first three.", "solution": "def op_beforezero_double_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_double_first3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_beforezero_double_first3([]) == []\nassert op_beforezero_double_first3([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_beforezero_double_first3([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_double_first3([3, 1, 2]) == [6, 2, 4]\nassert op_beforezero_double_first3([10]) == [20]\nassert op_beforezero_double_first3([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_double_first3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_beforezero_gt5_negate", "entry_point": "op_beforezero_gt5_negate", "primitives": ["beforezero", "gt5", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then negate each.", "solution": "def op_beforezero_gt5_negate(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return r", "tests": "assert op_beforezero_gt5_negate([1, 2, 3, 4]) == []\nassert op_beforezero_gt5_negate([]) == []\nassert op_beforezero_gt5_negate([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5_negate([5, 5, 5]) == []\nassert op_beforezero_gt5_negate([3, 1, 2]) == []\nassert op_beforezero_gt5_negate([10]) == [-10]\nassert op_beforezero_gt5_negate([2, 4, 6]) == [-6]\nassert op_beforezero_gt5_negate([-7, 12, -7]) == [-12]"}
{"id": "op_gt5_inc_sortabs", "entry_point": "op_gt5_inc_sortabs", "primitives": ["gt5", "inc", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then sort by absolute value.", "solution": "def op_gt5_inc_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_gt5_inc_sortabs([1, 2, 3, 4]) == []\nassert op_gt5_inc_sortabs([]) == []\nassert op_gt5_inc_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_sortabs([5, 5, 5]) == []\nassert op_gt5_inc_sortabs([3, 1, 2]) == []\nassert op_gt5_inc_sortabs([10]) == [11]\nassert op_gt5_inc_sortabs([2, 4, 6]) == [7]\nassert op_gt5_inc_sortabs([-7, 12, -7]) == [13]"}
{"id": "op_div3_double_trimends", "entry_point": "op_div3_double_trimends", "primitives": ["div3", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then drop the first and last elements.", "solution": "def op_div3_double_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_double_trimends([1, 2, 3, 4]) == []\nassert op_div3_double_trimends([]) == []\nassert op_div3_double_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_trimends([5, 5, 5]) == []\nassert op_div3_double_trimends([3, 1, 2]) == []\nassert op_div3_double_trimends([10]) == []\nassert op_div3_double_trimends([2, 4, 6]) == []\nassert op_div3_double_trimends([-7, 12, -7]) == []"}
{"id": "op_uniq_negate_allpos", "entry_point": "op_uniq_negate_allpos", "primitives": ["uniq", "negate", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then return whether all values are positive.", "solution": "def op_uniq_negate_allpos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_uniq_negate_allpos([1, 2, 3, 4]) == False\nassert op_uniq_negate_allpos([]) == True\nassert op_uniq_negate_allpos([-2, -1, 0, 1, 2]) == False\nassert op_uniq_negate_allpos([5, 5, 5]) == False\nassert op_uniq_negate_allpos([3, 1, 2]) == False\nassert op_uniq_negate_allpos([10]) == False\nassert op_uniq_negate_allpos([2, 4, 6]) == False\nassert op_uniq_negate_allpos([-7, 12, -7]) == False"}
{"id": "op_ages_dropwhileneg_rev", "entry_point": "op_ages_dropwhileneg_rev", "primitives": ["ages", "dropwhileneg", "rev"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then reverse the order.", "solution": "def op_ages_dropwhileneg_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_dropwhileneg_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_dropwhileneg_rev([]) == []\nassert op_ages_dropwhileneg_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_dropwhileneg_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_ages_absval_sum", "entry_point": "op_ages_absval_sum", "primitives": ["ages", "absval", "sum"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then return their sum.", "solution": "def op_ages_absval_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_ages_absval_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 48\nassert op_ages_absval_sum([]) == 0\nassert op_ages_absval_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 100\nassert op_ages_absval_sum([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_odds_uniq_len", "entry_point": "op_odds_uniq_len", "primitives": ["odds", "uniq", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_odds_uniq_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_odds_uniq_len([1, 2, 3, 4]) == 2\nassert op_odds_uniq_len([]) == 0\nassert op_odds_uniq_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_uniq_len([5, 5, 5]) == 1\nassert op_odds_uniq_len([3, 1, 2]) == 2\nassert op_odds_uniq_len([10]) == 0\nassert op_odds_uniq_len([2, 4, 6]) == 0\nassert op_odds_uniq_len([-7, 12, -7]) == 1"}
{"id": "op_first3_sorta_dropzeros", "entry_point": "op_first3_sorta_dropzeros", "primitives": ["first3", "sorta", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then drop the zeros.", "solution": "def op_first3_sorta_dropzeros(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_first3_sorta_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta_dropzeros([]) == []\nassert op_first3_sorta_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_sorta_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta_dropzeros([10]) == [10]\nassert op_first3_sorta_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_odds_uniq", "entry_point": "op_beforezero_odds_uniq", "primitives": ["beforezero", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_odds_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_beforezero_odds_uniq([]) == []\nassert op_beforezero_odds_uniq([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_odds_uniq([5, 5, 5]) == [5]\nassert op_beforezero_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_beforezero_odds_uniq([10]) == []\nassert op_beforezero_odds_uniq([2, 4, 6]) == []\nassert op_beforezero_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_ages_first3_rev", "entry_point": "op_ages_first3_rev", "primitives": ["ages", "first3", "rev"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then reverse the order.", "solution": "def op_ages_first3_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_first3_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_first3_rev([]) == []\nassert op_ages_first3_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_first3_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_oremptyzero_trimends_allpos", "entry_point": "op_oremptyzero_trimends_allpos", "primitives": ["oremptyzero", "trimends", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_oremptyzero_trimends_allpos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_oremptyzero_trimends_allpos([1, 2, 3, 4]) == True\nassert op_oremptyzero_trimends_allpos([]) == True\nassert op_oremptyzero_trimends_allpos([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_trimends_allpos([5, 5, 5]) == True\nassert op_oremptyzero_trimends_allpos([3, 1, 2]) == True\nassert op_oremptyzero_trimends_allpos([10]) == True\nassert op_oremptyzero_trimends_allpos([2, 4, 6]) == True\nassert op_oremptyzero_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_odds_pos_uniq", "entry_point": "op_odds_pos_uniq", "primitives": ["odds", "pos", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then drop duplicates keeping first occurrence.", "solution": "def op_odds_pos_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_odds_pos_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_odds_pos_uniq([]) == []\nassert op_odds_pos_uniq([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos_uniq([5, 5, 5]) == [5]\nassert op_odds_pos_uniq([3, 1, 2]) == [3, 1]\nassert op_odds_pos_uniq([10]) == []\nassert op_odds_pos_uniq([2, 4, 6]) == []\nassert op_odds_pos_uniq([-7, 12, -7]) == []"}
{"id": "op_absval_inc_padto3", "entry_point": "op_absval_inc_padto3", "primitives": ["absval", "inc", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add one to each, then pad with zeros to at least three elements.", "solution": "def op_absval_inc_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_inc_padto3([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_inc_padto3([]) == [0, 0, 0]\nassert op_absval_inc_padto3([-2, -1, 0, 1, 2]) == [3, 2, 1, 2, 3]\nassert op_absval_inc_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_absval_inc_padto3([3, 1, 2]) == [4, 2, 3]\nassert op_absval_inc_padto3([10]) == [11, 0, 0]\nassert op_absval_inc_padto3([2, 4, 6]) == [3, 5, 7]\nassert op_absval_inc_padto3([-7, 12, -7]) == [8, 13, 8]"}
{"id": "op_takewhilepos_oremptyzero_double", "entry_point": "op_takewhilepos_oremptyzero_double", "primitives": ["takewhilepos", "oremptyzero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then double each.", "solution": "def op_takewhilepos_oremptyzero_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_oremptyzero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_oremptyzero_double([]) == [0]\nassert op_takewhilepos_oremptyzero_double([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_oremptyzero_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_oremptyzero_double([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_oremptyzero_double([10]) == [20]\nassert op_takewhilepos_oremptyzero_double([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_oremptyzero_double([-7, 12, -7]) == [0]"}
{"id": "op_last3_takewhilepos_firsteven", "entry_point": "op_last3_takewhilepos_firsteven", "primitives": ["last3", "takewhilepos", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_last3_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_last3_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_last3_takewhilepos_firsteven([]) == 0\nassert op_last3_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_last3_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_last3_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_last3_takewhilepos_firsteven([10]) == 10\nassert op_last3_takewhilepos_firsteven([2, 4, 6]) == 2\nassert op_last3_takewhilepos_firsteven([-7, 12, -7]) == 0"}
{"id": "op_clamp10_absval_oremptyzero", "entry_point": "op_clamp10_absval_oremptyzero", "primitives": ["clamp10", "absval", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_clamp10_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_absval_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_absval_oremptyzero([]) == [0]\nassert op_clamp10_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_absval_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_absval_oremptyzero([10]) == [10]\nassert op_clamp10_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_absval_oremptyzero([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_dropfirst_beforezero_double", "entry_point": "op_dropfirst_beforezero_double", "primitives": ["dropfirst", "beforezero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then double each.", "solution": "def op_dropfirst_beforezero_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_beforezero_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropfirst_beforezero_double([]) == []\nassert op_dropfirst_beforezero_double([-2, -1, 0, 1, 2]) == [-2]\nassert op_dropfirst_beforezero_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_beforezero_double([3, 1, 2]) == [2, 4]\nassert op_dropfirst_beforezero_double([10]) == []\nassert op_dropfirst_beforezero_double([2, 4, 6]) == [8, 12]\nassert op_dropfirst_beforezero_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_ages_takewhilepos_last3", "entry_point": "op_ages_takewhilepos_last3", "primitives": ["ages", "takewhilepos", "last3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then keep only the last three.", "solution": "def op_ages_takewhilepos_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_takewhilepos_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos_last3([]) == []\nassert op_ages_takewhilepos_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos_last3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_last3_neg_rev", "entry_point": "op_last3_neg_rev", "primitives": ["last3", "neg", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then reverse the order.", "solution": "def op_last3_neg_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_neg_rev([1, 2, 3, 4]) == []\nassert op_last3_neg_rev([]) == []\nassert op_last3_neg_rev([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_rev([5, 5, 5]) == []\nassert op_last3_neg_rev([3, 1, 2]) == []\nassert op_last3_neg_rev([10]) == []\nassert op_last3_neg_rev([2, 4, 6]) == []\nassert op_last3_neg_rev([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_add10_rev", "entry_point": "op_neg_add10_rev", "primitives": ["neg", "add10", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then reverse the order.", "solution": "def op_neg_add10_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_neg_add10_rev([1, 2, 3, 4]) == []\nassert op_neg_add10_rev([]) == []\nassert op_neg_add10_rev([-2, -1, 0, 1, 2]) == [9, 8]\nassert op_neg_add10_rev([5, 5, 5]) == []\nassert op_neg_add10_rev([3, 1, 2]) == []\nassert op_neg_add10_rev([10]) == []\nassert op_neg_add10_rev([2, 4, 6]) == []\nassert op_neg_add10_rev([-7, 12, -7]) == [3, 3]"}
{"id": "op_first3_trimends_evens", "entry_point": "op_first3_trimends_evens", "primitives": ["first3", "trimends", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then keep the even numbers.", "solution": "def op_first3_trimends_evens(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_first3_trimends_evens([1, 2, 3, 4]) == [2]\nassert op_first3_trimends_evens([]) == []\nassert op_first3_trimends_evens([-2, -1, 0, 1, 2]) == []\nassert op_first3_trimends_evens([5, 5, 5]) == []\nassert op_first3_trimends_evens([3, 1, 2]) == []\nassert op_first3_trimends_evens([10]) == []\nassert op_first3_trimends_evens([2, 4, 6]) == [4]\nassert op_first3_trimends_evens([-7, 12, -7]) == [12]"}
{"id": "op_first3_odds_neg", "entry_point": "op_first3_odds_neg", "primitives": ["first3", "odds", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then keep the negative numbers.", "solution": "def op_first3_odds_neg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_first3_odds_neg([1, 2, 3, 4]) == []\nassert op_first3_odds_neg([]) == []\nassert op_first3_odds_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_odds_neg([5, 5, 5]) == []\nassert op_first3_odds_neg([3, 1, 2]) == []\nassert op_first3_odds_neg([10]) == []\nassert op_first3_odds_neg([2, 4, 6]) == []\nassert op_first3_odds_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_padto3_takewhilepos_alldistinct", "entry_point": "op_padto3_takewhilepos_alldistinct", "primitives": ["padto3", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_padto3_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_padto3_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_padto3_takewhilepos_alldistinct([]) == True\nassert op_padto3_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_padto3_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_padto3_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_padto3_takewhilepos_alldistinct([10]) == True\nassert op_padto3_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_padto3_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_inc_dropzeros_last3", "entry_point": "op_inc_dropzeros_last3", "primitives": ["inc", "dropzeros", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then keep only the last three.", "solution": "def op_inc_dropzeros_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_dropzeros_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_dropzeros_last3([]) == []\nassert op_inc_dropzeros_last3([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_dropzeros_last3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_dropzeros_last3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_dropzeros_last3([10]) == [11]\nassert op_inc_dropzeros_last3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_dropzeros_last3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_padto3_takewhilepos_dropwhileneg", "entry_point": "op_padto3_takewhilepos_dropwhileneg", "primitives": ["padto3", "takewhilepos", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then drop the leading negative values.", "solution": "def op_padto3_takewhilepos_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_takewhilepos_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_takewhilepos_dropwhileneg([]) == []\nassert op_padto3_takewhilepos_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos_dropwhileneg([10]) == [10]\nassert op_padto3_takewhilepos_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_ages_beforezero_dropzeros", "entry_point": "op_ages_beforezero_dropzeros", "primitives": ["ages", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then drop the zeros.", "solution": "def op_ages_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_beforezero_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_beforezero_dropzeros([]) == []\nassert op_ages_beforezero_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_beforezero_dropzeros([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_trimends_neg_allpos", "entry_point": "op_trimends_neg_allpos", "primitives": ["trimends", "neg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then return whether all values are positive.", "solution": "def op_trimends_neg_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_neg_allpos([1, 2, 3, 4]) == True\nassert op_trimends_neg_allpos([]) == True\nassert op_trimends_neg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_neg_allpos([5, 5, 5]) == True\nassert op_trimends_neg_allpos([3, 1, 2]) == True\nassert op_trimends_neg_allpos([10]) == True\nassert op_trimends_neg_allpos([2, 4, 6]) == True\nassert op_trimends_neg_allpos([-7, 12, -7]) == True"}
{"id": "op_double_trimends_dropzeros", "entry_point": "op_double_trimends_dropzeros", "primitives": ["double", "trimends", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then drop the zeros.", "solution": "def op_double_trimends_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_trimends_dropzeros([1, 2, 3, 4]) == [4, 6]\nassert op_double_trimends_dropzeros([]) == []\nassert op_double_trimends_dropzeros([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_double_trimends_dropzeros([5, 5, 5]) == [10]\nassert op_double_trimends_dropzeros([3, 1, 2]) == [2]\nassert op_double_trimends_dropzeros([10]) == []\nassert op_double_trimends_dropzeros([2, 4, 6]) == [8]\nassert op_double_trimends_dropzeros([-7, 12, -7]) == [24]"}
{"id": "op_div3_sortd_trimends", "entry_point": "op_div3_sortd_trimends", "primitives": ["div3", "sortd", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending, then drop the first and last elements.", "solution": "def op_div3_sortd_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_sortd_trimends([1, 2, 3, 4]) == []\nassert op_div3_sortd_trimends([]) == []\nassert op_div3_sortd_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_sortd_trimends([5, 5, 5]) == []\nassert op_div3_sortd_trimends([3, 1, 2]) == []\nassert op_div3_sortd_trimends([10]) == []\nassert op_div3_sortd_trimends([2, 4, 6]) == []\nassert op_div3_sortd_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_sortd_square", "entry_point": "op_sorta_sortd_square", "primitives": ["sorta", "sortd", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then square each.", "solution": "def op_sorta_sortd_square(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sorta_sortd_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sorta_sortd_square([]) == []\nassert op_sorta_sortd_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sorta_sortd_square([5, 5, 5]) == [25, 25, 25]\nassert op_sorta_sortd_square([3, 1, 2]) == [9, 4, 1]\nassert op_sorta_sortd_square([10]) == [100]\nassert op_sorta_sortd_square([2, 4, 6]) == [36, 16, 4]\nassert op_sorta_sortd_square([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_dec_pos_dropfirst", "entry_point": "op_dec_pos_dropfirst", "primitives": ["dec", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then drop the first element.", "solution": "def op_dec_pos_dropfirst(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_dec_pos_dropfirst([1, 2, 3, 4]) == [2, 3]\nassert op_dec_pos_dropfirst([]) == []\nassert op_dec_pos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_dec_pos_dropfirst([5, 5, 5]) == [4, 4]\nassert op_dec_pos_dropfirst([3, 1, 2]) == [1]\nassert op_dec_pos_dropfirst([10]) == []\nassert op_dec_pos_dropfirst([2, 4, 6]) == [3, 5]\nassert op_dec_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_neg_negate_dropzeros", "entry_point": "op_neg_negate_dropzeros", "primitives": ["neg", "negate", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then drop the zeros.", "solution": "def op_neg_negate_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_neg_negate_dropzeros([1, 2, 3, 4]) == []\nassert op_neg_negate_dropzeros([]) == []\nassert op_neg_negate_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_negate_dropzeros([5, 5, 5]) == []\nassert op_neg_negate_dropzeros([3, 1, 2]) == []\nassert op_neg_negate_dropzeros([10]) == []\nassert op_neg_negate_dropzeros([2, 4, 6]) == []\nassert op_neg_negate_dropzeros([-7, 12, -7]) == [7, 7]"}
{"id": "op_neg_padto3_allpos", "entry_point": "op_neg_padto3_allpos", "primitives": ["neg", "padto3", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then pad with zeros to at least three elements, then return whether all values are positive.", "solution": "def op_neg_padto3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return all(x > 0 for x in r)", "tests": "assert op_neg_padto3_allpos([1, 2, 3, 4]) == False\nassert op_neg_padto3_allpos([]) == False\nassert op_neg_padto3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_neg_padto3_allpos([5, 5, 5]) == False\nassert op_neg_padto3_allpos([3, 1, 2]) == False\nassert op_neg_padto3_allpos([10]) == False\nassert op_neg_padto3_allpos([2, 4, 6]) == False\nassert op_neg_padto3_allpos([-7, 12, -7]) == False"}
{"id": "op_clamp10_dropfirst_add10", "entry_point": "op_clamp10_dropfirst_add10", "primitives": ["clamp10", "dropfirst", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element, then add ten to each.", "solution": "def op_clamp10_dropfirst_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_dropfirst_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_clamp10_dropfirst_add10([]) == []\nassert op_clamp10_dropfirst_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_clamp10_dropfirst_add10([5, 5, 5]) == [15, 15]\nassert op_clamp10_dropfirst_add10([3, 1, 2]) == [11, 12]\nassert op_clamp10_dropfirst_add10([10]) == []\nassert op_clamp10_dropfirst_add10([2, 4, 6]) == [14, 16]\nassert op_clamp10_dropfirst_add10([-7, 12, -7]) == [20, 3]"}
{"id": "op_clamp10_dec_haszero", "entry_point": "op_clamp10_dec_haszero", "primitives": ["clamp10", "dec", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_clamp10_dec_haszero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_clamp10_dec_haszero([1, 2, 3, 4]) == True\nassert op_clamp10_dec_haszero([]) == False\nassert op_clamp10_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_dec_haszero([5, 5, 5]) == False\nassert op_clamp10_dec_haszero([3, 1, 2]) == True\nassert op_clamp10_dec_haszero([10]) == False\nassert op_clamp10_dec_haszero([2, 4, 6]) == False\nassert op_clamp10_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_lower_upper_sortalpha", "entry_point": "op_lower_upper_sortalpha", "primitives": ["lower", "upper", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then uppercase each string, then sort alphabetically.", "solution": "def op_lower_upper_sortalpha(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_lower_upper_sortalpha(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_lower_upper_sortalpha([]) == []\nassert op_lower_upper_sortalpha(['  a ', '', 'BC', 'bc']) == ['', '  A ', 'BC', 'BC']\nassert op_lower_upper_sortalpha(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_lower_upper_sortalpha(['x']) == ['X']\nassert op_lower_upper_sortalpha(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_negate_pos_trimends", "entry_point": "op_negate_pos_trimends", "primitives": ["negate", "pos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_negate_pos_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_pos_trimends([1, 2, 3, 4]) == []\nassert op_negate_pos_trimends([]) == []\nassert op_negate_pos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_negate_pos_trimends([5, 5, 5]) == []\nassert op_negate_pos_trimends([3, 1, 2]) == []\nassert op_negate_pos_trimends([10]) == []\nassert op_negate_pos_trimends([2, 4, 6]) == []\nassert op_negate_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_negate_dropfirst", "entry_point": "op_add10_negate_dropfirst", "primitives": ["add10", "negate", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each, then drop the first element.", "solution": "def op_add10_negate_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_add10_negate_dropfirst([1, 2, 3, 4]) == [-12, -13, -14]\nassert op_add10_negate_dropfirst([]) == []\nassert op_add10_negate_dropfirst([-2, -1, 0, 1, 2]) == [-9, -10, -11, -12]\nassert op_add10_negate_dropfirst([5, 5, 5]) == [-15, -15]\nassert op_add10_negate_dropfirst([3, 1, 2]) == [-11, -12]\nassert op_add10_negate_dropfirst([10]) == []\nassert op_add10_negate_dropfirst([2, 4, 6]) == [-14, -16]\nassert op_add10_negate_dropfirst([-7, 12, -7]) == [-22, -3]"}
{"id": "op_odds_oremptyzero_sortd", "entry_point": "op_odds_oremptyzero_sortd", "primitives": ["odds", "oremptyzero", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero, then sort descending.", "solution": "def op_odds_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_oremptyzero_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_odds_oremptyzero_sortd([]) == [0]\nassert op_odds_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_oremptyzero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_odds_oremptyzero_sortd([3, 1, 2]) == [3, 1]\nassert op_odds_oremptyzero_sortd([10]) == [0]\nassert op_odds_oremptyzero_sortd([2, 4, 6]) == [0]\nassert op_odds_oremptyzero_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_odds_dropfirst", "entry_point": "op_div3_odds_dropfirst", "primitives": ["div3", "odds", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then drop the first element.", "solution": "def op_div3_odds_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_div3_odds_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_odds_dropfirst([]) == []\nassert op_div3_odds_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_dropfirst([5, 5, 5]) == []\nassert op_div3_odds_dropfirst([3, 1, 2]) == []\nassert op_div3_odds_dropfirst([10]) == []\nassert op_div3_odds_dropfirst([2, 4, 6]) == []\nassert op_div3_odds_dropfirst([-7, 12, -7]) == []"}
{"id": "op_last3_square_evens", "entry_point": "op_last3_square_evens", "primitives": ["last3", "square", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then keep the even numbers.", "solution": "def op_last3_square_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_square_evens([1, 2, 3, 4]) == [4, 16]\nassert op_last3_square_evens([]) == []\nassert op_last3_square_evens([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_last3_square_evens([5, 5, 5]) == []\nassert op_last3_square_evens([3, 1, 2]) == [4]\nassert op_last3_square_evens([10]) == [100]\nassert op_last3_square_evens([2, 4, 6]) == [4, 16, 36]\nassert op_last3_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_beforezero_dropwhileneg_takewhilepos", "entry_point": "op_beforezero_dropwhileneg_takewhilepos", "primitives": ["beforezero", "dropwhileneg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the leading negative values, then take values while they are positive.", "solution": "def op_beforezero_dropwhileneg_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_dropwhileneg_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_dropwhileneg_takewhilepos([]) == []\nassert op_beforezero_dropwhileneg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_dropwhileneg_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_dropwhileneg_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_dropwhileneg_takewhilepos([10]) == [10]\nassert op_beforezero_dropwhileneg_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_dropwhileneg_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_padto3_rev", "entry_point": "op_uniq_padto3_rev", "primitives": ["uniq", "padto3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_uniq_padto3_rev(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_uniq_padto3_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_padto3_rev([]) == [0, 0, 0]\nassert op_uniq_padto3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_padto3_rev([5, 5, 5]) == [0, 0, 5]\nassert op_uniq_padto3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_uniq_padto3_rev([10]) == [0, 0, 10]\nassert op_uniq_padto3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_padto3_rev([-7, 12, -7]) == [0, 12, -7]"}
{"id": "op_ages_evens_sorta", "entry_point": "op_ages_evens_sorta", "primitives": ["ages", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then sort ascending.", "solution": "def op_ages_evens_sorta(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_ages_evens_sorta([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_evens_sorta([]) == []\nassert op_ages_evens_sorta([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens_sorta([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_nonempty_prefixup_sortlen", "entry_point": "op_nonempty_prefixup_sortlen", "primitives": ["nonempty", "prefixup", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then prefix each with a hash, then sort by length, shortest first.", "solution": "def op_nonempty_prefixup_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_nonempty_prefixup_sortlen(['Hello', 'world']) == ['#Hello', '#world']\nassert op_nonempty_prefixup_sortlen([]) == []\nassert op_nonempty_prefixup_sortlen(['  a ', '', 'BC', 'bc']) == ['#BC', '#bc', '#  a ']\nassert op_nonempty_prefixup_sortlen(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_nonempty_prefixup_sortlen(['x']) == ['#x']\nassert op_nonempty_prefixup_sortlen(['abc', 'de', '']) == ['#de', '#abc']"}
{"id": "op_trimends_evens_odds", "entry_point": "op_trimends_evens_odds", "primitives": ["trimends", "evens", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then keep the odd numbers.", "solution": "def op_trimends_evens_odds(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_trimends_evens_odds([1, 2, 3, 4]) == []\nassert op_trimends_evens_odds([]) == []\nassert op_trimends_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_trimends_evens_odds([5, 5, 5]) == []\nassert op_trimends_evens_odds([3, 1, 2]) == []\nassert op_trimends_evens_odds([10]) == []\nassert op_trimends_evens_odds([2, 4, 6]) == []\nassert op_trimends_evens_odds([-7, 12, -7]) == []"}
{"id": "op_div3_inc_sum", "entry_point": "op_div3_inc_sum", "primitives": ["div3", "inc", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then return their sum.", "solution": "def op_div3_inc_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_div3_inc_sum([1, 2, 3, 4]) == 4\nassert op_div3_inc_sum([]) == 0\nassert op_div3_inc_sum([-2, -1, 0, 1, 2]) == 1\nassert op_div3_inc_sum([5, 5, 5]) == 0\nassert op_div3_inc_sum([3, 1, 2]) == 4\nassert op_div3_inc_sum([10]) == 0\nassert op_div3_inc_sum([2, 4, 6]) == 7\nassert op_div3_inc_sum([-7, 12, -7]) == 13"}
{"id": "op_dropwhileneg_dropzeros_trimends", "entry_point": "op_dropwhileneg_dropzeros_trimends", "primitives": ["dropwhileneg", "dropzeros", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then drop the first and last elements.", "solution": "def op_dropwhileneg_dropzeros_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_dropzeros_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_dropwhileneg_dropzeros_trimends([]) == []\nassert op_dropwhileneg_dropzeros_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_dropzeros_trimends([5, 5, 5]) == [5]\nassert op_dropwhileneg_dropzeros_trimends([3, 1, 2]) == [1]\nassert op_dropwhileneg_dropzeros_trimends([10]) == []\nassert op_dropwhileneg_dropzeros_trimends([2, 4, 6]) == [4]\nassert op_dropwhileneg_dropzeros_trimends([-7, 12, -7]) == []"}
{"id": "op_square_negate_clamp10", "entry_point": "op_square_negate_clamp10", "primitives": ["square", "negate", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then negate each, then cap each value at 10.", "solution": "def op_square_negate_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_negate_clamp10([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_negate_clamp10([]) == []\nassert op_square_negate_clamp10([-2, -1, 0, 1, 2]) == [-4, -1, 0, -1, -4]\nassert op_square_negate_clamp10([5, 5, 5]) == [-25, -25, -25]\nassert op_square_negate_clamp10([3, 1, 2]) == [-9, -1, -4]\nassert op_square_negate_clamp10([10]) == [-100]\nassert op_square_negate_clamp10([2, 4, 6]) == [-4, -16, -36]\nassert op_square_negate_clamp10([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_padto3_absval_div3", "entry_point": "op_padto3_absval_div3", "primitives": ["padto3", "absval", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then keep multiples of three.", "solution": "def op_padto3_absval_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_absval_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_absval_div3([]) == [0, 0, 0]\nassert op_padto3_absval_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_absval_div3([5, 5, 5]) == []\nassert op_padto3_absval_div3([3, 1, 2]) == [3]\nassert op_padto3_absval_div3([10]) == [0, 0]\nassert op_padto3_absval_div3([2, 4, 6]) == [6]\nassert op_padto3_absval_div3([-7, 12, -7]) == [12]"}
{"id": "op_dec_neg_trimends", "entry_point": "op_dec_neg_trimends", "primitives": ["dec", "neg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_dec_neg_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_neg_trimends([1, 2, 3, 4]) == []\nassert op_dec_neg_trimends([]) == []\nassert op_dec_neg_trimends([-2, -1, 0, 1, 2]) == [-2]\nassert op_dec_neg_trimends([5, 5, 5]) == []\nassert op_dec_neg_trimends([3, 1, 2]) == []\nassert op_dec_neg_trimends([10]) == []\nassert op_dec_neg_trimends([2, 4, 6]) == []\nassert op_dec_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_last3_neg_div3", "entry_point": "op_last3_neg_div3", "primitives": ["last3", "neg", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then keep multiples of three.", "solution": "def op_last3_neg_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_neg_div3([1, 2, 3, 4]) == []\nassert op_last3_neg_div3([]) == []\nassert op_last3_neg_div3([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_div3([5, 5, 5]) == []\nassert op_last3_neg_div3([3, 1, 2]) == []\nassert op_last3_neg_div3([10]) == []\nassert op_last3_neg_div3([2, 4, 6]) == []\nassert op_last3_neg_div3([-7, 12, -7]) == []"}
{"id": "op_neg_odds_counteven", "entry_point": "op_neg_odds_counteven", "primitives": ["neg", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then return how many values are even.", "solution": "def op_neg_odds_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_odds_counteven([1, 2, 3, 4]) == 0\nassert op_neg_odds_counteven([]) == 0\nassert op_neg_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_odds_counteven([5, 5, 5]) == 0\nassert op_neg_odds_counteven([3, 1, 2]) == 0\nassert op_neg_odds_counteven([10]) == 0\nassert op_neg_odds_counteven([2, 4, 6]) == 0\nassert op_neg_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_sortabs_neg_negate", "entry_point": "op_sortabs_neg_negate", "primitives": ["sortabs", "neg", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then negate each.", "solution": "def op_sortabs_neg_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_neg_negate([1, 2, 3, 4]) == []\nassert op_sortabs_neg_negate([]) == []\nassert op_sortabs_neg_negate([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_neg_negate([5, 5, 5]) == []\nassert op_sortabs_neg_negate([3, 1, 2]) == []\nassert op_sortabs_neg_negate([10]) == []\nassert op_sortabs_neg_negate([2, 4, 6]) == []\nassert op_sortabs_neg_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_last3_oremptyzero_allpos", "entry_point": "op_last3_oremptyzero_allpos", "primitives": ["last3", "oremptyzero", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_last3_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_last3_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_last3_oremptyzero_allpos([]) == False\nassert op_last3_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_last3_oremptyzero_allpos([5, 5, 5]) == True\nassert op_last3_oremptyzero_allpos([3, 1, 2]) == True\nassert op_last3_oremptyzero_allpos([10]) == True\nassert op_last3_oremptyzero_allpos([2, 4, 6]) == True\nassert op_last3_oremptyzero_allpos([-7, 12, -7]) == False"}
{"id": "op_gt5_rev_trimends", "entry_point": "op_gt5_rev_trimends", "primitives": ["gt5", "rev", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then drop the first and last elements.", "solution": "def op_gt5_rev_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_rev_trimends([1, 2, 3, 4]) == []\nassert op_gt5_rev_trimends([]) == []\nassert op_gt5_rev_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_rev_trimends([5, 5, 5]) == []\nassert op_gt5_rev_trimends([3, 1, 2]) == []\nassert op_gt5_rev_trimends([10]) == []\nassert op_gt5_rev_trimends([2, 4, 6]) == []\nassert op_gt5_rev_trimends([-7, 12, -7]) == []"}
{"id": "op_dropfirst_rev_dropwhileneg", "entry_point": "op_dropfirst_rev_dropwhileneg", "primitives": ["dropfirst", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then drop the leading negative values.", "solution": "def op_dropfirst_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev_dropwhileneg([]) == []\nassert op_dropfirst_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_rev_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_dropfirst_rev_dropwhileneg([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev_dropwhileneg([10]) == []\nassert op_dropfirst_rev_dropwhileneg([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_square_allpos", "entry_point": "op_sortabs_square_allpos", "primitives": ["sortabs", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then return whether all values are positive.", "solution": "def op_sortabs_square_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_square_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_square_allpos([]) == True\nassert op_sortabs_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_square_allpos([5, 5, 5]) == True\nassert op_sortabs_square_allpos([3, 1, 2]) == True\nassert op_sortabs_square_allpos([10]) == True\nassert op_sortabs_square_allpos([2, 4, 6]) == True\nassert op_sortabs_square_allpos([-7, 12, -7]) == True"}
{"id": "op_double_gt5_allpos", "entry_point": "op_double_gt5_allpos", "primitives": ["double", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then return whether all values are positive.", "solution": "def op_double_gt5_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_double_gt5_allpos([1, 2, 3, 4]) == True\nassert op_double_gt5_allpos([]) == True\nassert op_double_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_double_gt5_allpos([5, 5, 5]) == True\nassert op_double_gt5_allpos([3, 1, 2]) == True\nassert op_double_gt5_allpos([10]) == True\nassert op_double_gt5_allpos([2, 4, 6]) == True\nassert op_double_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_last3_beforezero_rev", "entry_point": "op_last3_beforezero_rev", "primitives": ["last3", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then reverse the order.", "solution": "def op_last3_beforezero_rev(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_last3_beforezero_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_beforezero_rev([]) == []\nassert op_last3_beforezero_rev([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_last3_beforezero_rev([10]) == [10]\nassert op_last3_beforezero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_last3_beforezero_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_oremptyzero_gt5_pos", "entry_point": "op_oremptyzero_gt5_pos", "primitives": ["oremptyzero", "gt5", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then keep the positive numbers.", "solution": "def op_oremptyzero_gt5_pos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_oremptyzero_gt5_pos([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_pos([]) == []\nassert op_oremptyzero_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_pos([5, 5, 5]) == []\nassert op_oremptyzero_gt5_pos([3, 1, 2]) == []\nassert op_oremptyzero_gt5_pos([10]) == [10]\nassert op_oremptyzero_gt5_pos([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_takewhilepos_double", "entry_point": "op_dropzeros_takewhilepos_double", "primitives": ["dropzeros", "takewhilepos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then double each.", "solution": "def op_dropzeros_takewhilepos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_takewhilepos_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_takewhilepos_double([]) == []\nassert op_dropzeros_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_takewhilepos_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_takewhilepos_double([10]) == [20]\nassert op_dropzeros_takewhilepos_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_negate_gt5_issorted", "entry_point": "op_negate_gt5_issorted", "primitives": ["negate", "gt5", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_negate_gt5_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_negate_gt5_issorted([1, 2, 3, 4]) == True\nassert op_negate_gt5_issorted([]) == True\nassert op_negate_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_negate_gt5_issorted([5, 5, 5]) == True\nassert op_negate_gt5_issorted([3, 1, 2]) == True\nassert op_negate_gt5_issorted([10]) == True\nassert op_negate_gt5_issorted([2, 4, 6]) == True\nassert op_negate_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_dropfirst_negate_anyeven", "entry_point": "op_dropfirst_negate_anyeven", "primitives": ["dropfirst", "negate", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then return whether any value is even.", "solution": "def op_dropfirst_negate_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_negate_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_negate_anyeven([]) == False\nassert op_dropfirst_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_negate_anyeven([5, 5, 5]) == False\nassert op_dropfirst_negate_anyeven([3, 1, 2]) == True\nassert op_dropfirst_negate_anyeven([10]) == False\nassert op_dropfirst_negate_anyeven([2, 4, 6]) == True\nassert op_dropfirst_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_odds_beforezero_pos", "entry_point": "op_odds_beforezero_pos", "primitives": ["odds", "beforezero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_odds_beforezero_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_odds_beforezero_pos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_beforezero_pos([]) == []\nassert op_odds_beforezero_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_beforezero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_odds_beforezero_pos([3, 1, 2]) == [3, 1]\nassert op_odds_beforezero_pos([10]) == []\nassert op_odds_beforezero_pos([2, 4, 6]) == []\nassert op_odds_beforezero_pos([-7, 12, -7]) == []"}
{"id": "op_ages_neg_evens", "entry_point": "op_ages_neg_evens", "primitives": ["ages", "neg", "evens"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then keep the even numbers.", "solution": "def op_ages_neg_evens(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_ages_neg_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg_evens([]) == []\nassert op_ages_neg_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_trimends_double_neg", "entry_point": "op_trimends_double_neg", "primitives": ["trimends", "double", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then keep the negative numbers.", "solution": "def op_trimends_double_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_double_neg([1, 2, 3, 4]) == []\nassert op_trimends_double_neg([]) == []\nassert op_trimends_double_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_trimends_double_neg([5, 5, 5]) == []\nassert op_trimends_double_neg([3, 1, 2]) == []\nassert op_trimends_double_neg([10]) == []\nassert op_trimends_double_neg([2, 4, 6]) == []\nassert op_trimends_double_neg([-7, 12, -7]) == []"}
{"id": "op_uniqs_dropshort_anyempty", "entry_point": "op_uniqs_dropshort_anyempty", "primitives": ["uniqs", "dropshort", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop strings shorter than three characters, then return whether any string is empty.", "solution": "def op_uniqs_dropshort_anyempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    return any(s == '' for s in r)", "tests": "assert op_uniqs_dropshort_anyempty(['Hello', 'world']) == False\nassert op_uniqs_dropshort_anyempty([]) == False\nassert op_uniqs_dropshort_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_uniqs_dropshort_anyempty(['one', 'one', 'Two']) == False\nassert op_uniqs_dropshort_anyempty(['x']) == False\nassert op_uniqs_dropshort_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dropshort_strip_prefixup", "entry_point": "op_dropshort_strip_prefixup", "primitives": ["dropshort", "strip", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then trim whitespace from each, then prefix each with a hash.", "solution": "def op_dropshort_strip_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.strip() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_dropshort_strip_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_dropshort_strip_prefixup([]) == []\nassert op_dropshort_strip_prefixup(['  a ', '', 'BC', 'bc']) == ['#a']\nassert op_dropshort_strip_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_dropshort_strip_prefixup(['x']) == []\nassert op_dropshort_strip_prefixup(['abc', 'de', '']) == ['#abc']"}
{"id": "op_square_rev_gt5", "entry_point": "op_square_rev_gt5", "primitives": ["square", "rev", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then reverse the order, then keep values greater than five.", "solution": "def op_square_rev_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_rev_gt5([1, 2, 3, 4]) == [16, 9]\nassert op_square_rev_gt5([]) == []\nassert op_square_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_rev_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_square_rev_gt5([3, 1, 2]) == [9]\nassert op_square_rev_gt5([10]) == [100]\nassert op_square_rev_gt5([2, 4, 6]) == [36, 16]\nassert op_square_rev_gt5([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_evens_gt5_beforezero", "entry_point": "op_evens_gt5_beforezero", "primitives": ["evens", "gt5", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_evens_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_evens_gt5_beforezero([]) == []\nassert op_evens_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_evens_gt5_beforezero([5, 5, 5]) == []\nassert op_evens_gt5_beforezero([3, 1, 2]) == []\nassert op_evens_gt5_beforezero([10]) == [10]\nassert op_evens_gt5_beforezero([2, 4, 6]) == [6]\nassert op_evens_gt5_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_neg_dec", "entry_point": "op_clamp10_neg_dec", "primitives": ["clamp10", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then subtract one from each.", "solution": "def op_clamp10_neg_dec(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_clamp10_neg_dec([1, 2, 3, 4]) == []\nassert op_clamp10_neg_dec([]) == []\nassert op_clamp10_neg_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_clamp10_neg_dec([5, 5, 5]) == []\nassert op_clamp10_neg_dec([3, 1, 2]) == []\nassert op_clamp10_neg_dec([10]) == []\nassert op_clamp10_neg_dec([2, 4, 6]) == []\nassert op_clamp10_neg_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_sortd_neg_inc", "entry_point": "op_sortd_neg_inc", "primitives": ["sortd", "neg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then add one to each.", "solution": "def op_sortd_neg_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_neg_inc([1, 2, 3, 4]) == []\nassert op_sortd_neg_inc([]) == []\nassert op_sortd_neg_inc([-2, -1, 0, 1, 2]) == [0, -1]\nassert op_sortd_neg_inc([5, 5, 5]) == []\nassert op_sortd_neg_inc([3, 1, 2]) == []\nassert op_sortd_neg_inc([10]) == []\nassert op_sortd_neg_inc([2, 4, 6]) == []\nassert op_sortd_neg_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_add10_rev_double", "entry_point": "op_add10_rev_double", "primitives": ["add10", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then double each.", "solution": "def op_add10_rev_double(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_add10_rev_double([1, 2, 3, 4]) == [28, 26, 24, 22]\nassert op_add10_rev_double([]) == []\nassert op_add10_rev_double([-2, -1, 0, 1, 2]) == [24, 22, 20, 18, 16]\nassert op_add10_rev_double([5, 5, 5]) == [30, 30, 30]\nassert op_add10_rev_double([3, 1, 2]) == [24, 22, 26]\nassert op_add10_rev_double([10]) == [40]\nassert op_add10_rev_double([2, 4, 6]) == [32, 28, 24]\nassert op_add10_rev_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_double_sortabs_firsteven", "entry_point": "op_double_sortabs_firsteven", "primitives": ["double", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_double_sortabs_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_double_sortabs_firsteven([]) == 0\nassert op_double_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_double_sortabs_firsteven([5, 5, 5]) == 10\nassert op_double_sortabs_firsteven([3, 1, 2]) == 2\nassert op_double_sortabs_firsteven([10]) == 20\nassert op_double_sortabs_firsteven([2, 4, 6]) == 4\nassert op_double_sortabs_firsteven([-7, 12, -7]) == -14"}
{"id": "op_dropfirst_oremptyzero_inc", "entry_point": "op_dropfirst_oremptyzero_inc", "primitives": ["dropfirst", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then add one to each.", "solution": "def op_dropfirst_oremptyzero_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_oremptyzero_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_dropfirst_oremptyzero_inc([]) == [1]\nassert op_dropfirst_oremptyzero_inc([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_dropfirst_oremptyzero_inc([5, 5, 5]) == [6, 6]\nassert op_dropfirst_oremptyzero_inc([3, 1, 2]) == [2, 3]\nassert op_dropfirst_oremptyzero_inc([10]) == [1]\nassert op_dropfirst_oremptyzero_inc([2, 4, 6]) == [5, 7]\nassert op_dropfirst_oremptyzero_inc([-7, 12, -7]) == [13, -6]"}
{"id": "op_dropfirst_add10_inc", "entry_point": "op_dropfirst_add10_inc", "primitives": ["dropfirst", "add10", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then add one to each.", "solution": "def op_dropfirst_add10_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_add10_inc([1, 2, 3, 4]) == [13, 14, 15]\nassert op_dropfirst_add10_inc([]) == []\nassert op_dropfirst_add10_inc([-2, -1, 0, 1, 2]) == [10, 11, 12, 13]\nassert op_dropfirst_add10_inc([5, 5, 5]) == [16, 16]\nassert op_dropfirst_add10_inc([3, 1, 2]) == [12, 13]\nassert op_dropfirst_add10_inc([10]) == []\nassert op_dropfirst_add10_inc([2, 4, 6]) == [15, 17]\nassert op_dropfirst_add10_inc([-7, 12, -7]) == [23, 4]"}
{"id": "op_ages_neg_uniq", "entry_point": "op_ages_neg_uniq", "primitives": ["ages", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_ages_neg_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_neg_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg_uniq([]) == []\nassert op_ages_neg_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg_uniq([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dec_dropzeros_counteven", "entry_point": "op_dec_dropzeros_counteven", "primitives": ["dec", "dropzeros", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then return how many values are even.", "solution": "def op_dec_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_dropzeros_counteven([1, 2, 3, 4]) == 1\nassert op_dec_dropzeros_counteven([]) == 0\nassert op_dec_dropzeros_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_dec_dropzeros_counteven([5, 5, 5]) == 3\nassert op_dec_dropzeros_counteven([3, 1, 2]) == 1\nassert op_dec_dropzeros_counteven([10]) == 0\nassert op_dec_dropzeros_counteven([2, 4, 6]) == 0\nassert op_dec_dropzeros_counteven([-7, 12, -7]) == 2"}
{"id": "op_inc_first3_uniq", "entry_point": "op_inc_first3_uniq", "primitives": ["inc", "first3", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_inc_first3_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_first3_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_first3_uniq([]) == []\nassert op_inc_first3_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_first3_uniq([5, 5, 5]) == [6]\nassert op_inc_first3_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_inc_first3_uniq([10]) == [11]\nassert op_inc_first3_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_inc_first3_uniq([-7, 12, -7]) == [-6, 13]"}
{"id": "op_double_beforezero_takewhilepos", "entry_point": "op_double_beforezero_takewhilepos", "primitives": ["double", "beforezero", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_double_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_beforezero_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_beforezero_takewhilepos([]) == []\nassert op_double_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_beforezero_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_double_beforezero_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_beforezero_takewhilepos([10]) == [20]\nassert op_double_beforezero_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_rev_first3_absval", "entry_point": "op_rev_first3_absval", "primitives": ["rev", "first3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then take the absolute value of each.", "solution": "def op_rev_first3_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_first3_absval([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_absval([]) == []\nassert op_rev_first3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3_absval([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3_absval([10]) == [10]\nassert op_rev_first3_absval([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_inc_dec_prod", "entry_point": "op_inc_dec_prod", "primitives": ["inc", "dec", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then return their product.", "solution": "def op_inc_dec_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_inc_dec_prod([1, 2, 3, 4]) == 24\nassert op_inc_dec_prod([]) == 1\nassert op_inc_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_inc_dec_prod([5, 5, 5]) == 125\nassert op_inc_dec_prod([3, 1, 2]) == 6\nassert op_inc_dec_prod([10]) == 10\nassert op_inc_dec_prod([2, 4, 6]) == 48\nassert op_inc_dec_prod([-7, 12, -7]) == 588"}
{"id": "op_padto3_sortd_sorta", "entry_point": "op_padto3_sortd_sorta", "primitives": ["padto3", "sortd", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then sort ascending.", "solution": "def op_padto3_sortd_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_sortd_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sortd_sorta([]) == [0, 0, 0]\nassert op_padto3_sortd_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_sortd_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sortd_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sortd_sorta([10]) == [0, 0, 10]\nassert op_padto3_sortd_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sortd_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_absval_takewhilepos_sorta", "entry_point": "op_absval_takewhilepos_sorta", "primitives": ["absval", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then sort ascending.", "solution": "def op_absval_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_absval_takewhilepos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos_sorta([]) == []\nassert op_absval_takewhilepos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_absval_takewhilepos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_absval_takewhilepos_sorta([10]) == [10]\nassert op_absval_takewhilepos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_div3_trimends_firsteven", "entry_point": "op_div3_trimends_firsteven", "primitives": ["div3", "trimends", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_div3_trimends_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_trimends_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_trimends_firsteven([]) == 0\nassert op_div3_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_trimends_firsteven([5, 5, 5]) == 0\nassert op_div3_trimends_firsteven([3, 1, 2]) == 0\nassert op_div3_trimends_firsteven([10]) == 0\nassert op_div3_trimends_firsteven([2, 4, 6]) == 0\nassert op_div3_trimends_firsteven([-7, 12, -7]) == 0"}
{"id": "op_inc_neg_add10", "entry_point": "op_inc_neg_add10", "primitives": ["inc", "neg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then add ten to each.", "solution": "def op_inc_neg_add10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_inc_neg_add10([1, 2, 3, 4]) == []\nassert op_inc_neg_add10([]) == []\nassert op_inc_neg_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_inc_neg_add10([5, 5, 5]) == []\nassert op_inc_neg_add10([3, 1, 2]) == []\nassert op_inc_neg_add10([10]) == []\nassert op_inc_neg_add10([2, 4, 6]) == []\nassert op_inc_neg_add10([-7, 12, -7]) == [4, 4]"}
{"id": "op_gt5_evens_sorta", "entry_point": "op_gt5_evens_sorta", "primitives": ["gt5", "evens", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then sort ascending.", "solution": "def op_gt5_evens_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_evens_sorta([1, 2, 3, 4]) == []\nassert op_gt5_evens_sorta([]) == []\nassert op_gt5_evens_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens_sorta([5, 5, 5]) == []\nassert op_gt5_evens_sorta([3, 1, 2]) == []\nassert op_gt5_evens_sorta([10]) == [10]\nassert op_gt5_evens_sorta([2, 4, 6]) == [6]\nassert op_gt5_evens_sorta([-7, 12, -7]) == [12]"}
{"id": "op_neg_negate_beforezero", "entry_point": "op_neg_negate_beforezero", "primitives": ["neg", "negate", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then keep everything before the first zero.", "solution": "def op_neg_negate_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_negate_beforezero([1, 2, 3, 4]) == []\nassert op_neg_negate_beforezero([]) == []\nassert op_neg_negate_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_negate_beforezero([5, 5, 5]) == []\nassert op_neg_negate_beforezero([3, 1, 2]) == []\nassert op_neg_negate_beforezero([10]) == []\nassert op_neg_negate_beforezero([2, 4, 6]) == []\nassert op_neg_negate_beforezero([-7, 12, -7]) == [7, 7]"}
{"id": "op_double_odds_firsteven", "entry_point": "op_double_odds_firsteven", "primitives": ["double", "odds", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_double_odds_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_double_odds_firsteven([]) == 0\nassert op_double_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_double_odds_firsteven([5, 5, 5]) == 0\nassert op_double_odds_firsteven([3, 1, 2]) == 0\nassert op_double_odds_firsteven([10]) == 0\nassert op_double_odds_firsteven([2, 4, 6]) == 0\nassert op_double_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_odds_square_pos", "entry_point": "op_odds_square_pos", "primitives": ["odds", "square", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then keep the positive numbers.", "solution": "def op_odds_square_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_odds_square_pos([1, 2, 3, 4]) == [1, 9]\nassert op_odds_square_pos([]) == []\nassert op_odds_square_pos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_square_pos([5, 5, 5]) == [25, 25, 25]\nassert op_odds_square_pos([3, 1, 2]) == [9, 1]\nassert op_odds_square_pos([10]) == []\nassert op_odds_square_pos([2, 4, 6]) == []\nassert op_odds_square_pos([-7, 12, -7]) == [49, 49]"}
{"id": "op_add10_evens_counteven", "entry_point": "op_add10_evens_counteven", "primitives": ["add10", "evens", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the even numbers, then return how many values are even.", "solution": "def op_add10_evens_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_evens_counteven([1, 2, 3, 4]) == 2\nassert op_add10_evens_counteven([]) == 0\nassert op_add10_evens_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_evens_counteven([5, 5, 5]) == 0\nassert op_add10_evens_counteven([3, 1, 2]) == 1\nassert op_add10_evens_counteven([10]) == 1\nassert op_add10_evens_counteven([2, 4, 6]) == 3\nassert op_add10_evens_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_last3_odds", "entry_point": "op_clamp10_last3_odds", "primitives": ["clamp10", "last3", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three, then keep the odd numbers.", "solution": "def op_clamp10_last3_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_last3_odds([1, 2, 3, 4]) == [3]\nassert op_clamp10_last3_odds([]) == []\nassert op_clamp10_last3_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_clamp10_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_last3_odds([3, 1, 2]) == [3, 1]\nassert op_clamp10_last3_odds([10]) == []\nassert op_clamp10_last3_odds([2, 4, 6]) == []\nassert op_clamp10_last3_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_uniq_padto3", "entry_point": "op_beforezero_uniq_padto3", "primitives": ["beforezero", "uniq", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_beforezero_uniq_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_uniq_padto3([]) == [0, 0, 0]\nassert op_beforezero_uniq_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_beforezero_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_beforezero_uniq_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_uniq_padto3([10]) == [10, 0, 0]\nassert op_beforezero_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_uniq_padto3([-7, 12, -7]) == [-7, 12, 0]"}
{"id": "op_takewhilepos_beforezero_inc", "entry_point": "op_takewhilepos_beforezero_inc", "primitives": ["takewhilepos", "beforezero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then add one to each.", "solution": "def op_takewhilepos_beforezero_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_beforezero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_takewhilepos_beforezero_inc([]) == []\nassert op_takewhilepos_beforezero_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_beforezero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_takewhilepos_beforezero_inc([10]) == [11]\nassert op_takewhilepos_beforezero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_beforezero_inc([-7, 12, -7]) == []"}
{"id": "op_add10_takewhilepos_pos", "entry_point": "op_add10_takewhilepos_pos", "primitives": ["add10", "takewhilepos", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then keep the positive numbers.", "solution": "def op_add10_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_add10_takewhilepos_pos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_takewhilepos_pos([]) == []\nassert op_add10_takewhilepos_pos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_takewhilepos_pos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos_pos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_takewhilepos_pos([10]) == [20]\nassert op_add10_takewhilepos_pos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_takewhilepos_pos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_div3_gt5_neg", "entry_point": "op_div3_gt5_neg", "primitives": ["div3", "gt5", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then keep the negative numbers.", "solution": "def op_div3_gt5_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_div3_gt5_neg([1, 2, 3, 4]) == []\nassert op_div3_gt5_neg([]) == []\nassert op_div3_gt5_neg([-2, -1, 0, 1, 2]) == []\nassert op_div3_gt5_neg([5, 5, 5]) == []\nassert op_div3_gt5_neg([3, 1, 2]) == []\nassert op_div3_gt5_neg([10]) == []\nassert op_div3_gt5_neg([2, 4, 6]) == []\nassert op_div3_gt5_neg([-7, 12, -7]) == []"}
{"id": "op_sortabs_beforezero_inc", "entry_point": "op_sortabs_beforezero_inc", "primitives": ["sortabs", "beforezero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then add one to each.", "solution": "def op_sortabs_beforezero_inc(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortabs_beforezero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_beforezero_inc([]) == []\nassert op_sortabs_beforezero_inc([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_beforezero_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_beforezero_inc([10]) == [11]\nassert op_sortabs_beforezero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_beforezero_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_sortd_takewhilepos_haszero", "entry_point": "op_sortd_takewhilepos_haszero", "primitives": ["sortd", "takewhilepos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then return whether the list contains a zero.", "solution": "def op_sortd_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_sortd_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_sortd_takewhilepos_haszero([]) == False\nassert op_sortd_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortd_takewhilepos_haszero([5, 5, 5]) == False\nassert op_sortd_takewhilepos_haszero([3, 1, 2]) == False\nassert op_sortd_takewhilepos_haszero([10]) == False\nassert op_sortd_takewhilepos_haszero([2, 4, 6]) == False\nassert op_sortd_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_dropwhileneg_first3", "entry_point": "op_clamp10_dropwhileneg_first3", "primitives": ["clamp10", "dropwhileneg", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then keep only the first three.", "solution": "def op_clamp10_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_dropwhileneg_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_dropwhileneg_first3([]) == []\nassert op_clamp10_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropwhileneg_first3([10]) == [10]\nassert op_clamp10_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg_first3([-7, 12, -7]) == [10, -7]"}
{"id": "op_negate_neg_takewhilepos", "entry_point": "op_negate_neg_takewhilepos", "primitives": ["negate", "neg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then take values while they are positive.", "solution": "def op_negate_neg_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_negate_neg_takewhilepos([]) == []\nassert op_negate_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_negate_neg_takewhilepos([5, 5, 5]) == []\nassert op_negate_neg_takewhilepos([3, 1, 2]) == []\nassert op_negate_neg_takewhilepos([10]) == []\nassert op_negate_neg_takewhilepos([2, 4, 6]) == []\nassert op_negate_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_absval_square_evens", "entry_point": "op_absval_square_evens", "primitives": ["absval", "square", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each, then keep the even numbers.", "solution": "def op_absval_square_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_square_evens([1, 2, 3, 4]) == [4, 16]\nassert op_absval_square_evens([]) == []\nassert op_absval_square_evens([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_absval_square_evens([5, 5, 5]) == []\nassert op_absval_square_evens([3, 1, 2]) == [4]\nassert op_absval_square_evens([10]) == [100]\nassert op_absval_square_evens([2, 4, 6]) == [4, 16, 36]\nassert op_absval_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_pos_dec_double", "entry_point": "op_pos_dec_double", "primitives": ["pos", "dec", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then double each.", "solution": "def op_pos_dec_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_dec_double([1, 2, 3, 4]) == [0, 2, 4, 6]\nassert op_pos_dec_double([]) == []\nassert op_pos_dec_double([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_pos_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_pos_dec_double([3, 1, 2]) == [4, 0, 2]\nassert op_pos_dec_double([10]) == [18]\nassert op_pos_dec_double([2, 4, 6]) == [2, 6, 10]\nassert op_pos_dec_double([-7, 12, -7]) == [22]"}
{"id": "op_takewhilepos_inc_odds", "entry_point": "op_takewhilepos_inc_odds", "primitives": ["takewhilepos", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then keep the odd numbers.", "solution": "def op_takewhilepos_inc_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_inc_odds([1, 2, 3, 4]) == [3, 5]\nassert op_takewhilepos_inc_odds([]) == []\nassert op_takewhilepos_inc_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_inc_odds([5, 5, 5]) == []\nassert op_takewhilepos_inc_odds([3, 1, 2]) == [3]\nassert op_takewhilepos_inc_odds([10]) == [11]\nassert op_takewhilepos_inc_odds([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_inc_odds([-7, 12, -7]) == []"}
{"id": "op_neg_inc_pos", "entry_point": "op_neg_inc_pos", "primitives": ["neg", "inc", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then keep the positive numbers.", "solution": "def op_neg_inc_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_neg_inc_pos([1, 2, 3, 4]) == []\nassert op_neg_inc_pos([]) == []\nassert op_neg_inc_pos([-2, -1, 0, 1, 2]) == []\nassert op_neg_inc_pos([5, 5, 5]) == []\nassert op_neg_inc_pos([3, 1, 2]) == []\nassert op_neg_inc_pos([10]) == []\nassert op_neg_inc_pos([2, 4, 6]) == []\nassert op_neg_inc_pos([-7, 12, -7]) == []"}
{"id": "op_last3_inc_dec", "entry_point": "op_last3_inc_dec", "primitives": ["last3", "inc", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then subtract one from each.", "solution": "def op_last3_inc_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_inc_dec([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_inc_dec([]) == []\nassert op_last3_inc_dec([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_inc_dec([5, 5, 5]) == [5, 5, 5]\nassert op_last3_inc_dec([3, 1, 2]) == [3, 1, 2]\nassert op_last3_inc_dec([10]) == [10]\nassert op_last3_inc_dec([2, 4, 6]) == [2, 4, 6]\nassert op_last3_inc_dec([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst_evens_rev", "entry_point": "op_dropfirst_evens_rev", "primitives": ["dropfirst", "evens", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then reverse the order.", "solution": "def op_dropfirst_evens_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_dropfirst_evens_rev([]) == []\nassert op_dropfirst_evens_rev([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dropfirst_evens_rev([5, 5, 5]) == []\nassert op_dropfirst_evens_rev([3, 1, 2]) == [2]\nassert op_dropfirst_evens_rev([10]) == []\nassert op_dropfirst_evens_rev([2, 4, 6]) == [6, 4]\nassert op_dropfirst_evens_rev([-7, 12, -7]) == [12]"}
{"id": "op_absval_gt5_clamp10", "entry_point": "op_absval_gt5_clamp10", "primitives": ["absval", "gt5", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then cap each value at 10.", "solution": "def op_absval_gt5_clamp10(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_absval_gt5_clamp10([1, 2, 3, 4]) == []\nassert op_absval_gt5_clamp10([]) == []\nassert op_absval_gt5_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_clamp10([5, 5, 5]) == []\nassert op_absval_gt5_clamp10([3, 1, 2]) == []\nassert op_absval_gt5_clamp10([10]) == [10]\nassert op_absval_gt5_clamp10([2, 4, 6]) == [6]\nassert op_absval_gt5_clamp10([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_sortd_takewhilepos_sorta", "entry_point": "op_sortd_takewhilepos_sorta", "primitives": ["sortd", "takewhilepos", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then sort ascending.", "solution": "def op_sortd_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_takewhilepos_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_takewhilepos_sorta([]) == []\nassert op_sortd_takewhilepos_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortd_takewhilepos_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_takewhilepos_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_takewhilepos_sorta([10]) == [10]\nassert op_sortd_takewhilepos_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_takewhilepos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_firstchar_lower_strip", "entry_point": "op_firstchar_lower_strip", "primitives": ["firstchar", "lower", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then lowercase each string, then trim whitespace from each.", "solution": "def op_firstchar_lower_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_lower_strip(['Hello', 'world']) == ['h', 'w']\nassert op_firstchar_lower_strip([]) == []\nassert op_firstchar_lower_strip(['  a ', '', 'BC', 'bc']) == ['', 'b', 'b']\nassert op_firstchar_lower_strip(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_firstchar_lower_strip(['x']) == ['x']\nassert op_firstchar_lower_strip(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_gt5_negate_absval", "entry_point": "op_gt5_negate_absval", "primitives": ["gt5", "negate", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then take the absolute value of each.", "solution": "def op_gt5_negate_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_gt5_negate_absval([1, 2, 3, 4]) == []\nassert op_gt5_negate_absval([]) == []\nassert op_gt5_negate_absval([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_absval([5, 5, 5]) == []\nassert op_gt5_negate_absval([3, 1, 2]) == []\nassert op_gt5_negate_absval([10]) == [10]\nassert op_gt5_negate_absval([2, 4, 6]) == [6]\nassert op_gt5_negate_absval([-7, 12, -7]) == [12]"}
{"id": "op_square_dropwhileneg_uniq", "entry_point": "op_square_dropwhileneg_uniq", "primitives": ["square", "dropwhileneg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_square_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_square_dropwhileneg_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_dropwhileneg_uniq([]) == []\nassert op_square_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_dropwhileneg_uniq([5, 5, 5]) == [25]\nassert op_square_dropwhileneg_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_square_dropwhileneg_uniq([10]) == [100]\nassert op_square_dropwhileneg_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_square_dropwhileneg_uniq([-7, 12, -7]) == [49, 144]"}
{"id": "op_strip_dropshort_counts", "entry_point": "op_strip_dropshort_counts", "primitives": ["strip", "dropshort", "counts"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then drop strings shorter than three characters, then return how many strings remain.", "solution": "def op_strip_dropshort_counts(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return len(r)", "tests": "assert op_strip_dropshort_counts(['Hello', 'world']) == 2\nassert op_strip_dropshort_counts([]) == 0\nassert op_strip_dropshort_counts(['  a ', '', 'BC', 'bc']) == 0\nassert op_strip_dropshort_counts(['one', 'one', 'Two']) == 3\nassert op_strip_dropshort_counts(['x']) == 0\nassert op_strip_dropshort_counts(['abc', 'de', '']) == 1"}
{"id": "op_square_sortd_gt5", "entry_point": "op_square_sortd_gt5", "primitives": ["square", "sortd", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then keep values greater than five.", "solution": "def op_square_sortd_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_sortd_gt5([1, 2, 3, 4]) == [16, 9]\nassert op_square_sortd_gt5([]) == []\nassert op_square_sortd_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_sortd_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortd_gt5([3, 1, 2]) == [9]\nassert op_square_sortd_gt5([10]) == [100]\nassert op_square_sortd_gt5([2, 4, 6]) == [36, 16]\nassert op_square_sortd_gt5([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_firstchar_sortalpha_upper", "entry_point": "op_firstchar_sortalpha_upper", "primitives": ["firstchar", "sortalpha", "upper"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then uppercase each string.", "solution": "def op_firstchar_sortalpha_upper(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_firstchar_sortalpha_upper(['Hello', 'world']) == ['H', 'W']\nassert op_firstchar_sortalpha_upper([]) == []\nassert op_firstchar_sortalpha_upper(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'B']\nassert op_firstchar_sortalpha_upper(['one', 'one', 'Two']) == ['T', 'O', 'O']\nassert op_firstchar_sortalpha_upper(['x']) == ['X']\nassert op_firstchar_sortalpha_upper(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_clamp10_add10_issorted", "entry_point": "op_clamp10_add10_issorted", "primitives": ["clamp10", "add10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_clamp10_add10_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_clamp10_add10_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_add10_issorted([]) == True\nassert op_clamp10_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_add10_issorted([5, 5, 5]) == True\nassert op_clamp10_add10_issorted([3, 1, 2]) == False\nassert op_clamp10_add10_issorted([10]) == True\nassert op_clamp10_add10_issorted([2, 4, 6]) == True\nassert op_clamp10_add10_issorted([-7, 12, -7]) == False"}
{"id": "op_last3_add10_dropzeros", "entry_point": "op_last3_add10_dropzeros", "primitives": ["last3", "add10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then drop the zeros.", "solution": "def op_last3_add10_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_add10_dropzeros([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_add10_dropzeros([]) == []\nassert op_last3_add10_dropzeros([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_add10_dropzeros([5, 5, 5]) == [15, 15, 15]\nassert op_last3_add10_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_last3_add10_dropzeros([10]) == [20]\nassert op_last3_add10_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_last3_add10_dropzeros([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_trimends_pos_add10", "entry_point": "op_trimends_pos_add10", "primitives": ["trimends", "pos", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then add ten to each.", "solution": "def op_trimends_pos_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_pos_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_pos_add10([]) == []\nassert op_trimends_pos_add10([-2, -1, 0, 1, 2]) == [11]\nassert op_trimends_pos_add10([5, 5, 5]) == [15]\nassert op_trimends_pos_add10([3, 1, 2]) == [11]\nassert op_trimends_pos_add10([10]) == []\nassert op_trimends_pos_add10([2, 4, 6]) == [14]\nassert op_trimends_pos_add10([-7, 12, -7]) == [22]"}
{"id": "op_sortlen_firstchar_uniqs", "entry_point": "op_sortlen_firstchar_uniqs", "primitives": ["sortlen", "firstchar", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then keep the first character of each (dropping empties), then drop duplicate strings keeping the first.", "solution": "def op_sortlen_firstchar_uniqs(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortlen_firstchar_uniqs(['Hello', 'world']) == ['H', 'w']\nassert op_sortlen_firstchar_uniqs([]) == []\nassert op_sortlen_firstchar_uniqs(['  a ', '', 'BC', 'bc']) == ['B', 'b', ' ']\nassert op_sortlen_firstchar_uniqs(['one', 'one', 'Two']) == ['o', 'T']\nassert op_sortlen_firstchar_uniqs(['x']) == ['x']\nassert op_sortlen_firstchar_uniqs(['abc', 'de', '']) == ['d', 'a']"}
{"id": "op_strip_sortlen_maxlen", "entry_point": "op_strip_sortlen_maxlen", "primitives": ["strip", "sortlen", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first, then return the length of the longest string (0 if none).", "solution": "def op_strip_sortlen_maxlen(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_strip_sortlen_maxlen(['Hello', 'world']) == 5\nassert op_strip_sortlen_maxlen([]) == 0\nassert op_strip_sortlen_maxlen(['  a ', '', 'BC', 'bc']) == 2\nassert op_strip_sortlen_maxlen(['one', 'one', 'Two']) == 3\nassert op_strip_sortlen_maxlen(['x']) == 1\nassert op_strip_sortlen_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_sortd_sortabs_dropwhileneg", "entry_point": "op_sortd_sortabs_dropwhileneg", "primitives": ["sortd", "sortabs", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then drop the leading negative values.", "solution": "def op_sortd_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_sortabs_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sortabs_dropwhileneg([]) == []\nassert op_sortd_sortabs_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortd_sortabs_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sortabs_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sortabs_dropwhileneg([10]) == [10]\nassert op_sortd_sortabs_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sortabs_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_dec_rev_double", "entry_point": "op_dec_rev_double", "primitives": ["dec", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then double each.", "solution": "def op_dec_rev_double(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dec_rev_double([1, 2, 3, 4]) == [6, 4, 2, 0]\nassert op_dec_rev_double([]) == []\nassert op_dec_rev_double([-2, -1, 0, 1, 2]) == [2, 0, -2, -4, -6]\nassert op_dec_rev_double([5, 5, 5]) == [8, 8, 8]\nassert op_dec_rev_double([3, 1, 2]) == [2, 0, 4]\nassert op_dec_rev_double([10]) == [18]\nassert op_dec_rev_double([2, 4, 6]) == [10, 6, 2]\nassert op_dec_rev_double([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_sorta_sortabs_pos", "entry_point": "op_sorta_sortabs_pos", "primitives": ["sorta", "sortabs", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then keep the positive numbers.", "solution": "def op_sorta_sortabs_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_sortabs_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_sortabs_pos([]) == []\nassert op_sorta_sortabs_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sorta_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_sortabs_pos([10]) == [10]\nassert op_sorta_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_sortabs_pos([-7, 12, -7]) == [12]"}
{"id": "op_trimends_dropzeros_min", "entry_point": "op_trimends_dropzeros_min", "primitives": ["trimends", "dropzeros", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_trimends_dropzeros_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_trimends_dropzeros_min([1, 2, 3, 4]) == 2\nassert op_trimends_dropzeros_min([]) == 0\nassert op_trimends_dropzeros_min([-2, -1, 0, 1, 2]) == -1\nassert op_trimends_dropzeros_min([5, 5, 5]) == 5\nassert op_trimends_dropzeros_min([3, 1, 2]) == 1\nassert op_trimends_dropzeros_min([10]) == 0\nassert op_trimends_dropzeros_min([2, 4, 6]) == 4\nassert op_trimends_dropzeros_min([-7, 12, -7]) == 12"}
{"id": "op_neg_dropwhileneg_dropfirst", "entry_point": "op_neg_dropwhileneg_dropfirst", "primitives": ["neg", "dropwhileneg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values, then drop the first element.", "solution": "def op_neg_dropwhileneg_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    return r", "tests": "assert op_neg_dropwhileneg_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_dropwhileneg_dropfirst([]) == []\nassert op_neg_dropwhileneg_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropwhileneg_dropfirst([5, 5, 5]) == []\nassert op_neg_dropwhileneg_dropfirst([3, 1, 2]) == []\nassert op_neg_dropwhileneg_dropfirst([10]) == []\nassert op_neg_dropwhileneg_dropfirst([2, 4, 6]) == []\nassert op_neg_dropwhileneg_dropfirst([-7, 12, -7]) == []"}
{"id": "op_double_dropfirst_evens", "entry_point": "op_double_dropfirst_evens", "primitives": ["double", "dropfirst", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then keep the even numbers.", "solution": "def op_double_dropfirst_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_dropfirst_evens([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst_evens([]) == []\nassert op_double_dropfirst_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_double_dropfirst_evens([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst_evens([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst_evens([10]) == []\nassert op_double_dropfirst_evens([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst_evens([-7, 12, -7]) == [24, -14]"}
{"id": "op_negate_absval_takewhilepos", "entry_point": "op_negate_absval_takewhilepos", "primitives": ["negate", "absval", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then take values while they are positive.", "solution": "def op_negate_absval_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_absval_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval_takewhilepos([]) == []\nassert op_negate_absval_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval_takewhilepos([10]) == [10]\nassert op_negate_absval_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_takewhilepos_add10_negate", "entry_point": "op_takewhilepos_add10_negate", "primitives": ["takewhilepos", "add10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then negate each.", "solution": "def op_takewhilepos_add10_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_add10_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_takewhilepos_add10_negate([]) == []\nassert op_takewhilepos_add10_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_add10_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_takewhilepos_add10_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_takewhilepos_add10_negate([10]) == [-20]\nassert op_takewhilepos_add10_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_takewhilepos_add10_negate([-7, 12, -7]) == []"}
{"id": "op_inc_neg_dropfirst", "entry_point": "op_inc_neg_dropfirst", "primitives": ["inc", "neg", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then drop the first element.", "solution": "def op_inc_neg_dropfirst(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_inc_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_inc_neg_dropfirst([]) == []\nassert op_inc_neg_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_inc_neg_dropfirst([5, 5, 5]) == []\nassert op_inc_neg_dropfirst([3, 1, 2]) == []\nassert op_inc_neg_dropfirst([10]) == []\nassert op_inc_neg_dropfirst([2, 4, 6]) == []\nassert op_inc_neg_dropfirst([-7, 12, -7]) == [-6]"}
{"id": "op_sorta_double_dropzeros", "entry_point": "op_sorta_double_dropzeros", "primitives": ["sorta", "double", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each, then drop the zeros.", "solution": "def op_sorta_double_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_double_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sorta_double_dropzeros([]) == []\nassert op_sorta_double_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_sorta_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_double_dropzeros([3, 1, 2]) == [2, 4, 6]\nassert op_sorta_double_dropzeros([10]) == [20]\nassert op_sorta_double_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_sorta_double_dropzeros([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_evens_gt5_alldistinct", "entry_point": "op_evens_gt5_alldistinct", "primitives": ["evens", "gt5", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then return whether all values are distinct.", "solution": "def op_evens_gt5_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return len(r) == len(set(r))", "tests": "assert op_evens_gt5_alldistinct([1, 2, 3, 4]) == True\nassert op_evens_gt5_alldistinct([]) == True\nassert op_evens_gt5_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_evens_gt5_alldistinct([5, 5, 5]) == True\nassert op_evens_gt5_alldistinct([3, 1, 2]) == True\nassert op_evens_gt5_alldistinct([10]) == True\nassert op_evens_gt5_alldistinct([2, 4, 6]) == True\nassert op_evens_gt5_alldistinct([-7, 12, -7]) == True"}
{"id": "op_padto3_uniq_odds", "entry_point": "op_padto3_uniq_odds", "primitives": ["padto3", "uniq", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_padto3_uniq_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_uniq_odds([]) == []\nassert op_padto3_uniq_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_padto3_uniq_odds([5, 5, 5]) == [5]\nassert op_padto3_uniq_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_uniq_odds([10]) == []\nassert op_padto3_uniq_odds([2, 4, 6]) == []\nassert op_padto3_uniq_odds([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_double_sortd", "entry_point": "op_padto3_double_sortd", "primitives": ["padto3", "double", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then sort descending.", "solution": "def op_padto3_double_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_padto3_double_sortd([]) == [0, 0, 0]\nassert op_padto3_double_sortd([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_padto3_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_padto3_double_sortd([10]) == [20, 0, 0]\nassert op_padto3_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_padto3_double_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_sorta_oremptyzero_dropzeros", "entry_point": "op_sorta_oremptyzero_dropzeros", "primitives": ["sorta", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then drop the zeros.", "solution": "def op_sorta_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_oremptyzero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_oremptyzero_dropzeros([]) == []\nassert op_sorta_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_sorta_oremptyzero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_oremptyzero_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_oremptyzero_dropzeros([10]) == [10]\nassert op_sorta_oremptyzero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_oremptyzero_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_gt5_rev_first3", "entry_point": "op_gt5_rev_first3", "primitives": ["gt5", "rev", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then keep only the first three.", "solution": "def op_gt5_rev_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    r = r[:3]\n    return r", "tests": "assert op_gt5_rev_first3([1, 2, 3, 4]) == []\nassert op_gt5_rev_first3([]) == []\nassert op_gt5_rev_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_rev_first3([5, 5, 5]) == []\nassert op_gt5_rev_first3([3, 1, 2]) == []\nassert op_gt5_rev_first3([10]) == [10]\nassert op_gt5_rev_first3([2, 4, 6]) == [6]\nassert op_gt5_rev_first3([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_clamp10_dropzeros", "entry_point": "op_takewhilepos_clamp10_dropzeros", "primitives": ["takewhilepos", "clamp10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then drop the zeros.", "solution": "def op_takewhilepos_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_clamp10_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_clamp10_dropzeros([]) == []\nassert op_takewhilepos_clamp10_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_clamp10_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_clamp10_dropzeros([10]) == [10]\nassert op_takewhilepos_clamp10_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_clamp10_dropzeros([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_double_trimends", "entry_point": "op_dropwhileneg_double_trimends", "primitives": ["dropwhileneg", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then drop the first and last elements.", "solution": "def op_dropwhileneg_double_trimends(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropwhileneg_double_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_dropwhileneg_double_trimends([]) == []\nassert op_dropwhileneg_double_trimends([-2, -1, 0, 1, 2]) == [2]\nassert op_dropwhileneg_double_trimends([5, 5, 5]) == [10]\nassert op_dropwhileneg_double_trimends([3, 1, 2]) == [2]\nassert op_dropwhileneg_double_trimends([10]) == []\nassert op_dropwhileneg_double_trimends([2, 4, 6]) == [8]\nassert op_dropwhileneg_double_trimends([-7, 12, -7]) == []"}
{"id": "op_clamp10_sortd_last3", "entry_point": "op_clamp10_sortd_last3", "primitives": ["clamp10", "sortd", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then keep only the last three.", "solution": "def op_clamp10_sortd_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_sortd_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_clamp10_sortd_last3([]) == []\nassert op_clamp10_sortd_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_clamp10_sortd_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortd_last3([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_sortd_last3([10]) == [10]\nassert op_clamp10_sortd_last3([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_sortd_last3([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_takewhilepos_first3_min", "entry_point": "op_takewhilepos_first3_min", "primitives": ["takewhilepos", "first3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_first3_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_first3_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_first3_min([]) == 0\nassert op_takewhilepos_first3_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_first3_min([5, 5, 5]) == 5\nassert op_takewhilepos_first3_min([3, 1, 2]) == 1\nassert op_takewhilepos_first3_min([10]) == 10\nassert op_takewhilepos_first3_min([2, 4, 6]) == 2\nassert op_takewhilepos_first3_min([-7, 12, -7]) == 0"}
{"id": "op_ages_evens_dropfirst", "entry_point": "op_ages_evens_dropfirst", "primitives": ["ages", "evens", "dropfirst"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then drop the first element.", "solution": "def op_ages_evens_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_ages_evens_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12]\nassert op_ages_evens_dropfirst([]) == []\nassert op_ages_evens_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_evens_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_gt5_dropfirst_pos", "entry_point": "op_gt5_dropfirst_pos", "primitives": ["gt5", "dropfirst", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then keep the positive numbers.", "solution": "def op_gt5_dropfirst_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_dropfirst_pos([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_pos([]) == []\nassert op_gt5_dropfirst_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_pos([5, 5, 5]) == []\nassert op_gt5_dropfirst_pos([3, 1, 2]) == []\nassert op_gt5_dropfirst_pos([10]) == []\nassert op_gt5_dropfirst_pos([2, 4, 6]) == []\nassert op_gt5_dropfirst_pos([-7, 12, -7]) == []"}
{"id": "op_inc_neg_dropzeros", "entry_point": "op_inc_neg_dropzeros", "primitives": ["inc", "neg", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then drop the zeros.", "solution": "def op_inc_neg_dropzeros(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_inc_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_inc_neg_dropzeros([]) == []\nassert op_inc_neg_dropzeros([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_dropzeros([5, 5, 5]) == []\nassert op_inc_neg_dropzeros([3, 1, 2]) == []\nassert op_inc_neg_dropzeros([10]) == []\nassert op_inc_neg_dropzeros([2, 4, 6]) == []\nassert op_inc_neg_dropzeros([-7, 12, -7]) == [-6, -6]"}
{"id": "op_odds_clamp10_dropwhileneg", "entry_point": "op_odds_clamp10_dropwhileneg", "primitives": ["odds", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then drop the leading negative values.", "solution": "def op_odds_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_odds_clamp10_dropwhileneg([1, 2, 3, 4]) == [1, 3]\nassert op_odds_clamp10_dropwhileneg([]) == []\nassert op_odds_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_clamp10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_odds_clamp10_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_odds_clamp10_dropwhileneg([10]) == []\nassert op_odds_clamp10_dropwhileneg([2, 4, 6]) == []\nassert op_odds_clamp10_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_sortlen_lower_uniqs", "entry_point": "op_sortlen_lower_uniqs", "primitives": ["sortlen", "lower", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then lowercase each string, then drop duplicate strings keeping the first.", "solution": "def op_sortlen_lower_uniqs(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortlen_lower_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_sortlen_lower_uniqs([]) == []\nassert op_sortlen_lower_uniqs(['  a ', '', 'BC', 'bc']) == ['', 'bc', '  a ']\nassert op_sortlen_lower_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_sortlen_lower_uniqs(['x']) == ['x']\nassert op_sortlen_lower_uniqs(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_last3_add10_max", "entry_point": "op_last3_add10_max", "primitives": ["last3", "add10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then return the maximum (0 if empty).", "solution": "def op_last3_add10_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return max(r) if r else 0", "tests": "assert op_last3_add10_max([1, 2, 3, 4]) == 14\nassert op_last3_add10_max([]) == 0\nassert op_last3_add10_max([-2, -1, 0, 1, 2]) == 12\nassert op_last3_add10_max([5, 5, 5]) == 15\nassert op_last3_add10_max([3, 1, 2]) == 13\nassert op_last3_add10_max([10]) == 20\nassert op_last3_add10_max([2, 4, 6]) == 16\nassert op_last3_add10_max([-7, 12, -7]) == 22"}
{"id": "op_names_nonempty_strip", "entry_point": "op_names_nonempty_strip", "primitives": ["names", "nonempty", "strip"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop empty strings, then trim whitespace from each.", "solution": "def op_names_nonempty_strip(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if s]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_names_nonempty_strip([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_nonempty_strip([]) == []\nassert op_names_nonempty_strip([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_nonempty_strip([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_absval_sorta_firsteven", "entry_point": "op_absval_sorta_firsteven", "primitives": ["absval", "sorta", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then return the first even value (0 if none).", "solution": "def op_absval_sorta_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_sorta_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_sorta_firsteven([]) == 0\nassert op_absval_sorta_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_absval_sorta_firsteven([5, 5, 5]) == 0\nassert op_absval_sorta_firsteven([3, 1, 2]) == 2\nassert op_absval_sorta_firsteven([10]) == 10\nassert op_absval_sorta_firsteven([2, 4, 6]) == 2\nassert op_absval_sorta_firsteven([-7, 12, -7]) == 12"}
{"id": "op_inc_rev_oremptyzero", "entry_point": "op_inc_rev_oremptyzero", "primitives": ["inc", "rev", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then if empty, use a single zero.", "solution": "def op_inc_rev_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_rev_oremptyzero([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_rev_oremptyzero([]) == [0]\nassert op_inc_rev_oremptyzero([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_rev_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_rev_oremptyzero([3, 1, 2]) == [3, 2, 4]\nassert op_inc_rev_oremptyzero([10]) == [11]\nassert op_inc_rev_oremptyzero([2, 4, 6]) == [7, 5, 3]\nassert op_inc_rev_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_ages_clamp10_anyeven", "entry_point": "op_ages_clamp10_anyeven", "primitives": ["ages", "clamp10", "anyeven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then return whether any value is even.", "solution": "def op_ages_clamp10_anyeven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_ages_clamp10_anyeven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_clamp10_anyeven([]) == False\nassert op_ages_clamp10_anyeven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_clamp10_anyeven([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_sortabs_dec_trimends", "entry_point": "op_sortabs_dec_trimends", "primitives": ["sortabs", "dec", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then drop the first and last elements.", "solution": "def op_sortabs_dec_trimends(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortabs_dec_trimends([1, 2, 3, 4]) == [1, 2]\nassert op_sortabs_dec_trimends([]) == []\nassert op_sortabs_dec_trimends([-2, -1, 0, 1, 2]) == [-2, 0, -3]\nassert op_sortabs_dec_trimends([5, 5, 5]) == [4]\nassert op_sortabs_dec_trimends([3, 1, 2]) == [1]\nassert op_sortabs_dec_trimends([10]) == []\nassert op_sortabs_dec_trimends([2, 4, 6]) == [3]\nassert op_sortabs_dec_trimends([-7, 12, -7]) == [-8]"}
{"id": "op_evens_dropzeros_issorted", "entry_point": "op_evens_dropzeros_issorted", "primitives": ["evens", "dropzeros", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_evens_dropzeros_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_evens_dropzeros_issorted([1, 2, 3, 4]) == True\nassert op_evens_dropzeros_issorted([]) == True\nassert op_evens_dropzeros_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_dropzeros_issorted([5, 5, 5]) == True\nassert op_evens_dropzeros_issorted([3, 1, 2]) == True\nassert op_evens_dropzeros_issorted([10]) == True\nassert op_evens_dropzeros_issorted([2, 4, 6]) == True\nassert op_evens_dropzeros_issorted([-7, 12, -7]) == True"}
{"id": "op_clamp10_sortd_takewhilepos", "entry_point": "op_clamp10_sortd_takewhilepos", "primitives": ["clamp10", "sortd", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then take values while they are positive.", "solution": "def op_clamp10_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_clamp10_sortd_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_sortd_takewhilepos([]) == []\nassert op_clamp10_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_sortd_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortd_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_sortd_takewhilepos([10]) == [10]\nassert op_clamp10_sortd_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_sortd_takewhilepos([-7, 12, -7]) == [10]"}
{"id": "op_inc_clamp10_add10", "entry_point": "op_inc_clamp10_add10", "primitives": ["inc", "clamp10", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then add ten to each.", "solution": "def op_inc_clamp10_add10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_inc_clamp10_add10([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_clamp10_add10([]) == []\nassert op_inc_clamp10_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_clamp10_add10([5, 5, 5]) == [16, 16, 16]\nassert op_inc_clamp10_add10([3, 1, 2]) == [14, 12, 13]\nassert op_inc_clamp10_add10([10]) == [20]\nassert op_inc_clamp10_add10([2, 4, 6]) == [13, 15, 17]\nassert op_inc_clamp10_add10([-7, 12, -7]) == [4, 20, 4]"}
{"id": "op_add10_odds_negate", "entry_point": "op_add10_odds_negate", "primitives": ["add10", "odds", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then negate each.", "solution": "def op_add10_odds_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_odds_negate([1, 2, 3, 4]) == [-11, -13]\nassert op_add10_odds_negate([]) == []\nassert op_add10_odds_negate([-2, -1, 0, 1, 2]) == [-9, -11]\nassert op_add10_odds_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_odds_negate([3, 1, 2]) == [-13, -11]\nassert op_add10_odds_negate([10]) == []\nassert op_add10_odds_negate([2, 4, 6]) == []\nassert op_add10_odds_negate([-7, 12, -7]) == [-3, -3]"}
{"id": "op_div3_evens_allpos", "entry_point": "op_div3_evens_allpos", "primitives": ["div3", "evens", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then return whether all values are positive.", "solution": "def op_div3_evens_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_div3_evens_allpos([1, 2, 3, 4]) == True\nassert op_div3_evens_allpos([]) == True\nassert op_div3_evens_allpos([-2, -1, 0, 1, 2]) == False\nassert op_div3_evens_allpos([5, 5, 5]) == True\nassert op_div3_evens_allpos([3, 1, 2]) == True\nassert op_div3_evens_allpos([10]) == True\nassert op_div3_evens_allpos([2, 4, 6]) == True\nassert op_div3_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_evens_gt5", "entry_point": "op_inc_evens_gt5", "primitives": ["inc", "evens", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then keep values greater than five.", "solution": "def op_inc_evens_gt5(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_inc_evens_gt5([1, 2, 3, 4]) == []\nassert op_inc_evens_gt5([]) == []\nassert op_inc_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_inc_evens_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_inc_evens_gt5([3, 1, 2]) == []\nassert op_inc_evens_gt5([10]) == []\nassert op_inc_evens_gt5([2, 4, 6]) == []\nassert op_inc_evens_gt5([-7, 12, -7]) == []"}
{"id": "op_dropfirst_sortd_haszero", "entry_point": "op_dropfirst_sortd_haszero", "primitives": ["dropfirst", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then return whether the list contains a zero.", "solution": "def op_dropfirst_sortd_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_dropfirst_sortd_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_sortd_haszero([]) == False\nassert op_dropfirst_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_sortd_haszero([5, 5, 5]) == False\nassert op_dropfirst_sortd_haszero([3, 1, 2]) == False\nassert op_dropfirst_sortd_haszero([10]) == False\nassert op_dropfirst_sortd_haszero([2, 4, 6]) == False\nassert op_dropfirst_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_sortlen_dropshort_firstchar", "entry_point": "op_sortlen_dropshort_firstchar", "primitives": ["sortlen", "dropshort", "firstchar"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop strings shorter than three characters, then keep the first character of each (dropping empties).", "solution": "def op_sortlen_dropshort_firstchar(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortlen_dropshort_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_sortlen_dropshort_firstchar([]) == []\nassert op_sortlen_dropshort_firstchar(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_sortlen_dropshort_firstchar(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_sortlen_dropshort_firstchar(['x']) == []\nassert op_sortlen_dropshort_firstchar(['abc', 'de', '']) == ['a']"}
{"id": "op_absval_odds_dropzeros", "entry_point": "op_absval_odds_dropzeros", "primitives": ["absval", "odds", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers, then drop the zeros.", "solution": "def op_absval_odds_dropzeros(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_absval_odds_dropzeros([1, 2, 3, 4]) == [1, 3]\nassert op_absval_odds_dropzeros([]) == []\nassert op_absval_odds_dropzeros([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_odds_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_absval_odds_dropzeros([3, 1, 2]) == [3, 1]\nassert op_absval_odds_dropzeros([10]) == []\nassert op_absval_odds_dropzeros([2, 4, 6]) == []\nassert op_absval_odds_dropzeros([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropwhileneg_gt5_prod", "entry_point": "op_dropwhileneg_gt5_prod", "primitives": ["dropwhileneg", "gt5", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep values greater than five, then return their product.", "solution": "def op_dropwhileneg_gt5_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 5]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_gt5_prod([1, 2, 3, 4]) == 1\nassert op_dropwhileneg_gt5_prod([]) == 1\nassert op_dropwhileneg_gt5_prod([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_gt5_prod([5, 5, 5]) == 1\nassert op_dropwhileneg_gt5_prod([3, 1, 2]) == 1\nassert op_dropwhileneg_gt5_prod([10]) == 10\nassert op_dropwhileneg_gt5_prod([2, 4, 6]) == 6\nassert op_dropwhileneg_gt5_prod([-7, 12, -7]) == 12"}
{"id": "op_first3_pos_sortd", "entry_point": "op_first3_pos_sortd", "primitives": ["first3", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then sort descending.", "solution": "def op_first3_pos_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_pos_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_pos_sortd([]) == []\nassert op_first3_pos_sortd([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_first3_pos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_first3_pos_sortd([10]) == [10]\nassert op_first3_pos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_first3_pos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_double_gt5_uniq", "entry_point": "op_double_gt5_uniq", "primitives": ["double", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_double_gt5_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_gt5_uniq([1, 2, 3, 4]) == [6, 8]\nassert op_double_gt5_uniq([]) == []\nassert op_double_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_uniq([5, 5, 5]) == [10]\nassert op_double_gt5_uniq([3, 1, 2]) == [6]\nassert op_double_gt5_uniq([10]) == [20]\nassert op_double_gt5_uniq([2, 4, 6]) == [8, 12]\nassert op_double_gt5_uniq([-7, 12, -7]) == [24]"}
{"id": "op_square_dropwhileneg_firsteven", "entry_point": "op_square_dropwhileneg_firsteven", "primitives": ["square", "dropwhileneg", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then return the first even value (0 if none).", "solution": "def op_square_dropwhileneg_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_dropwhileneg_firsteven([1, 2, 3, 4]) == 4\nassert op_square_dropwhileneg_firsteven([]) == 0\nassert op_square_dropwhileneg_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_square_dropwhileneg_firsteven([5, 5, 5]) == 0\nassert op_square_dropwhileneg_firsteven([3, 1, 2]) == 4\nassert op_square_dropwhileneg_firsteven([10]) == 100\nassert op_square_dropwhileneg_firsteven([2, 4, 6]) == 4\nassert op_square_dropwhileneg_firsteven([-7, 12, -7]) == 144"}
{"id": "op_div3_odds_alldistinct", "entry_point": "op_div3_odds_alldistinct", "primitives": ["div3", "odds", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then return whether all values are distinct.", "solution": "def op_div3_odds_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_div3_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_odds_alldistinct([]) == True\nassert op_div3_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_odds_alldistinct([5, 5, 5]) == True\nassert op_div3_odds_alldistinct([3, 1, 2]) == True\nassert op_div3_odds_alldistinct([10]) == True\nassert op_div3_odds_alldistinct([2, 4, 6]) == True\nassert op_div3_odds_alldistinct([-7, 12, -7]) == True"}
{"id": "op_padto3_sortd_counteven", "entry_point": "op_padto3_sortd_counteven", "primitives": ["padto3", "sortd", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then return how many values are even.", "solution": "def op_padto3_sortd_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_sortd_counteven([1, 2, 3, 4]) == 2\nassert op_padto3_sortd_counteven([]) == 3\nassert op_padto3_sortd_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_padto3_sortd_counteven([5, 5, 5]) == 0\nassert op_padto3_sortd_counteven([3, 1, 2]) == 1\nassert op_padto3_sortd_counteven([10]) == 3\nassert op_padto3_sortd_counteven([2, 4, 6]) == 3\nassert op_padto3_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_last3_clamp10", "entry_point": "op_first3_last3_clamp10", "primitives": ["first3", "last3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then cap each value at 10.", "solution": "def op_first3_last3_clamp10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_first3_last3_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_last3_clamp10([]) == []\nassert op_first3_last3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_last3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_first3_last3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_first3_last3_clamp10([10]) == [10]\nassert op_first3_last3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_first3_last3_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_sortabs_double_dec", "entry_point": "op_sortabs_double_dec", "primitives": ["sortabs", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then subtract one from each.", "solution": "def op_sortabs_double_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_double_dec([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_sortabs_double_dec([]) == []\nassert op_sortabs_double_dec([-2, -1, 0, 1, 2]) == [-1, -3, 1, -5, 3]\nassert op_sortabs_double_dec([5, 5, 5]) == [9, 9, 9]\nassert op_sortabs_double_dec([3, 1, 2]) == [1, 3, 5]\nassert op_sortabs_double_dec([10]) == [19]\nassert op_sortabs_double_dec([2, 4, 6]) == [3, 7, 11]\nassert op_sortabs_double_dec([-7, 12, -7]) == [-15, -15, 23]"}
{"id": "op_clamp10_sortabs_trimends", "entry_point": "op_clamp10_sortabs_trimends", "primitives": ["clamp10", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then drop the first and last elements.", "solution": "def op_clamp10_sortabs_trimends(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_clamp10_sortabs_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_clamp10_sortabs_trimends([]) == []\nassert op_clamp10_sortabs_trimends([-2, -1, 0, 1, 2]) == [-1, 1, -2]\nassert op_clamp10_sortabs_trimends([5, 5, 5]) == [5]\nassert op_clamp10_sortabs_trimends([3, 1, 2]) == [2]\nassert op_clamp10_sortabs_trimends([10]) == []\nassert op_clamp10_sortabs_trimends([2, 4, 6]) == [4]\nassert op_clamp10_sortabs_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_padto3_odds_inc", "entry_point": "op_padto3_odds_inc", "primitives": ["padto3", "odds", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then add one to each.", "solution": "def op_padto3_odds_inc(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_padto3_odds_inc([1, 2, 3, 4]) == [2, 4]\nassert op_padto3_odds_inc([]) == []\nassert op_padto3_odds_inc([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_padto3_odds_inc([5, 5, 5]) == [6, 6, 6]\nassert op_padto3_odds_inc([3, 1, 2]) == [4, 2]\nassert op_padto3_odds_inc([10]) == []\nassert op_padto3_odds_inc([2, 4, 6]) == []\nassert op_padto3_odds_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_absval_uniq_sortd", "entry_point": "op_absval_uniq_sortd", "primitives": ["absval", "uniq", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_absval_uniq_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_uniq_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_uniq_sortd([]) == []\nassert op_absval_uniq_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_uniq_sortd([5, 5, 5]) == [5]\nassert op_absval_uniq_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_absval_uniq_sortd([10]) == [10]\nassert op_absval_uniq_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_absval_uniq_sortd([-7, 12, -7]) == [12, 7]"}
{"id": "op_dropfirst_dropzeros_padto3", "entry_point": "op_dropfirst_dropzeros_padto3", "primitives": ["dropfirst", "dropzeros", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_dropzeros_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_dropzeros_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dropzeros_padto3([]) == [0, 0, 0]\nassert op_dropfirst_dropzeros_padto3([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropfirst_dropzeros_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_dropzeros_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_dropzeros_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_dropzeros_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_dropzeros_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_inc_sortd_dec", "entry_point": "op_inc_sortd_dec", "primitives": ["inc", "sortd", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then subtract one from each.", "solution": "def op_inc_sortd_dec(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_inc_sortd_dec([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_inc_sortd_dec([]) == []\nassert op_inc_sortd_dec([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_inc_sortd_dec([5, 5, 5]) == [5, 5, 5]\nassert op_inc_sortd_dec([3, 1, 2]) == [3, 2, 1]\nassert op_inc_sortd_dec([10]) == [10]\nassert op_inc_sortd_dec([2, 4, 6]) == [6, 4, 2]\nassert op_inc_sortd_dec([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_first3_oremptyzero_len", "entry_point": "op_first3_oremptyzero_len", "primitives": ["first3", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then return how many remain.", "solution": "def op_first3_oremptyzero_len(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_first3_oremptyzero_len([1, 2, 3, 4]) == 3\nassert op_first3_oremptyzero_len([]) == 1\nassert op_first3_oremptyzero_len([-2, -1, 0, 1, 2]) == 3\nassert op_first3_oremptyzero_len([5, 5, 5]) == 3\nassert op_first3_oremptyzero_len([3, 1, 2]) == 3\nassert op_first3_oremptyzero_len([10]) == 1\nassert op_first3_oremptyzero_len([2, 4, 6]) == 3\nassert op_first3_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_dropwhileneg_issorted", "entry_point": "op_sortd_dropwhileneg_issorted", "primitives": ["sortd", "dropwhileneg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_sortd_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_sortd_dropwhileneg_issorted([1, 2, 3, 4]) == False\nassert op_sortd_dropwhileneg_issorted([]) == True\nassert op_sortd_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == False\nassert op_sortd_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_sortd_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_sortd_dropwhileneg_issorted([10]) == True\nassert op_sortd_dropwhileneg_issorted([2, 4, 6]) == False\nassert op_sortd_dropwhileneg_issorted([-7, 12, -7]) == False"}
{"id": "op_sortalpha_lower_longest", "entry_point": "op_sortalpha_lower_longest", "primitives": ["sortalpha", "lower", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then lowercase each string, then return the longest string (empty if none).", "solution": "def op_sortalpha_lower_longest(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.lower() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_sortalpha_lower_longest(['Hello', 'world']) == 'hello'\nassert op_sortalpha_lower_longest([]) == ''\nassert op_sortalpha_lower_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_sortalpha_lower_longest(['one', 'one', 'Two']) == 'two'\nassert op_sortalpha_lower_longest(['x']) == 'x'\nassert op_sortalpha_lower_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_clamp10_last3_max", "entry_point": "op_clamp10_last3_max", "primitives": ["clamp10", "last3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_clamp10_last3_max(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_clamp10_last3_max([1, 2, 3, 4]) == 4\nassert op_clamp10_last3_max([]) == 0\nassert op_clamp10_last3_max([-2, -1, 0, 1, 2]) == 2\nassert op_clamp10_last3_max([5, 5, 5]) == 5\nassert op_clamp10_last3_max([3, 1, 2]) == 3\nassert op_clamp10_last3_max([10]) == 10\nassert op_clamp10_last3_max([2, 4, 6]) == 6\nassert op_clamp10_last3_max([-7, 12, -7]) == 10"}
{"id": "op_evens_negate_takewhilepos", "entry_point": "op_evens_negate_takewhilepos", "primitives": ["evens", "negate", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then negate each, then take values while they are positive.", "solution": "def op_evens_negate_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_evens_negate_takewhilepos([1, 2, 3, 4]) == []\nassert op_evens_negate_takewhilepos([]) == []\nassert op_evens_negate_takewhilepos([-2, -1, 0, 1, 2]) == [2]\nassert op_evens_negate_takewhilepos([5, 5, 5]) == []\nassert op_evens_negate_takewhilepos([3, 1, 2]) == []\nassert op_evens_negate_takewhilepos([10]) == []\nassert op_evens_negate_takewhilepos([2, 4, 6]) == []\nassert op_evens_negate_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_beforezero_uniq_min", "entry_point": "op_beforezero_uniq_min", "primitives": ["beforezero", "uniq", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence, then return the minimum (0 if empty).", "solution": "def op_beforezero_uniq_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return min(r) if r else 0", "tests": "assert op_beforezero_uniq_min([1, 2, 3, 4]) == 1\nassert op_beforezero_uniq_min([]) == 0\nassert op_beforezero_uniq_min([-2, -1, 0, 1, 2]) == -2\nassert op_beforezero_uniq_min([5, 5, 5]) == 5\nassert op_beforezero_uniq_min([3, 1, 2]) == 1\nassert op_beforezero_uniq_min([10]) == 10\nassert op_beforezero_uniq_min([2, 4, 6]) == 2\nassert op_beforezero_uniq_min([-7, 12, -7]) == -7"}
{"id": "op_dropfirst_inc_odds", "entry_point": "op_dropfirst_inc_odds", "primitives": ["dropfirst", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add one to each, then keep the odd numbers.", "solution": "def op_dropfirst_inc_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_inc_odds([1, 2, 3, 4]) == [3, 5]\nassert op_dropfirst_inc_odds([]) == []\nassert op_dropfirst_inc_odds([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_dropfirst_inc_odds([5, 5, 5]) == []\nassert op_dropfirst_inc_odds([3, 1, 2]) == [3]\nassert op_dropfirst_inc_odds([10]) == []\nassert op_dropfirst_inc_odds([2, 4, 6]) == [5, 7]\nassert op_dropfirst_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_dropzeros_absval_sorta", "entry_point": "op_dropzeros_absval_sorta", "primitives": ["dropzeros", "absval", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then sort ascending.", "solution": "def op_dropzeros_absval_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropzeros_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_absval_sorta([]) == []\nassert op_dropzeros_absval_sorta([-2, -1, 0, 1, 2]) == [1, 1, 2, 2]\nassert op_dropzeros_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_absval_sorta([10]) == [10]\nassert op_dropzeros_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_div3_odds_sortd", "entry_point": "op_div3_odds_sortd", "primitives": ["div3", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then sort descending.", "solution": "def op_div3_odds_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_div3_odds_sortd([1, 2, 3, 4]) == [3]\nassert op_div3_odds_sortd([]) == []\nassert op_div3_odds_sortd([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_sortd([5, 5, 5]) == []\nassert op_div3_odds_sortd([3, 1, 2]) == [3]\nassert op_div3_odds_sortd([10]) == []\nassert op_div3_odds_sortd([2, 4, 6]) == []\nassert op_div3_odds_sortd([-7, 12, -7]) == []"}
{"id": "op_sortabs_sorta_dropwhileneg", "entry_point": "op_sortabs_sorta_dropwhileneg", "primitives": ["sortabs", "sorta", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then drop the leading negative values.", "solution": "def op_sortabs_sorta_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortabs_sorta_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_sorta_dropwhileneg([]) == []\nassert op_sortabs_sorta_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sortabs_sorta_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_sorta_dropwhileneg([10]) == [10]\nassert op_sortabs_sorta_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_sorta_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_padto3_sortd_square", "entry_point": "op_padto3_sortd_square", "primitives": ["padto3", "sortd", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort descending, then square each.", "solution": "def op_padto3_sortd_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_sortd_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_padto3_sortd_square([]) == [0, 0, 0]\nassert op_padto3_sortd_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_padto3_sortd_square([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_sortd_square([3, 1, 2]) == [9, 4, 1]\nassert op_padto3_sortd_square([10]) == [100, 0, 0]\nassert op_padto3_sortd_square([2, 4, 6]) == [36, 16, 4]\nassert op_padto3_sortd_square([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_pos_beforezero_inc", "entry_point": "op_pos_beforezero_inc", "primitives": ["pos", "beforezero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then add one to each.", "solution": "def op_pos_beforezero_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_pos_beforezero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_pos_beforezero_inc([]) == []\nassert op_pos_beforezero_inc([-2, -1, 0, 1, 2]) == [2, 3]\nassert op_pos_beforezero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_pos_beforezero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_pos_beforezero_inc([10]) == [11]\nassert op_pos_beforezero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_pos_beforezero_inc([-7, 12, -7]) == [13]"}
{"id": "op_sortd_double_dropzeros", "entry_point": "op_sortd_double_dropzeros", "primitives": ["sortd", "double", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then drop the zeros.", "solution": "def op_sortd_double_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortd_double_dropzeros([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_double_dropzeros([]) == []\nassert op_sortd_double_dropzeros([-2, -1, 0, 1, 2]) == [4, 2, -2, -4]\nassert op_sortd_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_double_dropzeros([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_double_dropzeros([10]) == [20]\nassert op_sortd_double_dropzeros([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_double_dropzeros([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_gt5_inc_dec", "entry_point": "op_gt5_inc_dec", "primitives": ["gt5", "inc", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then subtract one from each.", "solution": "def op_gt5_inc_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_gt5_inc_dec([1, 2, 3, 4]) == []\nassert op_gt5_inc_dec([]) == []\nassert op_gt5_inc_dec([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_dec([5, 5, 5]) == []\nassert op_gt5_inc_dec([3, 1, 2]) == []\nassert op_gt5_inc_dec([10]) == [10]\nassert op_gt5_inc_dec([2, 4, 6]) == [6]\nassert op_gt5_inc_dec([-7, 12, -7]) == [12]"}
{"id": "op_absval_add10_anyeven", "entry_point": "op_absval_add10_anyeven", "primitives": ["absval", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then return whether any value is even.", "solution": "def op_absval_add10_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_add10_anyeven([1, 2, 3, 4]) == True\nassert op_absval_add10_anyeven([]) == False\nassert op_absval_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_add10_anyeven([5, 5, 5]) == False\nassert op_absval_add10_anyeven([3, 1, 2]) == True\nassert op_absval_add10_anyeven([10]) == True\nassert op_absval_add10_anyeven([2, 4, 6]) == True\nassert op_absval_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_first3_last3_sortd", "entry_point": "op_first3_last3_sortd", "primitives": ["first3", "last3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then sort descending.", "solution": "def op_first3_last3_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_last3_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_last3_sortd([]) == []\nassert op_first3_last3_sortd([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_last3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_first3_last3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_first3_last3_sortd([10]) == [10]\nassert op_first3_last3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_first3_last3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_clamp10_sorta_first3", "entry_point": "op_clamp10_sorta_first3", "primitives": ["clamp10", "sorta", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then keep only the first three.", "solution": "def op_clamp10_sorta_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_sorta_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_sorta_first3([]) == []\nassert op_clamp10_sorta_first3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_clamp10_sorta_first3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sorta_first3([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sorta_first3([10]) == [10]\nassert op_clamp10_sorta_first3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sorta_first3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_beforezero_trimends_takewhilepos", "entry_point": "op_beforezero_trimends_takewhilepos", "primitives": ["beforezero", "trimends", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then take values while they are positive.", "solution": "def op_beforezero_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_trimends_takewhilepos([1, 2, 3, 4]) == [2, 3]\nassert op_beforezero_trimends_takewhilepos([]) == []\nassert op_beforezero_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_trimends_takewhilepos([5, 5, 5]) == [5]\nassert op_beforezero_trimends_takewhilepos([3, 1, 2]) == [1]\nassert op_beforezero_trimends_takewhilepos([10]) == []\nassert op_beforezero_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_beforezero_trimends_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_last3_double", "entry_point": "op_dropzeros_last3_double", "primitives": ["dropzeros", "last3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then double each.", "solution": "def op_dropzeros_last3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_last3_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropzeros_last3_double([]) == []\nassert op_dropzeros_last3_double([-2, -1, 0, 1, 2]) == [-2, 2, 4]\nassert op_dropzeros_last3_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_last3_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_last3_double([10]) == [20]\nassert op_dropzeros_last3_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_last3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_takewhilepos_inc_square", "entry_point": "op_takewhilepos_inc_square", "primitives": ["takewhilepos", "inc", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add one to each, then square each.", "solution": "def op_takewhilepos_inc_square(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_takewhilepos_inc_square([1, 2, 3, 4]) == [4, 9, 16, 25]\nassert op_takewhilepos_inc_square([]) == []\nassert op_takewhilepos_inc_square([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_inc_square([5, 5, 5]) == [36, 36, 36]\nassert op_takewhilepos_inc_square([3, 1, 2]) == [16, 4, 9]\nassert op_takewhilepos_inc_square([10]) == [121]\nassert op_takewhilepos_inc_square([2, 4, 6]) == [9, 25, 49]\nassert op_takewhilepos_inc_square([-7, 12, -7]) == []"}
{"id": "op_ages_trimends_uniq", "entry_point": "op_ages_trimends_uniq", "primitives": ["ages", "trimends", "uniq"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_ages_trimends_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_trimends_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_uniq([]) == []\nassert op_ages_trimends_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_trimends_uniq([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_odds_sorta_prod", "entry_point": "op_odds_sorta_prod", "primitives": ["odds", "sorta", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then return their product.", "solution": "def op_odds_sorta_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return __import__('math').prod(r)", "tests": "assert op_odds_sorta_prod([1, 2, 3, 4]) == 3\nassert op_odds_sorta_prod([]) == 1\nassert op_odds_sorta_prod([-2, -1, 0, 1, 2]) == -1\nassert op_odds_sorta_prod([5, 5, 5]) == 125\nassert op_odds_sorta_prod([3, 1, 2]) == 3\nassert op_odds_sorta_prod([10]) == 1\nassert op_odds_sorta_prod([2, 4, 6]) == 1\nassert op_odds_sorta_prod([-7, 12, -7]) == 49"}
{"id": "op_sortabs_absval_anyeven", "entry_point": "op_sortabs_absval_anyeven", "primitives": ["sortabs", "absval", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then return whether any value is even.", "solution": "def op_sortabs_absval_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_absval_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_absval_anyeven([]) == False\nassert op_sortabs_absval_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_absval_anyeven([5, 5, 5]) == False\nassert op_sortabs_absval_anyeven([3, 1, 2]) == True\nassert op_sortabs_absval_anyeven([10]) == True\nassert op_sortabs_absval_anyeven([2, 4, 6]) == True\nassert op_sortabs_absval_anyeven([-7, 12, -7]) == True"}
{"id": "op_gt5_double_pos", "entry_point": "op_gt5_double_pos", "primitives": ["gt5", "double", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then keep the positive numbers.", "solution": "def op_gt5_double_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_double_pos([1, 2, 3, 4]) == []\nassert op_gt5_double_pos([]) == []\nassert op_gt5_double_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_double_pos([5, 5, 5]) == []\nassert op_gt5_double_pos([3, 1, 2]) == []\nassert op_gt5_double_pos([10]) == [20]\nassert op_gt5_double_pos([2, 4, 6]) == [12]\nassert op_gt5_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_trimends_dropwhileneg_double", "entry_point": "op_trimends_dropwhileneg_double", "primitives": ["trimends", "dropwhileneg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values, then double each.", "solution": "def op_trimends_dropwhileneg_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_dropwhileneg_double([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_dropwhileneg_double([]) == []\nassert op_trimends_dropwhileneg_double([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_trimends_dropwhileneg_double([5, 5, 5]) == [10]\nassert op_trimends_dropwhileneg_double([3, 1, 2]) == [2]\nassert op_trimends_dropwhileneg_double([10]) == []\nassert op_trimends_dropwhileneg_double([2, 4, 6]) == [8]\nassert op_trimends_dropwhileneg_double([-7, 12, -7]) == [24]"}
{"id": "op_absval_beforezero_firsteven", "entry_point": "op_absval_beforezero_firsteven", "primitives": ["absval", "beforezero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_absval_beforezero_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_beforezero_firsteven([]) == 0\nassert op_absval_beforezero_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_beforezero_firsteven([5, 5, 5]) == 0\nassert op_absval_beforezero_firsteven([3, 1, 2]) == 2\nassert op_absval_beforezero_firsteven([10]) == 10\nassert op_absval_beforezero_firsteven([2, 4, 6]) == 2\nassert op_absval_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_beforezero_absval_max", "entry_point": "op_beforezero_absval_max", "primitives": ["beforezero", "absval", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_beforezero_absval_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_beforezero_absval_max([1, 2, 3, 4]) == 4\nassert op_beforezero_absval_max([]) == 0\nassert op_beforezero_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_absval_max([5, 5, 5]) == 5\nassert op_beforezero_absval_max([3, 1, 2]) == 3\nassert op_beforezero_absval_max([10]) == 10\nassert op_beforezero_absval_max([2, 4, 6]) == 6\nassert op_beforezero_absval_max([-7, 12, -7]) == 12"}
{"id": "op_odds_absval_sum", "entry_point": "op_odds_absval_sum", "primitives": ["odds", "absval", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then return their sum.", "solution": "def op_odds_absval_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_odds_absval_sum([1, 2, 3, 4]) == 4\nassert op_odds_absval_sum([]) == 0\nassert op_odds_absval_sum([-2, -1, 0, 1, 2]) == 2\nassert op_odds_absval_sum([5, 5, 5]) == 15\nassert op_odds_absval_sum([3, 1, 2]) == 4\nassert op_odds_absval_sum([10]) == 0\nassert op_odds_absval_sum([2, 4, 6]) == 0\nassert op_odds_absval_sum([-7, 12, -7]) == 14"}
{"id": "op_uniq_first3_negate", "entry_point": "op_uniq_first3_negate", "primitives": ["uniq", "first3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the first three, then negate each.", "solution": "def op_uniq_first3_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_first3_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_uniq_first3_negate([]) == []\nassert op_uniq_first3_negate([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_uniq_first3_negate([5, 5, 5]) == [-5]\nassert op_uniq_first3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_first3_negate([10]) == [-10]\nassert op_uniq_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_first3_negate([-7, 12, -7]) == [7, -12]"}
{"id": "op_div3_negate_min", "entry_point": "op_div3_negate_min", "primitives": ["div3", "negate", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then return the minimum (0 if empty).", "solution": "def op_div3_negate_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return min(r) if r else 0", "tests": "assert op_div3_negate_min([1, 2, 3, 4]) == -3\nassert op_div3_negate_min([]) == 0\nassert op_div3_negate_min([-2, -1, 0, 1, 2]) == 0\nassert op_div3_negate_min([5, 5, 5]) == 0\nassert op_div3_negate_min([3, 1, 2]) == -3\nassert op_div3_negate_min([10]) == 0\nassert op_div3_negate_min([2, 4, 6]) == -6\nassert op_div3_negate_min([-7, 12, -7]) == -12"}
{"id": "op_odds_last3_sortabs", "entry_point": "op_odds_last3_sortabs", "primitives": ["odds", "last3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then sort by absolute value.", "solution": "def op_odds_last3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_last3_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_odds_last3_sortabs([]) == []\nassert op_odds_last3_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_last3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_odds_last3_sortabs([3, 1, 2]) == [1, 3]\nassert op_odds_last3_sortabs([10]) == []\nassert op_odds_last3_sortabs([2, 4, 6]) == []\nassert op_odds_last3_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_neg_gt5", "entry_point": "op_uniq_neg_gt5", "primitives": ["uniq", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers, then keep values greater than five.", "solution": "def op_uniq_neg_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_neg_gt5([1, 2, 3, 4]) == []\nassert op_uniq_neg_gt5([]) == []\nassert op_uniq_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_neg_gt5([5, 5, 5]) == []\nassert op_uniq_neg_gt5([3, 1, 2]) == []\nassert op_uniq_neg_gt5([10]) == []\nassert op_uniq_neg_gt5([2, 4, 6]) == []\nassert op_uniq_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_last3_neg_dec", "entry_point": "op_last3_neg_dec", "primitives": ["last3", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then subtract one from each.", "solution": "def op_last3_neg_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_neg_dec([1, 2, 3, 4]) == []\nassert op_last3_neg_dec([]) == []\nassert op_last3_neg_dec([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_dec([5, 5, 5]) == []\nassert op_last3_neg_dec([3, 1, 2]) == []\nassert op_last3_neg_dec([10]) == []\nassert op_last3_neg_dec([2, 4, 6]) == []\nassert op_last3_neg_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_dropzeros_padto3_absval", "entry_point": "op_dropzeros_padto3_absval", "primitives": ["dropzeros", "padto3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_dropzeros_padto3_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_padto3_absval([]) == [0, 0, 0]\nassert op_dropzeros_padto3_absval([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_padto3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_padto3_absval([10]) == [10, 0, 0]\nassert op_dropzeros_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_padto3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_inc_evens_sortd", "entry_point": "op_inc_evens_sortd", "primitives": ["inc", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then sort descending.", "solution": "def op_inc_evens_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_inc_evens_sortd([]) == []\nassert op_inc_evens_sortd([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_inc_evens_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_inc_evens_sortd([3, 1, 2]) == [4, 2]\nassert op_inc_evens_sortd([10]) == []\nassert op_inc_evens_sortd([2, 4, 6]) == []\nassert op_inc_evens_sortd([-7, 12, -7]) == [-6, -6]"}
{"id": "op_ages_dropfirst_allpos", "entry_point": "op_ages_dropfirst_allpos", "primitives": ["ages", "dropfirst", "allpos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then return whether all values are positive.", "solution": "def op_ages_dropfirst_allpos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_ages_dropfirst_allpos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_dropfirst_allpos([]) == True\nassert op_ages_dropfirst_allpos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_dropfirst_allpos([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_div3_pos_dropfirst", "entry_point": "op_div3_pos_dropfirst", "primitives": ["div3", "pos", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then drop the first element.", "solution": "def op_div3_pos_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_div3_pos_dropfirst([1, 2, 3, 4]) == []\nassert op_div3_pos_dropfirst([]) == []\nassert op_div3_pos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_div3_pos_dropfirst([5, 5, 5]) == []\nassert op_div3_pos_dropfirst([3, 1, 2]) == []\nassert op_div3_pos_dropfirst([10]) == []\nassert op_div3_pos_dropfirst([2, 4, 6]) == []\nassert op_div3_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_neg_dropzeros_haszero", "entry_point": "op_neg_dropzeros_haszero", "primitives": ["neg", "dropzeros", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then return whether the list contains a zero.", "solution": "def op_neg_dropzeros_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_neg_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_neg_dropzeros_haszero([]) == False\nassert op_neg_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_dropzeros_haszero([5, 5, 5]) == False\nassert op_neg_dropzeros_haszero([3, 1, 2]) == False\nassert op_neg_dropzeros_haszero([10]) == False\nassert op_neg_dropzeros_haszero([2, 4, 6]) == False\nassert op_neg_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_absval_alldistinct", "entry_point": "op_sorta_absval_alldistinct", "primitives": ["sorta", "absval", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then return whether all values are distinct.", "solution": "def op_sorta_absval_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sorta_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_absval_alldistinct([]) == True\nassert op_sorta_absval_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_sorta_absval_alldistinct([5, 5, 5]) == False\nassert op_sorta_absval_alldistinct([3, 1, 2]) == True\nassert op_sorta_absval_alldistinct([10]) == True\nassert op_sorta_absval_alldistinct([2, 4, 6]) == True\nassert op_sorta_absval_alldistinct([-7, 12, -7]) == False"}
{"id": "op_firstchar_prefixup_dropshort", "entry_point": "op_firstchar_prefixup_dropshort", "primitives": ["firstchar", "prefixup", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then prefix each with a hash, then drop strings shorter than three characters.", "solution": "def op_firstchar_prefixup_dropshort(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_firstchar_prefixup_dropshort(['Hello', 'world']) == []\nassert op_firstchar_prefixup_dropshort([]) == []\nassert op_firstchar_prefixup_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_firstchar_prefixup_dropshort(['one', 'one', 'Two']) == []\nassert op_firstchar_prefixup_dropshort(['x']) == []\nassert op_firstchar_prefixup_dropshort(['abc', 'de', '']) == []"}
{"id": "op_square_sorta_sortd", "entry_point": "op_square_sorta_sortd", "primitives": ["square", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then sort descending.", "solution": "def op_square_sorta_sortd(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_square_sorta_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_sorta_sortd([]) == []\nassert op_square_sorta_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_square_sorta_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_square_sorta_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_square_sorta_sortd([10]) == [100]\nassert op_square_sorta_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_square_sorta_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_odds_trimends_max", "entry_point": "op_odds_trimends_max", "primitives": ["odds", "trimends", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_odds_trimends_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_odds_trimends_max([1, 2, 3, 4]) == 0\nassert op_odds_trimends_max([]) == 0\nassert op_odds_trimends_max([-2, -1, 0, 1, 2]) == 0\nassert op_odds_trimends_max([5, 5, 5]) == 5\nassert op_odds_trimends_max([3, 1, 2]) == 0\nassert op_odds_trimends_max([10]) == 0\nassert op_odds_trimends_max([2, 4, 6]) == 0\nassert op_odds_trimends_max([-7, 12, -7]) == 0"}
{"id": "op_pos_neg_absval", "entry_point": "op_pos_neg_absval", "primitives": ["pos", "neg", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the negative numbers, then take the absolute value of each.", "solution": "def op_pos_neg_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_neg_absval([1, 2, 3, 4]) == []\nassert op_pos_neg_absval([]) == []\nassert op_pos_neg_absval([-2, -1, 0, 1, 2]) == []\nassert op_pos_neg_absval([5, 5, 5]) == []\nassert op_pos_neg_absval([3, 1, 2]) == []\nassert op_pos_neg_absval([10]) == []\nassert op_pos_neg_absval([2, 4, 6]) == []\nassert op_pos_neg_absval([-7, 12, -7]) == []"}
{"id": "op_gt5_add10_dec", "entry_point": "op_gt5_add10_dec", "primitives": ["gt5", "add10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then subtract one from each.", "solution": "def op_gt5_add10_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_gt5_add10_dec([1, 2, 3, 4]) == []\nassert op_gt5_add10_dec([]) == []\nassert op_gt5_add10_dec([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_dec([5, 5, 5]) == []\nassert op_gt5_add10_dec([3, 1, 2]) == []\nassert op_gt5_add10_dec([10]) == [19]\nassert op_gt5_add10_dec([2, 4, 6]) == [15]\nassert op_gt5_add10_dec([-7, 12, -7]) == [21]"}
{"id": "op_beforezero_dropfirst_sortabs", "entry_point": "op_beforezero_dropfirst_sortabs", "primitives": ["beforezero", "dropfirst", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then sort by absolute value.", "solution": "def op_beforezero_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_beforezero_dropfirst_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_dropfirst_sortabs([]) == []\nassert op_beforezero_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_dropfirst_sortabs([5, 5, 5]) == [5, 5]\nassert op_beforezero_dropfirst_sortabs([3, 1, 2]) == [1, 2]\nassert op_beforezero_dropfirst_sortabs([10]) == []\nassert op_beforezero_dropfirst_sortabs([2, 4, 6]) == [4, 6]\nassert op_beforezero_dropfirst_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_div3_odds_anyeven", "entry_point": "op_div3_odds_anyeven", "primitives": ["div3", "odds", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then return whether any value is even.", "solution": "def op_div3_odds_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_odds_anyeven([1, 2, 3, 4]) == False\nassert op_div3_odds_anyeven([]) == False\nassert op_div3_odds_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_div3_odds_anyeven([5, 5, 5]) == False\nassert op_div3_odds_anyeven([3, 1, 2]) == False\nassert op_div3_odds_anyeven([10]) == False\nassert op_div3_odds_anyeven([2, 4, 6]) == False\nassert op_div3_odds_anyeven([-7, 12, -7]) == False"}
{"id": "op_beforezero_uniq_absval", "entry_point": "op_beforezero_uniq_absval", "primitives": ["beforezero", "uniq", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_beforezero_uniq_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_uniq_absval([]) == []\nassert op_beforezero_uniq_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_uniq_absval([5, 5, 5]) == [5]\nassert op_beforezero_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_uniq_absval([10]) == [10]\nassert op_beforezero_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_uniq_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_sortabs_square_takewhilepos", "entry_point": "op_sortabs_square_takewhilepos", "primitives": ["sortabs", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then take values while they are positive.", "solution": "def op_sortabs_square_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortabs_square_takewhilepos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_square_takewhilepos([]) == []\nassert op_sortabs_square_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_square_takewhilepos([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_square_takewhilepos([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_square_takewhilepos([10]) == [100]\nassert op_sortabs_square_takewhilepos([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_square_takewhilepos([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dec_gt5_haszero", "entry_point": "op_dec_gt5_haszero", "primitives": ["dec", "gt5", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then return whether the list contains a zero.", "solution": "def op_dec_gt5_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return 0 in r", "tests": "assert op_dec_gt5_haszero([1, 2, 3, 4]) == False\nassert op_dec_gt5_haszero([]) == False\nassert op_dec_gt5_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dec_gt5_haszero([5, 5, 5]) == False\nassert op_dec_gt5_haszero([3, 1, 2]) == False\nassert op_dec_gt5_haszero([10]) == False\nassert op_dec_gt5_haszero([2, 4, 6]) == False\nassert op_dec_gt5_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_sortabs_dropfirst", "entry_point": "op_sorta_sortabs_dropfirst", "primitives": ["sorta", "sortabs", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then drop the first element.", "solution": "def op_sorta_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_sorta_sortabs_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_sortabs_dropfirst([]) == []\nassert op_sorta_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sorta_sortabs_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sorta_sortabs_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sorta_sortabs_dropfirst([10]) == []\nassert op_sorta_sortabs_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sorta_sortabs_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_neg_trimends_dropwhileneg", "entry_point": "op_neg_trimends_dropwhileneg", "primitives": ["neg", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_neg_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_trimends_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_trimends_dropwhileneg([]) == []\nassert op_neg_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_dropwhileneg([5, 5, 5]) == []\nassert op_neg_trimends_dropwhileneg([3, 1, 2]) == []\nassert op_neg_trimends_dropwhileneg([10]) == []\nassert op_neg_trimends_dropwhileneg([2, 4, 6]) == []\nassert op_neg_trimends_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_negate_takewhilepos_dec", "entry_point": "op_negate_takewhilepos_dec", "primitives": ["negate", "takewhilepos", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then subtract one from each.", "solution": "def op_negate_takewhilepos_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_takewhilepos_dec([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos_dec([]) == []\nassert op_negate_takewhilepos_dec([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_negate_takewhilepos_dec([5, 5, 5]) == []\nassert op_negate_takewhilepos_dec([3, 1, 2]) == []\nassert op_negate_takewhilepos_dec([10]) == []\nassert op_negate_takewhilepos_dec([2, 4, 6]) == []\nassert op_negate_takewhilepos_dec([-7, 12, -7]) == [6]"}
{"id": "op_trimends_last3_padto3", "entry_point": "op_trimends_last3_padto3", "primitives": ["trimends", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_trimends_last3_padto3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_trimends_last3_padto3([1, 2, 3, 4]) == [2, 3, 0]\nassert op_trimends_last3_padto3([]) == [0, 0, 0]\nassert op_trimends_last3_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_last3_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_last3_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_last3_padto3([10]) == [0, 0, 0]\nassert op_trimends_last3_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_last3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_clamp10_trimends_max", "entry_point": "op_clamp10_trimends_max", "primitives": ["clamp10", "trimends", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_clamp10_trimends_max(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_clamp10_trimends_max([1, 2, 3, 4]) == 3\nassert op_clamp10_trimends_max([]) == 0\nassert op_clamp10_trimends_max([-2, -1, 0, 1, 2]) == 1\nassert op_clamp10_trimends_max([5, 5, 5]) == 5\nassert op_clamp10_trimends_max([3, 1, 2]) == 1\nassert op_clamp10_trimends_max([10]) == 0\nassert op_clamp10_trimends_max([2, 4, 6]) == 4\nassert op_clamp10_trimends_max([-7, 12, -7]) == 10"}
{"id": "op_evens_neg_inc", "entry_point": "op_evens_neg_inc", "primitives": ["evens", "neg", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers, then add one to each.", "solution": "def op_evens_neg_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_evens_neg_inc([1, 2, 3, 4]) == []\nassert op_evens_neg_inc([]) == []\nassert op_evens_neg_inc([-2, -1, 0, 1, 2]) == [-1]\nassert op_evens_neg_inc([5, 5, 5]) == []\nassert op_evens_neg_inc([3, 1, 2]) == []\nassert op_evens_neg_inc([10]) == []\nassert op_evens_neg_inc([2, 4, 6]) == []\nassert op_evens_neg_inc([-7, 12, -7]) == []"}
{"id": "op_double_div3_rev", "entry_point": "op_double_div3_rev", "primitives": ["double", "div3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then reverse the order.", "solution": "def op_double_div3_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_div3_rev([1, 2, 3, 4]) == [6]\nassert op_double_div3_rev([]) == []\nassert op_double_div3_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_double_div3_rev([5, 5, 5]) == []\nassert op_double_div3_rev([3, 1, 2]) == [6]\nassert op_double_div3_rev([10]) == []\nassert op_double_div3_rev([2, 4, 6]) == [12]\nassert op_double_div3_rev([-7, 12, -7]) == [24]"}
{"id": "op_dropzeros_inc_takewhilepos", "entry_point": "op_dropzeros_inc_takewhilepos", "primitives": ["dropzeros", "inc", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then take values while they are positive.", "solution": "def op_dropzeros_inc_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_inc_takewhilepos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropzeros_inc_takewhilepos([]) == []\nassert op_dropzeros_inc_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_inc_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_dropzeros_inc_takewhilepos([3, 1, 2]) == [4, 2, 3]\nassert op_dropzeros_inc_takewhilepos([10]) == [11]\nassert op_dropzeros_inc_takewhilepos([2, 4, 6]) == [3, 5, 7]\nassert op_dropzeros_inc_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_first3_trimends_uniq", "entry_point": "op_first3_trimends_uniq", "primitives": ["first3", "trimends", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_first3_trimends_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_trimends_uniq([1, 2, 3, 4]) == [2]\nassert op_first3_trimends_uniq([]) == []\nassert op_first3_trimends_uniq([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_trimends_uniq([5, 5, 5]) == [5]\nassert op_first3_trimends_uniq([3, 1, 2]) == [1]\nassert op_first3_trimends_uniq([10]) == []\nassert op_first3_trimends_uniq([2, 4, 6]) == [4]\nassert op_first3_trimends_uniq([-7, 12, -7]) == [12]"}
{"id": "op_last3_padto3_trimends", "entry_point": "op_last3_padto3_trimends", "primitives": ["last3", "padto3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_last3_padto3_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_padto3_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_padto3_trimends([]) == [0]\nassert op_last3_padto3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_padto3_trimends([5, 5, 5]) == [5]\nassert op_last3_padto3_trimends([3, 1, 2]) == [1]\nassert op_last3_padto3_trimends([10]) == [0]\nassert op_last3_padto3_trimends([2, 4, 6]) == [4]\nassert op_last3_padto3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_trimends_square_evens", "entry_point": "op_trimends_square_evens", "primitives": ["trimends", "square", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then keep the even numbers.", "solution": "def op_trimends_square_evens(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_trimends_square_evens([1, 2, 3, 4]) == [4]\nassert op_trimends_square_evens([]) == []\nassert op_trimends_square_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_square_evens([5, 5, 5]) == []\nassert op_trimends_square_evens([3, 1, 2]) == []\nassert op_trimends_square_evens([10]) == []\nassert op_trimends_square_evens([2, 4, 6]) == [16]\nassert op_trimends_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_evens_clamp10_max", "entry_point": "op_evens_clamp10_max", "primitives": ["evens", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_evens_clamp10_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_evens_clamp10_max([1, 2, 3, 4]) == 4\nassert op_evens_clamp10_max([]) == 0\nassert op_evens_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_clamp10_max([5, 5, 5]) == 0\nassert op_evens_clamp10_max([3, 1, 2]) == 2\nassert op_evens_clamp10_max([10]) == 10\nassert op_evens_clamp10_max([2, 4, 6]) == 6\nassert op_evens_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_add10_negate_len", "entry_point": "op_add10_negate_len", "primitives": ["add10", "negate", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each, then return how many remain.", "solution": "def op_add10_negate_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_add10_negate_len([1, 2, 3, 4]) == 4\nassert op_add10_negate_len([]) == 0\nassert op_add10_negate_len([-2, -1, 0, 1, 2]) == 5\nassert op_add10_negate_len([5, 5, 5]) == 3\nassert op_add10_negate_len([3, 1, 2]) == 3\nassert op_add10_negate_len([10]) == 1\nassert op_add10_negate_len([2, 4, 6]) == 3\nassert op_add10_negate_len([-7, 12, -7]) == 3"}
{"id": "op_inc_sortd_allpos", "entry_point": "op_inc_sortd_allpos", "primitives": ["inc", "sortd", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then return whether all values are positive.", "solution": "def op_inc_sortd_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_inc_sortd_allpos([1, 2, 3, 4]) == True\nassert op_inc_sortd_allpos([]) == True\nassert op_inc_sortd_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_sortd_allpos([5, 5, 5]) == True\nassert op_inc_sortd_allpos([3, 1, 2]) == True\nassert op_inc_sortd_allpos([10]) == True\nassert op_inc_sortd_allpos([2, 4, 6]) == True\nassert op_inc_sortd_allpos([-7, 12, -7]) == False"}
{"id": "op_first3_takewhilepos_haszero", "entry_point": "op_first3_takewhilepos_haszero", "primitives": ["first3", "takewhilepos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then return whether the list contains a zero.", "solution": "def op_first3_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_first3_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_first3_takewhilepos_haszero([]) == False\nassert op_first3_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_first3_takewhilepos_haszero([5, 5, 5]) == False\nassert op_first3_takewhilepos_haszero([3, 1, 2]) == False\nassert op_first3_takewhilepos_haszero([10]) == False\nassert op_first3_takewhilepos_haszero([2, 4, 6]) == False\nassert op_first3_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_last3_anyeven", "entry_point": "op_dropwhileneg_last3_anyeven", "primitives": ["dropwhileneg", "last3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then return whether any value is even.", "solution": "def op_dropwhileneg_last3_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_last3_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_last3_anyeven([]) == False\nassert op_dropwhileneg_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_last3_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_last3_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_last3_anyeven([10]) == True\nassert op_dropwhileneg_last3_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_dec_clamp10_sum", "entry_point": "op_dec_clamp10_sum", "primitives": ["dec", "clamp10", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cap each value at 10, then return their sum.", "solution": "def op_dec_clamp10_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_dec_clamp10_sum([1, 2, 3, 4]) == 6\nassert op_dec_clamp10_sum([]) == 0\nassert op_dec_clamp10_sum([-2, -1, 0, 1, 2]) == -5\nassert op_dec_clamp10_sum([5, 5, 5]) == 12\nassert op_dec_clamp10_sum([3, 1, 2]) == 3\nassert op_dec_clamp10_sum([10]) == 9\nassert op_dec_clamp10_sum([2, 4, 6]) == 9\nassert op_dec_clamp10_sum([-7, 12, -7]) == -6"}
{"id": "op_takewhilepos_neg_uniq", "entry_point": "op_takewhilepos_neg_uniq", "primitives": ["takewhilepos", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_neg_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_neg_uniq([1, 2, 3, 4]) == []\nassert op_takewhilepos_neg_uniq([]) == []\nassert op_takewhilepos_neg_uniq([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_neg_uniq([5, 5, 5]) == []\nassert op_takewhilepos_neg_uniq([3, 1, 2]) == []\nassert op_takewhilepos_neg_uniq([10]) == []\nassert op_takewhilepos_neg_uniq([2, 4, 6]) == []\nassert op_takewhilepos_neg_uniq([-7, 12, -7]) == []"}
{"id": "op_div3_uniq_counteven", "entry_point": "op_div3_uniq_counteven", "primitives": ["div3", "uniq", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_div3_uniq_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_div3_uniq_counteven([1, 2, 3, 4]) == 0\nassert op_div3_uniq_counteven([]) == 0\nassert op_div3_uniq_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_div3_uniq_counteven([5, 5, 5]) == 0\nassert op_div3_uniq_counteven([3, 1, 2]) == 0\nassert op_div3_uniq_counteven([10]) == 0\nassert op_div3_uniq_counteven([2, 4, 6]) == 1\nassert op_div3_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_div3_trimends_double", "entry_point": "op_div3_trimends_double", "primitives": ["div3", "trimends", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then double each.", "solution": "def op_div3_trimends_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_trimends_double([1, 2, 3, 4]) == []\nassert op_div3_trimends_double([]) == []\nassert op_div3_trimends_double([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends_double([5, 5, 5]) == []\nassert op_div3_trimends_double([3, 1, 2]) == []\nassert op_div3_trimends_double([10]) == []\nassert op_div3_trimends_double([2, 4, 6]) == []\nassert op_div3_trimends_double([-7, 12, -7]) == []"}
{"id": "op_evens_inc_div3", "entry_point": "op_evens_inc_div3", "primitives": ["evens", "inc", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then keep multiples of three.", "solution": "def op_evens_inc_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_inc_div3([1, 2, 3, 4]) == [3]\nassert op_evens_inc_div3([]) == []\nassert op_evens_inc_div3([-2, -1, 0, 1, 2]) == [3]\nassert op_evens_inc_div3([5, 5, 5]) == []\nassert op_evens_inc_div3([3, 1, 2]) == [3]\nassert op_evens_inc_div3([10]) == []\nassert op_evens_inc_div3([2, 4, 6]) == [3]\nassert op_evens_inc_div3([-7, 12, -7]) == []"}
{"id": "op_add10_inc_first3", "entry_point": "op_add10_inc_first3", "primitives": ["add10", "inc", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then add one to each, then keep only the first three.", "solution": "def op_add10_inc_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_add10_inc_first3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_inc_first3([]) == []\nassert op_add10_inc_first3([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_inc_first3([5, 5, 5]) == [16, 16, 16]\nassert op_add10_inc_first3([3, 1, 2]) == [14, 12, 13]\nassert op_add10_inc_first3([10]) == [21]\nassert op_add10_inc_first3([2, 4, 6]) == [13, 15, 17]\nassert op_add10_inc_first3([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_ages_evens_sortd", "entry_point": "op_ages_evens_sortd", "primitives": ["ages", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then sort descending.", "solution": "def op_ages_evens_sortd(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_ages_evens_sortd([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_evens_sortd([]) == []\nassert op_ages_evens_sortd([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens_sortd([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_takewhilepos_rev_dropwhileneg", "entry_point": "op_takewhilepos_rev_dropwhileneg", "primitives": ["takewhilepos", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then reverse the order, then drop the leading negative values.", "solution": "def op_takewhilepos_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_rev_dropwhileneg([]) == []\nassert op_takewhilepos_rev_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_rev_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_takewhilepos_rev_dropwhileneg([10]) == [10]\nassert op_takewhilepos_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_rev_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_rev_clamp10_takewhilepos", "entry_point": "op_rev_clamp10_takewhilepos", "primitives": ["rev", "clamp10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then take values while they are positive.", "solution": "def op_rev_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_clamp10_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_clamp10_takewhilepos([]) == []\nassert op_rev_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_clamp10_takewhilepos([10]) == [10]\nassert op_rev_clamp10_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_clamp10_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_neg_gt5", "entry_point": "op_dropfirst_neg_gt5", "primitives": ["dropfirst", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then keep values greater than five.", "solution": "def op_dropfirst_neg_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_neg_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_gt5([]) == []\nassert op_dropfirst_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_neg_gt5([5, 5, 5]) == []\nassert op_dropfirst_neg_gt5([3, 1, 2]) == []\nassert op_dropfirst_neg_gt5([10]) == []\nassert op_dropfirst_neg_gt5([2, 4, 6]) == []\nassert op_dropfirst_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_add10_haszero", "entry_point": "op_oremptyzero_add10_haszero", "primitives": ["oremptyzero", "add10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then return whether the list contains a zero.", "solution": "def op_oremptyzero_add10_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return 0 in r", "tests": "assert op_oremptyzero_add10_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_add10_haszero([]) == False\nassert op_oremptyzero_add10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_add10_haszero([5, 5, 5]) == False\nassert op_oremptyzero_add10_haszero([3, 1, 2]) == False\nassert op_oremptyzero_add10_haszero([10]) == False\nassert op_oremptyzero_add10_haszero([2, 4, 6]) == False\nassert op_oremptyzero_add10_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_odds_prod", "entry_point": "op_uniq_odds_prod", "primitives": ["uniq", "odds", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then return their product.", "solution": "def op_uniq_odds_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return __import__('math').prod(r)", "tests": "assert op_uniq_odds_prod([1, 2, 3, 4]) == 3\nassert op_uniq_odds_prod([]) == 1\nassert op_uniq_odds_prod([-2, -1, 0, 1, 2]) == -1\nassert op_uniq_odds_prod([5, 5, 5]) == 5\nassert op_uniq_odds_prod([3, 1, 2]) == 3\nassert op_uniq_odds_prod([10]) == 1\nassert op_uniq_odds_prod([2, 4, 6]) == 1\nassert op_uniq_odds_prod([-7, 12, -7]) == -7"}
{"id": "op_rev_evens_square", "entry_point": "op_rev_evens_square", "primitives": ["rev", "evens", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers, then square each.", "solution": "def op_rev_evens_square(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_rev_evens_square([1, 2, 3, 4]) == [16, 4]\nassert op_rev_evens_square([]) == []\nassert op_rev_evens_square([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_rev_evens_square([5, 5, 5]) == []\nassert op_rev_evens_square([3, 1, 2]) == [4]\nassert op_rev_evens_square([10]) == [100]\nassert op_rev_evens_square([2, 4, 6]) == [36, 16, 4]\nassert op_rev_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_gt5_oremptyzero_firsteven", "entry_point": "op_gt5_oremptyzero_firsteven", "primitives": ["gt5", "oremptyzero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then return the first even value (0 if none).", "solution": "def op_gt5_oremptyzero_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_oremptyzero_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_oremptyzero_firsteven([]) == 0\nassert op_gt5_oremptyzero_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_oremptyzero_firsteven([5, 5, 5]) == 0\nassert op_gt5_oremptyzero_firsteven([3, 1, 2]) == 0\nassert op_gt5_oremptyzero_firsteven([10]) == 10\nassert op_gt5_oremptyzero_firsteven([2, 4, 6]) == 6\nassert op_gt5_oremptyzero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_sortabs_trimends", "entry_point": "op_evens_sortabs_trimends", "primitives": ["evens", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then drop the first and last elements.", "solution": "def op_evens_sortabs_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_evens_sortabs_trimends([1, 2, 3, 4]) == []\nassert op_evens_sortabs_trimends([]) == []\nassert op_evens_sortabs_trimends([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_sortabs_trimends([5, 5, 5]) == []\nassert op_evens_sortabs_trimends([3, 1, 2]) == []\nassert op_evens_sortabs_trimends([10]) == []\nassert op_evens_sortabs_trimends([2, 4, 6]) == [4]\nassert op_evens_sortabs_trimends([-7, 12, -7]) == []"}
{"id": "op_trimends_square_dropzeros", "entry_point": "op_trimends_square_dropzeros", "primitives": ["trimends", "square", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then drop the zeros.", "solution": "def op_trimends_square_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_square_dropzeros([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_square_dropzeros([]) == []\nassert op_trimends_square_dropzeros([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_trimends_square_dropzeros([5, 5, 5]) == [25]\nassert op_trimends_square_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_square_dropzeros([10]) == []\nassert op_trimends_square_dropzeros([2, 4, 6]) == [16]\nassert op_trimends_square_dropzeros([-7, 12, -7]) == [144]"}
{"id": "op_dec_square_sorta", "entry_point": "op_dec_square_sorta", "primitives": ["dec", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then sort ascending.", "solution": "def op_dec_square_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_square_sorta([1, 2, 3, 4]) == [0, 1, 4, 9]\nassert op_dec_square_sorta([]) == []\nassert op_dec_square_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 9]\nassert op_dec_square_sorta([5, 5, 5]) == [16, 16, 16]\nassert op_dec_square_sorta([3, 1, 2]) == [0, 1, 4]\nassert op_dec_square_sorta([10]) == [81]\nassert op_dec_square_sorta([2, 4, 6]) == [1, 9, 25]\nassert op_dec_square_sorta([-7, 12, -7]) == [64, 64, 121]"}
{"id": "op_negate_odds_firsteven", "entry_point": "op_negate_odds_firsteven", "primitives": ["negate", "odds", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_negate_odds_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_negate_odds_firsteven([]) == 0\nassert op_negate_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_negate_odds_firsteven([5, 5, 5]) == 0\nassert op_negate_odds_firsteven([3, 1, 2]) == 0\nassert op_negate_odds_firsteven([10]) == 0\nassert op_negate_odds_firsteven([2, 4, 6]) == 0\nassert op_negate_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_uniq_evens_clamp10", "entry_point": "op_uniq_evens_clamp10", "primitives": ["uniq", "evens", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then cap each value at 10.", "solution": "def op_uniq_evens_clamp10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_uniq_evens_clamp10([1, 2, 3, 4]) == [2, 4]\nassert op_uniq_evens_clamp10([]) == []\nassert op_uniq_evens_clamp10([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_uniq_evens_clamp10([5, 5, 5]) == []\nassert op_uniq_evens_clamp10([3, 1, 2]) == [2]\nassert op_uniq_evens_clamp10([10]) == [10]\nassert op_uniq_evens_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_evens_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_absval_trimends_counteven", "entry_point": "op_absval_trimends_counteven", "primitives": ["absval", "trimends", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then return how many values are even.", "solution": "def op_absval_trimends_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_absval_trimends_counteven([]) == 0\nassert op_absval_trimends_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_absval_trimends_counteven([5, 5, 5]) == 0\nassert op_absval_trimends_counteven([3, 1, 2]) == 0\nassert op_absval_trimends_counteven([10]) == 0\nassert op_absval_trimends_counteven([2, 4, 6]) == 1\nassert op_absval_trimends_counteven([-7, 12, -7]) == 1"}
{"id": "op_evens_padto3_min", "entry_point": "op_evens_padto3_min", "primitives": ["evens", "padto3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_evens_padto3_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_evens_padto3_min([1, 2, 3, 4]) == 0\nassert op_evens_padto3_min([]) == 0\nassert op_evens_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_evens_padto3_min([5, 5, 5]) == 0\nassert op_evens_padto3_min([3, 1, 2]) == 0\nassert op_evens_padto3_min([10]) == 0\nassert op_evens_padto3_min([2, 4, 6]) == 2\nassert op_evens_padto3_min([-7, 12, -7]) == 0"}
{"id": "op_sortabs_odds_haszero", "entry_point": "op_sortabs_odds_haszero", "primitives": ["sortabs", "odds", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_sortabs_odds_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_sortabs_odds_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_odds_haszero([]) == False\nassert op_sortabs_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_odds_haszero([5, 5, 5]) == False\nassert op_sortabs_odds_haszero([3, 1, 2]) == False\nassert op_sortabs_odds_haszero([10]) == False\nassert op_sortabs_odds_haszero([2, 4, 6]) == False\nassert op_sortabs_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_absval_dec_neg", "entry_point": "op_absval_dec_neg", "primitives": ["absval", "dec", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then keep the negative numbers.", "solution": "def op_absval_dec_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_dec_neg([1, 2, 3, 4]) == []\nassert op_absval_dec_neg([]) == []\nassert op_absval_dec_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_absval_dec_neg([5, 5, 5]) == []\nassert op_absval_dec_neg([3, 1, 2]) == []\nassert op_absval_dec_neg([10]) == []\nassert op_absval_dec_neg([2, 4, 6]) == []\nassert op_absval_dec_neg([-7, 12, -7]) == []"}
{"id": "op_sortlen_prefixup_sortalpha", "entry_point": "op_sortlen_prefixup_sortalpha", "primitives": ["sortlen", "prefixup", "sortalpha"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then prefix each with a hash, then sort alphabetically.", "solution": "def op_sortlen_prefixup_sortalpha(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_sortlen_prefixup_sortalpha(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortlen_prefixup_sortalpha([]) == []\nassert op_sortlen_prefixup_sortalpha(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_sortlen_prefixup_sortalpha(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_sortlen_prefixup_sortalpha(['x']) == ['#x']\nassert op_sortlen_prefixup_sortalpha(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_first3_padto3_last3", "entry_point": "op_first3_padto3_last3", "primitives": ["first3", "padto3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_first3_padto3_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_first3_padto3_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_padto3_last3([]) == [0, 0, 0]\nassert op_first3_padto3_last3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_padto3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_padto3_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_padto3_last3([10]) == [10, 0, 0]\nassert op_first3_padto3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_padto3_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_dropfirst_negate_sortabs", "entry_point": "op_dropfirst_negate_sortabs", "primitives": ["dropfirst", "negate", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then sort by absolute value.", "solution": "def op_dropfirst_negate_sortabs(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropfirst_negate_sortabs([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_dropfirst_negate_sortabs([]) == []\nassert op_dropfirst_negate_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, -2]\nassert op_dropfirst_negate_sortabs([5, 5, 5]) == [-5, -5]\nassert op_dropfirst_negate_sortabs([3, 1, 2]) == [-1, -2]\nassert op_dropfirst_negate_sortabs([10]) == []\nassert op_dropfirst_negate_sortabs([2, 4, 6]) == [-4, -6]\nassert op_dropfirst_negate_sortabs([-7, 12, -7]) == [7, -12]"}
{"id": "op_sorta_dropwhileneg_pos", "entry_point": "op_sorta_dropwhileneg_pos", "primitives": ["sorta", "dropwhileneg", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_sorta_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_dropwhileneg_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropwhileneg_pos([]) == []\nassert op_sorta_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sorta_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropwhileneg_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropwhileneg_pos([10]) == [10]\nassert op_sorta_dropwhileneg_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropwhileneg_pos([-7, 12, -7]) == [12]"}
{"id": "op_negate_dropzeros_alldistinct", "entry_point": "op_negate_dropzeros_alldistinct", "primitives": ["negate", "dropzeros", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then return whether all values are distinct.", "solution": "def op_negate_dropzeros_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return len(r) == len(set(r))", "tests": "assert op_negate_dropzeros_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_dropzeros_alldistinct([]) == True\nassert op_negate_dropzeros_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_dropzeros_alldistinct([5, 5, 5]) == False\nassert op_negate_dropzeros_alldistinct([3, 1, 2]) == True\nassert op_negate_dropzeros_alldistinct([10]) == True\nassert op_negate_dropzeros_alldistinct([2, 4, 6]) == True\nassert op_negate_dropzeros_alldistinct([-7, 12, -7]) == False"}
{"id": "op_neg_double_sortabs", "entry_point": "op_neg_double_sortabs", "primitives": ["neg", "double", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then double each, then sort by absolute value.", "solution": "def op_neg_double_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_neg_double_sortabs([1, 2, 3, 4]) == []\nassert op_neg_double_sortabs([]) == []\nassert op_neg_double_sortabs([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_neg_double_sortabs([5, 5, 5]) == []\nassert op_neg_double_sortabs([3, 1, 2]) == []\nassert op_neg_double_sortabs([10]) == []\nassert op_neg_double_sortabs([2, 4, 6]) == []\nassert op_neg_double_sortabs([-7, 12, -7]) == [-14, -14]"}
{"id": "op_double_div3_oremptyzero", "entry_point": "op_double_div3_oremptyzero", "primitives": ["double", "div3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then if empty, use a single zero.", "solution": "def op_double_div3_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_div3_oremptyzero([1, 2, 3, 4]) == [6]\nassert op_double_div3_oremptyzero([]) == [0]\nassert op_double_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_double_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_double_div3_oremptyzero([3, 1, 2]) == [6]\nassert op_double_div3_oremptyzero([10]) == [0]\nassert op_double_div3_oremptyzero([2, 4, 6]) == [12]\nassert op_double_div3_oremptyzero([-7, 12, -7]) == [24]"}
{"id": "op_rev_neg_double", "entry_point": "op_rev_neg_double", "primitives": ["rev", "neg", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the negative numbers, then double each.", "solution": "def op_rev_neg_double(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_rev_neg_double([1, 2, 3, 4]) == []\nassert op_rev_neg_double([]) == []\nassert op_rev_neg_double([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_rev_neg_double([5, 5, 5]) == []\nassert op_rev_neg_double([3, 1, 2]) == []\nassert op_rev_neg_double([10]) == []\nassert op_rev_neg_double([2, 4, 6]) == []\nassert op_rev_neg_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_first3_rev_inc", "entry_point": "op_first3_rev_inc", "primitives": ["first3", "rev", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then add one to each.", "solution": "def op_first3_rev_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_rev_inc([1, 2, 3, 4]) == [4, 3, 2]\nassert op_first3_rev_inc([]) == []\nassert op_first3_rev_inc([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_first3_rev_inc([5, 5, 5]) == [6, 6, 6]\nassert op_first3_rev_inc([3, 1, 2]) == [3, 2, 4]\nassert op_first3_rev_inc([10]) == [11]\nassert op_first3_rev_inc([2, 4, 6]) == [7, 5, 3]\nassert op_first3_rev_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_padto3_negate_last3", "entry_point": "op_padto3_negate_last3", "primitives": ["padto3", "negate", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then negate each, then keep only the last three.", "solution": "def op_padto3_negate_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_padto3_negate_last3([]) == [0, 0, 0]\nassert op_padto3_negate_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_padto3_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_padto3_negate_last3([10]) == [-10, 0, 0]\nassert op_padto3_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_negate_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_double_negate_dropwhileneg", "entry_point": "op_double_negate_dropwhileneg", "primitives": ["double", "negate", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then drop the leading negative values.", "solution": "def op_double_negate_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_negate_dropwhileneg([1, 2, 3, 4]) == []\nassert op_double_negate_dropwhileneg([]) == []\nassert op_double_negate_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_negate_dropwhileneg([5, 5, 5]) == []\nassert op_double_negate_dropwhileneg([3, 1, 2]) == []\nassert op_double_negate_dropwhileneg([10]) == []\nassert op_double_negate_dropwhileneg([2, 4, 6]) == []\nassert op_double_negate_dropwhileneg([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_ages_padto3_gt5", "entry_point": "op_ages_padto3_gt5", "primitives": ["ages", "padto3", "gt5"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then keep values greater than five.", "solution": "def op_ages_padto3_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_padto3_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_padto3_gt5([]) == []\nassert op_ages_padto3_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_padto3_gt5([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dec_absval_sorta", "entry_point": "op_dec_absval_sorta", "primitives": ["dec", "absval", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then sort ascending.", "solution": "def op_dec_absval_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_absval_sorta([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_absval_sorta([]) == []\nassert op_dec_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 3]\nassert op_dec_absval_sorta([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_sorta([3, 1, 2]) == [0, 1, 2]\nassert op_dec_absval_sorta([10]) == [9]\nassert op_dec_absval_sorta([2, 4, 6]) == [1, 3, 5]\nassert op_dec_absval_sorta([-7, 12, -7]) == [8, 8, 11]"}
{"id": "op_ages_trimends_padto3", "entry_point": "op_ages_trimends_padto3", "primitives": ["ages", "trimends", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_ages_trimends_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_trimends_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [0, 0, 0]\nassert op_ages_trimends_padto3([]) == [0, 0, 0]\nassert op_ages_trimends_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 0, 0]\nassert op_ages_trimends_padto3([{'name': 'Fi', 'age': 41}]) == [0, 0, 0]"}
{"id": "op_neg_trimends_dropfirst", "entry_point": "op_neg_trimends_dropfirst", "primitives": ["neg", "trimends", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then drop the first element.", "solution": "def op_neg_trimends_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_neg_trimends_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_trimends_dropfirst([]) == []\nassert op_neg_trimends_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_dropfirst([5, 5, 5]) == []\nassert op_neg_trimends_dropfirst([3, 1, 2]) == []\nassert op_neg_trimends_dropfirst([10]) == []\nassert op_neg_trimends_dropfirst([2, 4, 6]) == []\nassert op_neg_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_neg_negate_double", "entry_point": "op_neg_negate_double", "primitives": ["neg", "negate", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then double each.", "solution": "def op_neg_negate_double(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_neg_negate_double([1, 2, 3, 4]) == []\nassert op_neg_negate_double([]) == []\nassert op_neg_negate_double([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_neg_negate_double([5, 5, 5]) == []\nassert op_neg_negate_double([3, 1, 2]) == []\nassert op_neg_negate_double([10]) == []\nassert op_neg_negate_double([2, 4, 6]) == []\nassert op_neg_negate_double([-7, 12, -7]) == [14, 14]"}
{"id": "op_inc_dropfirst_min", "entry_point": "op_inc_dropfirst_min", "primitives": ["inc", "dropfirst", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first element, then return the minimum (0 if empty).", "solution": "def op_inc_dropfirst_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:]\n    return min(r) if r else 0", "tests": "assert op_inc_dropfirst_min([1, 2, 3, 4]) == 3\nassert op_inc_dropfirst_min([]) == 0\nassert op_inc_dropfirst_min([-2, -1, 0, 1, 2]) == 0\nassert op_inc_dropfirst_min([5, 5, 5]) == 6\nassert op_inc_dropfirst_min([3, 1, 2]) == 2\nassert op_inc_dropfirst_min([10]) == 0\nassert op_inc_dropfirst_min([2, 4, 6]) == 5\nassert op_inc_dropfirst_min([-7, 12, -7]) == -6"}
{"id": "op_padto3_neg_gt5", "entry_point": "op_padto3_neg_gt5", "primitives": ["padto3", "neg", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then keep values greater than five.", "solution": "def op_padto3_neg_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_neg_gt5([1, 2, 3, 4]) == []\nassert op_padto3_neg_gt5([]) == []\nassert op_padto3_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_neg_gt5([5, 5, 5]) == []\nassert op_padto3_neg_gt5([3, 1, 2]) == []\nassert op_padto3_neg_gt5([10]) == []\nassert op_padto3_neg_gt5([2, 4, 6]) == []\nassert op_padto3_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_add10_rev_len", "entry_point": "op_add10_rev_len", "primitives": ["add10", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then return how many remain.", "solution": "def op_add10_rev_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_add10_rev_len([1, 2, 3, 4]) == 4\nassert op_add10_rev_len([]) == 0\nassert op_add10_rev_len([-2, -1, 0, 1, 2]) == 5\nassert op_add10_rev_len([5, 5, 5]) == 3\nassert op_add10_rev_len([3, 1, 2]) == 3\nassert op_add10_rev_len([10]) == 1\nassert op_add10_rev_len([2, 4, 6]) == 3\nassert op_add10_rev_len([-7, 12, -7]) == 3"}
{"id": "op_neg_last3_dropwhileneg", "entry_point": "op_neg_last3_dropwhileneg", "primitives": ["neg", "last3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then drop the leading negative values.", "solution": "def op_neg_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_last3_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_last3_dropwhileneg([]) == []\nassert op_neg_last3_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_last3_dropwhileneg([5, 5, 5]) == []\nassert op_neg_last3_dropwhileneg([3, 1, 2]) == []\nassert op_neg_last3_dropwhileneg([10]) == []\nassert op_neg_last3_dropwhileneg([2, 4, 6]) == []\nassert op_neg_last3_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_trimends_padto3_sortd", "entry_point": "op_trimends_padto3_sortd", "primitives": ["trimends", "padto3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_trimends_padto3_sortd(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_trimends_padto3_sortd([1, 2, 3, 4]) == [3, 2, 0]\nassert op_trimends_padto3_sortd([]) == [0, 0, 0]\nassert op_trimends_padto3_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_padto3_sortd([5, 5, 5]) == [5, 0, 0]\nassert op_trimends_padto3_sortd([3, 1, 2]) == [1, 0, 0]\nassert op_trimends_padto3_sortd([10]) == [0, 0, 0]\nassert op_trimends_padto3_sortd([2, 4, 6]) == [4, 0, 0]\nassert op_trimends_padto3_sortd([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_beforezero_absval_allpos", "entry_point": "op_beforezero_absval_allpos", "primitives": ["beforezero", "absval", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_beforezero_absval_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_absval_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_absval_allpos([]) == True\nassert op_beforezero_absval_allpos([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_absval_allpos([5, 5, 5]) == True\nassert op_beforezero_absval_allpos([3, 1, 2]) == True\nassert op_beforezero_absval_allpos([10]) == True\nassert op_beforezero_absval_allpos([2, 4, 6]) == True\nassert op_beforezero_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_square_beforezero_last3", "entry_point": "op_square_beforezero_last3", "primitives": ["square", "beforezero", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then keep only the last three.", "solution": "def op_square_beforezero_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return r", "tests": "assert op_square_beforezero_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_beforezero_last3([]) == []\nassert op_square_beforezero_last3([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_beforezero_last3([5, 5, 5]) == [25, 25, 25]\nassert op_square_beforezero_last3([3, 1, 2]) == [9, 1, 4]\nassert op_square_beforezero_last3([10]) == [100]\nassert op_square_beforezero_last3([2, 4, 6]) == [4, 16, 36]\nassert op_square_beforezero_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_div3_last3_neg", "entry_point": "op_div3_last3_neg", "primitives": ["div3", "last3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then keep the negative numbers.", "solution": "def op_div3_last3_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_div3_last3_neg([1, 2, 3, 4]) == []\nassert op_div3_last3_neg([]) == []\nassert op_div3_last3_neg([-2, -1, 0, 1, 2]) == []\nassert op_div3_last3_neg([5, 5, 5]) == []\nassert op_div3_last3_neg([3, 1, 2]) == []\nassert op_div3_last3_neg([10]) == []\nassert op_div3_last3_neg([2, 4, 6]) == []\nassert op_div3_last3_neg([-7, 12, -7]) == []"}
{"id": "op_trimends_inc_max", "entry_point": "op_trimends_inc_max", "primitives": ["trimends", "inc", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then return the maximum (0 if empty).", "solution": "def op_trimends_inc_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_trimends_inc_max([1, 2, 3, 4]) == 4\nassert op_trimends_inc_max([]) == 0\nassert op_trimends_inc_max([-2, -1, 0, 1, 2]) == 2\nassert op_trimends_inc_max([5, 5, 5]) == 6\nassert op_trimends_inc_max([3, 1, 2]) == 2\nassert op_trimends_inc_max([10]) == 0\nassert op_trimends_inc_max([2, 4, 6]) == 5\nassert op_trimends_inc_max([-7, 12, -7]) == 13"}
{"id": "op_takewhilepos_neg_sortabs", "entry_point": "op_takewhilepos_neg_sortabs", "primitives": ["takewhilepos", "neg", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then sort by absolute value.", "solution": "def op_takewhilepos_neg_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_neg_sortabs([1, 2, 3, 4]) == []\nassert op_takewhilepos_neg_sortabs([]) == []\nassert op_takewhilepos_neg_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_neg_sortabs([5, 5, 5]) == []\nassert op_takewhilepos_neg_sortabs([3, 1, 2]) == []\nassert op_takewhilepos_neg_sortabs([10]) == []\nassert op_takewhilepos_neg_sortabs([2, 4, 6]) == []\nassert op_takewhilepos_neg_sortabs([-7, 12, -7]) == []"}
{"id": "op_div3_dropzeros_clamp10", "entry_point": "op_div3_dropzeros_clamp10", "primitives": ["div3", "dropzeros", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros, then cap each value at 10.", "solution": "def op_div3_dropzeros_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_div3_dropzeros_clamp10([1, 2, 3, 4]) == [3]\nassert op_div3_dropzeros_clamp10([]) == []\nassert op_div3_dropzeros_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros_clamp10([5, 5, 5]) == []\nassert op_div3_dropzeros_clamp10([3, 1, 2]) == [3]\nassert op_div3_dropzeros_clamp10([10]) == []\nassert op_div3_dropzeros_clamp10([2, 4, 6]) == [6]\nassert op_div3_dropzeros_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_sortabs_dropfirst_beforezero", "entry_point": "op_sortabs_dropfirst_beforezero", "primitives": ["sortabs", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element, then keep everything before the first zero.", "solution": "def op_sortabs_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortabs_dropfirst_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_dropfirst_beforezero([]) == []\nassert op_sortabs_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_dropfirst_beforezero([5, 5, 5]) == [5, 5]\nassert op_sortabs_dropfirst_beforezero([3, 1, 2]) == [2, 3]\nassert op_sortabs_dropfirst_beforezero([10]) == []\nassert op_sortabs_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_sortabs_dropfirst_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_evens_beforezero_issorted", "entry_point": "op_evens_beforezero_issorted", "primitives": ["evens", "beforezero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then return whether the list is sorted ascending.", "solution": "def op_evens_beforezero_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r == sorted(r)", "tests": "assert op_evens_beforezero_issorted([1, 2, 3, 4]) == True\nassert op_evens_beforezero_issorted([]) == True\nassert op_evens_beforezero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_beforezero_issorted([5, 5, 5]) == True\nassert op_evens_beforezero_issorted([3, 1, 2]) == True\nassert op_evens_beforezero_issorted([10]) == True\nassert op_evens_beforezero_issorted([2, 4, 6]) == True\nassert op_evens_beforezero_issorted([-7, 12, -7]) == True"}
{"id": "op_sortabs_beforezero_dropzeros", "entry_point": "op_sortabs_beforezero_dropzeros", "primitives": ["sortabs", "beforezero", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then drop the zeros.", "solution": "def op_sortabs_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_beforezero_dropzeros([]) == []\nassert op_sortabs_beforezero_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_beforezero_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_beforezero_dropzeros([10]) == [10]\nassert op_sortabs_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_beforezero_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_first3_last3_counteven", "entry_point": "op_first3_last3_counteven", "primitives": ["first3", "last3", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then return how many values are even.", "solution": "def op_first3_last3_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_last3_counteven([1, 2, 3, 4]) == 1\nassert op_first3_last3_counteven([]) == 0\nassert op_first3_last3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_last3_counteven([5, 5, 5]) == 0\nassert op_first3_last3_counteven([3, 1, 2]) == 1\nassert op_first3_last3_counteven([10]) == 1\nassert op_first3_last3_counteven([2, 4, 6]) == 3\nassert op_first3_last3_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_dropfirst_sortd", "entry_point": "op_neg_dropfirst_sortd", "primitives": ["neg", "dropfirst", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then sort descending.", "solution": "def op_neg_dropfirst_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_neg_dropfirst_sortd([1, 2, 3, 4]) == []\nassert op_neg_dropfirst_sortd([]) == []\nassert op_neg_dropfirst_sortd([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_dropfirst_sortd([5, 5, 5]) == []\nassert op_neg_dropfirst_sortd([3, 1, 2]) == []\nassert op_neg_dropfirst_sortd([10]) == []\nassert op_neg_dropfirst_sortd([2, 4, 6]) == []\nassert op_neg_dropfirst_sortd([-7, 12, -7]) == [-7]"}
{"id": "op_dropzeros_trimends_neg", "entry_point": "op_dropzeros_trimends_neg", "primitives": ["dropzeros", "trimends", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_dropzeros_trimends_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropzeros_trimends_neg([1, 2, 3, 4]) == []\nassert op_dropzeros_trimends_neg([]) == []\nassert op_dropzeros_trimends_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropzeros_trimends_neg([5, 5, 5]) == []\nassert op_dropzeros_trimends_neg([3, 1, 2]) == []\nassert op_dropzeros_trimends_neg([10]) == []\nassert op_dropzeros_trimends_neg([2, 4, 6]) == []\nassert op_dropzeros_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_double_takewhilepos", "entry_point": "op_oremptyzero_double_takewhilepos", "primitives": ["oremptyzero", "double", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then take values while they are positive.", "solution": "def op_oremptyzero_double_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_double_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_oremptyzero_double_takewhilepos([]) == []\nassert op_oremptyzero_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_double_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_double_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_oremptyzero_double_takewhilepos([10]) == [20]\nassert op_oremptyzero_double_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_oremptyzero_double_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_neg_absval_firsteven", "entry_point": "op_neg_absval_firsteven", "primitives": ["neg", "absval", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_neg_absval_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_absval_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_absval_firsteven([]) == 0\nassert op_neg_absval_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_neg_absval_firsteven([5, 5, 5]) == 0\nassert op_neg_absval_firsteven([3, 1, 2]) == 0\nassert op_neg_absval_firsteven([10]) == 0\nassert op_neg_absval_firsteven([2, 4, 6]) == 0\nassert op_neg_absval_firsteven([-7, 12, -7]) == 0"}
{"id": "op_uniq_div3_clamp10", "entry_point": "op_uniq_div3_clamp10", "primitives": ["uniq", "div3", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then cap each value at 10.", "solution": "def op_uniq_div3_clamp10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_uniq_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_uniq_div3_clamp10([]) == []\nassert op_uniq_div3_clamp10([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_div3_clamp10([5, 5, 5]) == []\nassert op_uniq_div3_clamp10([3, 1, 2]) == [3]\nassert op_uniq_div3_clamp10([10]) == []\nassert op_uniq_div3_clamp10([2, 4, 6]) == [6]\nassert op_uniq_div3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_inc_double_min", "entry_point": "op_inc_double_min", "primitives": ["inc", "double", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then return the minimum (0 if empty).", "solution": "def op_inc_double_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_inc_double_min([1, 2, 3, 4]) == 4\nassert op_inc_double_min([]) == 0\nassert op_inc_double_min([-2, -1, 0, 1, 2]) == -2\nassert op_inc_double_min([5, 5, 5]) == 12\nassert op_inc_double_min([3, 1, 2]) == 4\nassert op_inc_double_min([10]) == 22\nassert op_inc_double_min([2, 4, 6]) == 6\nassert op_inc_double_min([-7, 12, -7]) == -12"}
{"id": "op_neg_dec_dropfirst", "entry_point": "op_neg_dec_dropfirst", "primitives": ["neg", "dec", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then drop the first element.", "solution": "def op_neg_dec_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_neg_dec_dropfirst([1, 2, 3, 4]) == []\nassert op_neg_dec_dropfirst([]) == []\nassert op_neg_dec_dropfirst([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_dec_dropfirst([5, 5, 5]) == []\nassert op_neg_dec_dropfirst([3, 1, 2]) == []\nassert op_neg_dec_dropfirst([10]) == []\nassert op_neg_dec_dropfirst([2, 4, 6]) == []\nassert op_neg_dec_dropfirst([-7, 12, -7]) == [-8]"}
{"id": "op_dropwhileneg_div3_anyeven", "entry_point": "op_dropwhileneg_div3_anyeven", "primitives": ["dropwhileneg", "div3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then return whether any value is even.", "solution": "def op_dropwhileneg_div3_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_div3_anyeven([1, 2, 3, 4]) == False\nassert op_dropwhileneg_div3_anyeven([]) == False\nassert op_dropwhileneg_div3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_div3_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_div3_anyeven([3, 1, 2]) == False\nassert op_dropwhileneg_div3_anyeven([10]) == False\nassert op_dropwhileneg_div3_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_div3_anyeven([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_last3_max", "entry_point": "op_takewhilepos_last3_max", "primitives": ["takewhilepos", "last3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_last3_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_last3_max([1, 2, 3, 4]) == 4\nassert op_takewhilepos_last3_max([]) == 0\nassert op_takewhilepos_last3_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_last3_max([5, 5, 5]) == 5\nassert op_takewhilepos_last3_max([3, 1, 2]) == 3\nassert op_takewhilepos_last3_max([10]) == 10\nassert op_takewhilepos_last3_max([2, 4, 6]) == 6\nassert op_takewhilepos_last3_max([-7, 12, -7]) == 0"}
{"id": "op_odds_first3_absval", "entry_point": "op_odds_first3_absval", "primitives": ["odds", "first3", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three, then take the absolute value of each.", "solution": "def op_odds_first3_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_first3_absval([1, 2, 3, 4]) == [1, 3]\nassert op_odds_first3_absval([]) == []\nassert op_odds_first3_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_first3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_odds_first3_absval([3, 1, 2]) == [3, 1]\nassert op_odds_first3_absval([10]) == []\nassert op_odds_first3_absval([2, 4, 6]) == []\nassert op_odds_first3_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_first3_dropwhileneg_div3", "entry_point": "op_first3_dropwhileneg_div3", "primitives": ["first3", "dropwhileneg", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the leading negative values, then keep multiples of three.", "solution": "def op_first3_dropwhileneg_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_dropwhileneg_div3([1, 2, 3, 4]) == [3]\nassert op_first3_dropwhileneg_div3([]) == []\nassert op_first3_dropwhileneg_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_dropwhileneg_div3([5, 5, 5]) == []\nassert op_first3_dropwhileneg_div3([3, 1, 2]) == [3]\nassert op_first3_dropwhileneg_div3([10]) == []\nassert op_first3_dropwhileneg_div3([2, 4, 6]) == [6]\nassert op_first3_dropwhileneg_div3([-7, 12, -7]) == [12]"}
{"id": "op_odds_gt5_absval", "entry_point": "op_odds_gt5_absval", "primitives": ["odds", "gt5", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep values greater than five, then take the absolute value of each.", "solution": "def op_odds_gt5_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_gt5_absval([1, 2, 3, 4]) == []\nassert op_odds_gt5_absval([]) == []\nassert op_odds_gt5_absval([-2, -1, 0, 1, 2]) == []\nassert op_odds_gt5_absval([5, 5, 5]) == []\nassert op_odds_gt5_absval([3, 1, 2]) == []\nassert op_odds_gt5_absval([10]) == []\nassert op_odds_gt5_absval([2, 4, 6]) == []\nassert op_odds_gt5_absval([-7, 12, -7]) == []"}
{"id": "op_add10_gt5_neg", "entry_point": "op_add10_gt5_neg", "primitives": ["add10", "gt5", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then keep the negative numbers.", "solution": "def op_add10_gt5_neg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_add10_gt5_neg([1, 2, 3, 4]) == []\nassert op_add10_gt5_neg([]) == []\nassert op_add10_gt5_neg([-2, -1, 0, 1, 2]) == []\nassert op_add10_gt5_neg([5, 5, 5]) == []\nassert op_add10_gt5_neg([3, 1, 2]) == []\nassert op_add10_gt5_neg([10]) == []\nassert op_add10_gt5_neg([2, 4, 6]) == []\nassert op_add10_gt5_neg([-7, 12, -7]) == []"}
{"id": "op_dropzeros_dropfirst_len", "entry_point": "op_dropzeros_dropfirst_len", "primitives": ["dropzeros", "dropfirst", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then return how many remain.", "solution": "def op_dropzeros_dropfirst_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    return len(r)", "tests": "assert op_dropzeros_dropfirst_len([1, 2, 3, 4]) == 3\nassert op_dropzeros_dropfirst_len([]) == 0\nassert op_dropzeros_dropfirst_len([-2, -1, 0, 1, 2]) == 3\nassert op_dropzeros_dropfirst_len([5, 5, 5]) == 2\nassert op_dropzeros_dropfirst_len([3, 1, 2]) == 2\nassert op_dropzeros_dropfirst_len([10]) == 0\nassert op_dropzeros_dropfirst_len([2, 4, 6]) == 2\nassert op_dropzeros_dropfirst_len([-7, 12, -7]) == 2"}
{"id": "op_negate_double_add10", "entry_point": "op_negate_double_add10", "primitives": ["negate", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then add ten to each.", "solution": "def op_negate_double_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_double_add10([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_negate_double_add10([]) == []\nassert op_negate_double_add10([-2, -1, 0, 1, 2]) == [14, 12, 10, 8, 6]\nassert op_negate_double_add10([5, 5, 5]) == [0, 0, 0]\nassert op_negate_double_add10([3, 1, 2]) == [4, 8, 6]\nassert op_negate_double_add10([10]) == [-10]\nassert op_negate_double_add10([2, 4, 6]) == [6, 2, -2]\nassert op_negate_double_add10([-7, 12, -7]) == [24, -14, 24]"}
{"id": "op_lower_upper_strip", "entry_point": "op_lower_upper_strip", "primitives": ["lower", "upper", "strip"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then uppercase each string, then trim whitespace from each.", "solution": "def op_lower_upper_strip(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.upper() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_lower_upper_strip(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_lower_upper_strip([]) == []\nassert op_lower_upper_strip(['  a ', '', 'BC', 'bc']) == ['A', '', 'BC', 'BC']\nassert op_lower_upper_strip(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_lower_upper_strip(['x']) == ['X']\nassert op_lower_upper_strip(['abc', 'de', '']) == ['ABC', 'DE', '']"}
{"id": "op_square_clamp10_len", "entry_point": "op_square_clamp10_len", "primitives": ["square", "clamp10", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then return how many remain.", "solution": "def op_square_clamp10_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_square_clamp10_len([1, 2, 3, 4]) == 4\nassert op_square_clamp10_len([]) == 0\nassert op_square_clamp10_len([-2, -1, 0, 1, 2]) == 5\nassert op_square_clamp10_len([5, 5, 5]) == 3\nassert op_square_clamp10_len([3, 1, 2]) == 3\nassert op_square_clamp10_len([10]) == 1\nassert op_square_clamp10_len([2, 4, 6]) == 3\nassert op_square_clamp10_len([-7, 12, -7]) == 3"}
{"id": "op_first3_sorta_issorted", "entry_point": "op_first3_sorta_issorted", "primitives": ["first3", "sorta", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_first3_sorta_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_first3_sorta_issorted([1, 2, 3, 4]) == True\nassert op_first3_sorta_issorted([]) == True\nassert op_first3_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_first3_sorta_issorted([5, 5, 5]) == True\nassert op_first3_sorta_issorted([3, 1, 2]) == True\nassert op_first3_sorta_issorted([10]) == True\nassert op_first3_sorta_issorted([2, 4, 6]) == True\nassert op_first3_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_ages_double_neg", "entry_point": "op_ages_double_neg", "primitives": ["ages", "double", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then double each, then keep the negative numbers.", "solution": "def op_ages_double_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_double_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_double_neg([]) == []\nassert op_ages_double_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_double_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_square_odds_pos", "entry_point": "op_square_odds_pos", "primitives": ["square", "odds", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then keep the positive numbers.", "solution": "def op_square_odds_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_odds_pos([1, 2, 3, 4]) == [1, 9]\nassert op_square_odds_pos([]) == []\nassert op_square_odds_pos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_odds_pos([5, 5, 5]) == [25, 25, 25]\nassert op_square_odds_pos([3, 1, 2]) == [9, 1]\nassert op_square_odds_pos([10]) == []\nassert op_square_odds_pos([2, 4, 6]) == []\nassert op_square_odds_pos([-7, 12, -7]) == [49, 49]"}
{"id": "op_evens_odds_alldistinct", "entry_point": "op_evens_odds_alldistinct", "primitives": ["evens", "odds", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then return whether all values are distinct.", "solution": "def op_evens_odds_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_evens_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_evens_odds_alldistinct([]) == True\nassert op_evens_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_evens_odds_alldistinct([5, 5, 5]) == True\nassert op_evens_odds_alldistinct([3, 1, 2]) == True\nassert op_evens_odds_alldistinct([10]) == True\nassert op_evens_odds_alldistinct([2, 4, 6]) == True\nassert op_evens_odds_alldistinct([-7, 12, -7]) == True"}
{"id": "op_add10_dec_negate", "entry_point": "op_add10_dec_negate", "primitives": ["add10", "dec", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then negate each.", "solution": "def op_add10_dec_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_dec_negate([1, 2, 3, 4]) == [-10, -11, -12, -13]\nassert op_add10_dec_negate([]) == []\nassert op_add10_dec_negate([-2, -1, 0, 1, 2]) == [-7, -8, -9, -10, -11]\nassert op_add10_dec_negate([5, 5, 5]) == [-14, -14, -14]\nassert op_add10_dec_negate([3, 1, 2]) == [-12, -10, -11]\nassert op_add10_dec_negate([10]) == [-19]\nassert op_add10_dec_negate([2, 4, 6]) == [-11, -13, -15]\nassert op_add10_dec_negate([-7, 12, -7]) == [-2, -21, -2]"}
{"id": "op_gt5_dropfirst_clamp10", "entry_point": "op_gt5_dropfirst_clamp10", "primitives": ["gt5", "dropfirst", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then cap each value at 10.", "solution": "def op_gt5_dropfirst_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_dropfirst_clamp10([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_clamp10([]) == []\nassert op_gt5_dropfirst_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_clamp10([5, 5, 5]) == []\nassert op_gt5_dropfirst_clamp10([3, 1, 2]) == []\nassert op_gt5_dropfirst_clamp10([10]) == []\nassert op_gt5_dropfirst_clamp10([2, 4, 6]) == []\nassert op_gt5_dropfirst_clamp10([-7, 12, -7]) == []"}
{"id": "op_trimends_padto3_sum", "entry_point": "op_trimends_padto3_sum", "primitives": ["trimends", "padto3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then return their sum.", "solution": "def op_trimends_padto3_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(r)", "tests": "assert op_trimends_padto3_sum([1, 2, 3, 4]) == 5\nassert op_trimends_padto3_sum([]) == 0\nassert op_trimends_padto3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_padto3_sum([5, 5, 5]) == 5\nassert op_trimends_padto3_sum([3, 1, 2]) == 1\nassert op_trimends_padto3_sum([10]) == 0\nassert op_trimends_padto3_sum([2, 4, 6]) == 4\nassert op_trimends_padto3_sum([-7, 12, -7]) == 12"}
{"id": "op_double_uniq_takewhilepos", "entry_point": "op_double_uniq_takewhilepos", "primitives": ["double", "uniq", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then take values while they are positive.", "solution": "def op_double_uniq_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_uniq_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_uniq_takewhilepos([]) == []\nassert op_double_uniq_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_uniq_takewhilepos([5, 5, 5]) == [10]\nassert op_double_uniq_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_uniq_takewhilepos([10]) == [20]\nassert op_double_uniq_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_uniq_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sortalpha_firstchar_nonempty", "entry_point": "op_sortalpha_firstchar_nonempty", "primitives": ["sortalpha", "firstchar", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then keep the first character of each (dropping empties), then drop empty strings.", "solution": "def op_sortalpha_firstchar_nonempty(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_sortalpha_firstchar_nonempty(['Hello', 'world']) == ['H', 'w']\nassert op_sortalpha_firstchar_nonempty([]) == []\nassert op_sortalpha_firstchar_nonempty(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_sortalpha_firstchar_nonempty(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_sortalpha_firstchar_nonempty(['x']) == ['x']\nassert op_sortalpha_firstchar_nonempty(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortd_div3_takewhilepos", "entry_point": "op_sortd_div3_takewhilepos", "primitives": ["sortd", "div3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep multiples of three, then take values while they are positive.", "solution": "def op_sortd_div3_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_div3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_sortd_div3_takewhilepos([]) == []\nassert op_sortd_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortd_div3_takewhilepos([5, 5, 5]) == []\nassert op_sortd_div3_takewhilepos([3, 1, 2]) == [3]\nassert op_sortd_div3_takewhilepos([10]) == []\nassert op_sortd_div3_takewhilepos([2, 4, 6]) == [6]\nassert op_sortd_div3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_trimends_sortd_oremptyzero", "entry_point": "op_trimends_sortd_oremptyzero", "primitives": ["trimends", "sortd", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort descending, then if empty, use a single zero.", "solution": "def op_trimends_sortd_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_sortd_oremptyzero([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_sortd_oremptyzero([]) == [0]\nassert op_trimends_sortd_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_sortd_oremptyzero([5, 5, 5]) == [5]\nassert op_trimends_sortd_oremptyzero([3, 1, 2]) == [1]\nassert op_trimends_sortd_oremptyzero([10]) == [0]\nassert op_trimends_sortd_oremptyzero([2, 4, 6]) == [4]\nassert op_trimends_sortd_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_last3_div3", "entry_point": "op_oremptyzero_last3_div3", "primitives": ["oremptyzero", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then keep multiples of three.", "solution": "def op_oremptyzero_last3_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_last3_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_last3_div3([]) == [0]\nassert op_oremptyzero_last3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_last3_div3([5, 5, 5]) == []\nassert op_oremptyzero_last3_div3([3, 1, 2]) == [3]\nassert op_oremptyzero_last3_div3([10]) == []\nassert op_oremptyzero_last3_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_last3_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_odds_max", "entry_point": "op_dropwhileneg_odds_max", "primitives": ["dropwhileneg", "odds", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_odds_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_odds_max([1, 2, 3, 4]) == 3\nassert op_dropwhileneg_odds_max([]) == 0\nassert op_dropwhileneg_odds_max([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_odds_max([5, 5, 5]) == 5\nassert op_dropwhileneg_odds_max([3, 1, 2]) == 3\nassert op_dropwhileneg_odds_max([10]) == 0\nassert op_dropwhileneg_odds_max([2, 4, 6]) == 0\nassert op_dropwhileneg_odds_max([-7, 12, -7]) == -7"}
{"id": "op_sortalpha_lower_maxlen", "entry_point": "op_sortalpha_lower_maxlen", "primitives": ["sortalpha", "lower", "maxlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then lowercase each string, then return the length of the longest string (0 if none).", "solution": "def op_sortalpha_lower_maxlen(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.lower() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortalpha_lower_maxlen(['Hello', 'world']) == 5\nassert op_sortalpha_lower_maxlen([]) == 0\nassert op_sortalpha_lower_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortalpha_lower_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortalpha_lower_maxlen(['x']) == 1\nassert op_sortalpha_lower_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_odds_inc_neg", "entry_point": "op_odds_inc_neg", "primitives": ["odds", "inc", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then keep the negative numbers.", "solution": "def op_odds_inc_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_inc_neg([1, 2, 3, 4]) == []\nassert op_odds_inc_neg([]) == []\nassert op_odds_inc_neg([-2, -1, 0, 1, 2]) == []\nassert op_odds_inc_neg([5, 5, 5]) == []\nassert op_odds_inc_neg([3, 1, 2]) == []\nassert op_odds_inc_neg([10]) == []\nassert op_odds_inc_neg([2, 4, 6]) == []\nassert op_odds_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_odds_neg_dec", "entry_point": "op_odds_neg_dec", "primitives": ["odds", "neg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then subtract one from each.", "solution": "def op_odds_neg_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_odds_neg_dec([1, 2, 3, 4]) == []\nassert op_odds_neg_dec([]) == []\nassert op_odds_neg_dec([-2, -1, 0, 1, 2]) == [-2]\nassert op_odds_neg_dec([5, 5, 5]) == []\nassert op_odds_neg_dec([3, 1, 2]) == []\nassert op_odds_neg_dec([10]) == []\nassert op_odds_neg_dec([2, 4, 6]) == []\nassert op_odds_neg_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_last3_inc_allpos", "entry_point": "op_last3_inc_allpos", "primitives": ["last3", "inc", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then return whether all values are positive.", "solution": "def op_last3_inc_allpos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_last3_inc_allpos([1, 2, 3, 4]) == True\nassert op_last3_inc_allpos([]) == True\nassert op_last3_inc_allpos([-2, -1, 0, 1, 2]) == True\nassert op_last3_inc_allpos([5, 5, 5]) == True\nassert op_last3_inc_allpos([3, 1, 2]) == True\nassert op_last3_inc_allpos([10]) == True\nassert op_last3_inc_allpos([2, 4, 6]) == True\nassert op_last3_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_double_takewhilepos_allpos", "entry_point": "op_double_takewhilepos_allpos", "primitives": ["double", "takewhilepos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take values while they are positive, then return whether all values are positive.", "solution": "def op_double_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_double_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_double_takewhilepos_allpos([]) == True\nassert op_double_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_double_takewhilepos_allpos([5, 5, 5]) == True\nassert op_double_takewhilepos_allpos([3, 1, 2]) == True\nassert op_double_takewhilepos_allpos([10]) == True\nassert op_double_takewhilepos_allpos([2, 4, 6]) == True\nassert op_double_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_clamp10_padto3_sortd", "entry_point": "op_clamp10_padto3_sortd", "primitives": ["clamp10", "padto3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_clamp10_padto3_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_padto3_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_padto3_sortd([]) == [0, 0, 0]\nassert op_clamp10_padto3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_padto3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_padto3_sortd([10]) == [10, 0, 0]\nassert op_clamp10_padto3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_padto3_sortd([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_sortd_double_dropwhileneg", "entry_point": "op_sortd_double_dropwhileneg", "primitives": ["sortd", "double", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then drop the leading negative values.", "solution": "def op_sortd_double_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_double_dropwhileneg([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_double_dropwhileneg([]) == []\nassert op_sortd_double_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_sortd_double_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_double_dropwhileneg([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_double_dropwhileneg([10]) == [20]\nassert op_sortd_double_dropwhileneg([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_double_dropwhileneg([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_double_absval_padto3", "entry_point": "op_double_absval_padto3", "primitives": ["double", "absval", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then pad with zeros to at least three elements.", "solution": "def op_double_absval_padto3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_double_absval_padto3([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_absval_padto3([]) == [0, 0, 0]\nassert op_double_absval_padto3([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_double_absval_padto3([5, 5, 5]) == [10, 10, 10]\nassert op_double_absval_padto3([3, 1, 2]) == [6, 2, 4]\nassert op_double_absval_padto3([10]) == [20, 0, 0]\nassert op_double_absval_padto3([2, 4, 6]) == [4, 8, 12]\nassert op_double_absval_padto3([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_oremptyzero_rev_double", "entry_point": "op_oremptyzero_rev_double", "primitives": ["oremptyzero", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then double each.", "solution": "def op_oremptyzero_rev_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_oremptyzero_rev_double([]) == [0]\nassert op_oremptyzero_rev_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_oremptyzero_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_oremptyzero_rev_double([10]) == [20]\nassert op_oremptyzero_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_oremptyzero_rev_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_clamp10_oremptyzero_inc", "entry_point": "op_clamp10_oremptyzero_inc", "primitives": ["clamp10", "oremptyzero", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then if empty, use a single zero, then add one to each.", "solution": "def op_clamp10_oremptyzero_inc(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_clamp10_oremptyzero_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_clamp10_oremptyzero_inc([]) == [1]\nassert op_clamp10_oremptyzero_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_clamp10_oremptyzero_inc([5, 5, 5]) == [6, 6, 6]\nassert op_clamp10_oremptyzero_inc([3, 1, 2]) == [4, 2, 3]\nassert op_clamp10_oremptyzero_inc([10]) == [11]\nassert op_clamp10_oremptyzero_inc([2, 4, 6]) == [3, 5, 7]\nassert op_clamp10_oremptyzero_inc([-7, 12, -7]) == [-6, 11, -6]"}
{"id": "op_ages_beforezero_counteven", "entry_point": "op_ages_beforezero_counteven", "primitives": ["ages", "beforezero", "counteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then return how many values are even.", "solution": "def op_ages_beforezero_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_beforezero_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_beforezero_counteven([]) == 0\nassert op_ages_beforezero_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_ages_beforezero_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_double_trimends_allpos", "entry_point": "op_double_trimends_allpos", "primitives": ["double", "trimends", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_double_trimends_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_double_trimends_allpos([1, 2, 3, 4]) == True\nassert op_double_trimends_allpos([]) == True\nassert op_double_trimends_allpos([-2, -1, 0, 1, 2]) == False\nassert op_double_trimends_allpos([5, 5, 5]) == True\nassert op_double_trimends_allpos([3, 1, 2]) == True\nassert op_double_trimends_allpos([10]) == True\nassert op_double_trimends_allpos([2, 4, 6]) == True\nassert op_double_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_rev_add10", "entry_point": "op_sorta_rev_add10", "primitives": ["sorta", "rev", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then add ten to each.", "solution": "def op_sorta_rev_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_rev_add10([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sorta_rev_add10([]) == []\nassert op_sorta_rev_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sorta_rev_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_rev_add10([3, 1, 2]) == [13, 12, 11]\nassert op_sorta_rev_add10([10]) == [20]\nassert op_sorta_rev_add10([2, 4, 6]) == [16, 14, 12]\nassert op_sorta_rev_add10([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_negate_last3_dec", "entry_point": "op_negate_last3_dec", "primitives": ["negate", "last3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then subtract one from each.", "solution": "def op_negate_last3_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_last3_dec([1, 2, 3, 4]) == [-3, -4, -5]\nassert op_negate_last3_dec([]) == []\nassert op_negate_last3_dec([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_negate_last3_dec([5, 5, 5]) == [-6, -6, -6]\nassert op_negate_last3_dec([3, 1, 2]) == [-4, -2, -3]\nassert op_negate_last3_dec([10]) == [-11]\nassert op_negate_last3_dec([2, 4, 6]) == [-3, -5, -7]\nassert op_negate_last3_dec([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_lower_strip_uniqs", "entry_point": "op_lower_strip_uniqs", "primitives": ["lower", "strip", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then trim whitespace from each, then drop duplicate strings keeping the first.", "solution": "def op_lower_strip_uniqs(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_lower_strip_uniqs(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_strip_uniqs([]) == []\nassert op_lower_strip_uniqs(['  a ', '', 'BC', 'bc']) == ['a', '', 'bc']\nassert op_lower_strip_uniqs(['one', 'one', 'Two']) == ['one', 'two']\nassert op_lower_strip_uniqs(['x']) == ['x']\nassert op_lower_strip_uniqs(['abc', 'de', '']) == ['abc', 'de', '']"}
{"id": "op_double_dropfirst_dropwhileneg", "entry_point": "op_double_dropfirst_dropwhileneg", "primitives": ["double", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then drop the leading negative values.", "solution": "def op_double_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_dropfirst_dropwhileneg([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst_dropwhileneg([]) == []\nassert op_double_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_dropfirst_dropwhileneg([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst_dropwhileneg([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst_dropwhileneg([10]) == []\nassert op_double_dropfirst_dropwhileneg([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst_dropwhileneg([-7, 12, -7]) == [24, -14]"}
{"id": "op_evens_add10_uniq", "entry_point": "op_evens_add10_uniq", "primitives": ["evens", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_evens_add10_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_evens_add10_uniq([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10_uniq([]) == []\nassert op_evens_add10_uniq([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10_uniq([5, 5, 5]) == []\nassert op_evens_add10_uniq([3, 1, 2]) == [12]\nassert op_evens_add10_uniq([10]) == [20]\nassert op_evens_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10_uniq([-7, 12, -7]) == [22]"}
{"id": "op_first3_uniq_dropzeros", "entry_point": "op_first3_uniq_dropzeros", "primitives": ["first3", "uniq", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_first3_uniq_dropzeros(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_first3_uniq_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_uniq_dropzeros([]) == []\nassert op_first3_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_first3_uniq_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_first3_uniq_dropzeros([10]) == [10]\nassert op_first3_uniq_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_first3_uniq_dropzeros([-7, 12, -7]) == [-7, 12]"}
{"id": "op_sortabs_neg_uniq", "entry_point": "op_sortabs_neg_uniq", "primitives": ["sortabs", "neg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_neg_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_neg_uniq([1, 2, 3, 4]) == []\nassert op_sortabs_neg_uniq([]) == []\nassert op_sortabs_neg_uniq([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_neg_uniq([5, 5, 5]) == []\nassert op_sortabs_neg_uniq([3, 1, 2]) == []\nassert op_sortabs_neg_uniq([10]) == []\nassert op_sortabs_neg_uniq([2, 4, 6]) == []\nassert op_sortabs_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_rev_dropwhileneg_square", "entry_point": "op_rev_dropwhileneg_square", "primitives": ["rev", "dropwhileneg", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then square each.", "solution": "def op_rev_dropwhileneg_square(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_rev_dropwhileneg_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_dropwhileneg_square([]) == []\nassert op_rev_dropwhileneg_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_rev_dropwhileneg_square([5, 5, 5]) == [25, 25, 25]\nassert op_rev_dropwhileneg_square([3, 1, 2]) == [4, 1, 9]\nassert op_rev_dropwhileneg_square([10]) == [100]\nassert op_rev_dropwhileneg_square([2, 4, 6]) == [36, 16, 4]\nassert op_rev_dropwhileneg_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_double_pos_oremptyzero", "entry_point": "op_double_pos_oremptyzero", "primitives": ["double", "pos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_double_pos_oremptyzero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_double_pos_oremptyzero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_pos_oremptyzero([]) == [0]\nassert op_double_pos_oremptyzero([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_pos_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_double_pos_oremptyzero([3, 1, 2]) == [6, 2, 4]\nassert op_double_pos_oremptyzero([10]) == [20]\nassert op_double_pos_oremptyzero([2, 4, 6]) == [4, 8, 12]\nassert op_double_pos_oremptyzero([-7, 12, -7]) == [24]"}
{"id": "op_uniq_dec_takewhilepos", "entry_point": "op_uniq_dec_takewhilepos", "primitives": ["uniq", "dec", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then take values while they are positive.", "solution": "def op_uniq_dec_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_dec_takewhilepos([1, 2, 3, 4]) == []\nassert op_uniq_dec_takewhilepos([]) == []\nassert op_uniq_dec_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_dec_takewhilepos([5, 5, 5]) == [4]\nassert op_uniq_dec_takewhilepos([3, 1, 2]) == [2]\nassert op_uniq_dec_takewhilepos([10]) == [9]\nassert op_uniq_dec_takewhilepos([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_dec_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dec_odds_padto3", "entry_point": "op_dec_odds_padto3", "primitives": ["dec", "odds", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the odd numbers, then pad with zeros to at least three elements.", "solution": "def op_dec_odds_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_odds_padto3([1, 2, 3, 4]) == [1, 3, 0]\nassert op_dec_odds_padto3([]) == [0, 0, 0]\nassert op_dec_odds_padto3([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_dec_odds_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_dec_odds_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_dec_odds_padto3([10]) == [9, 0, 0]\nassert op_dec_odds_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_odds_padto3([-7, 12, -7]) == [11, 0, 0]"}
{"id": "op_ages_sortabs_padto3", "entry_point": "op_ages_sortabs_padto3", "primitives": ["ages", "sortabs", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_ages_sortabs_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_sortabs_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36, 0]\nassert op_ages_sortabs_padto3([]) == [0, 0, 0]\nassert op_ages_sortabs_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_sortabs_padto3([{'name': 'Fi', 'age': 41}]) == [41, 0, 0]"}
{"id": "op_ages_odds_counteven", "entry_point": "op_ages_odds_counteven", "primitives": ["ages", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then return how many values are even.", "solution": "def op_ages_odds_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_odds_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_odds_counteven([]) == 0\nassert op_ages_odds_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 0\nassert op_ages_odds_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_ages_square_neg", "entry_point": "op_ages_square_neg", "primitives": ["ages", "square", "neg"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then keep the negative numbers.", "solution": "def op_ages_square_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_square_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_square_neg([]) == []\nassert op_ages_square_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_square_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_evens_double_dec", "entry_point": "op_evens_double_dec", "primitives": ["evens", "double", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then subtract one from each.", "solution": "def op_evens_double_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_evens_double_dec([1, 2, 3, 4]) == [3, 7]\nassert op_evens_double_dec([]) == []\nassert op_evens_double_dec([-2, -1, 0, 1, 2]) == [-5, -1, 3]\nassert op_evens_double_dec([5, 5, 5]) == []\nassert op_evens_double_dec([3, 1, 2]) == [3]\nassert op_evens_double_dec([10]) == [19]\nassert op_evens_double_dec([2, 4, 6]) == [3, 7, 11]\nassert op_evens_double_dec([-7, 12, -7]) == [23]"}
{"id": "op_sorta_dropwhileneg_dec", "entry_point": "op_sorta_dropwhileneg_dec", "primitives": ["sorta", "dropwhileneg", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then subtract one from each.", "solution": "def op_sorta_dropwhileneg_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_dropwhileneg_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sorta_dropwhileneg_dec([]) == []\nassert op_sorta_dropwhileneg_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_sorta_dropwhileneg_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_dropwhileneg_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sorta_dropwhileneg_dec([10]) == [9]\nassert op_sorta_dropwhileneg_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sorta_dropwhileneg_dec([-7, 12, -7]) == [11]"}
{"id": "op_clamp10_negate_first3", "entry_point": "op_clamp10_negate_first3", "primitives": ["clamp10", "negate", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then keep only the first three.", "solution": "def op_clamp10_negate_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_negate_first3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_clamp10_negate_first3([]) == []\nassert op_clamp10_negate_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_clamp10_negate_first3([5, 5, 5]) == [-5, -5, -5]\nassert op_clamp10_negate_first3([3, 1, 2]) == [-3, -1, -2]\nassert op_clamp10_negate_first3([10]) == [-10]\nassert op_clamp10_negate_first3([2, 4, 6]) == [-2, -4, -6]\nassert op_clamp10_negate_first3([-7, 12, -7]) == [7, -10, 7]"}
{"id": "op_uniq_beforezero_square", "entry_point": "op_uniq_beforezero_square", "primitives": ["uniq", "beforezero", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then square each.", "solution": "def op_uniq_beforezero_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_beforezero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_beforezero_square([]) == []\nassert op_uniq_beforezero_square([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_uniq_beforezero_square([5, 5, 5]) == [25]\nassert op_uniq_beforezero_square([3, 1, 2]) == [9, 1, 4]\nassert op_uniq_beforezero_square([10]) == [100]\nassert op_uniq_beforezero_square([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_beforezero_square([-7, 12, -7]) == [49, 144]"}
{"id": "op_sorta_absval_dropzeros", "entry_point": "op_sorta_absval_dropzeros", "primitives": ["sorta", "absval", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then drop the zeros.", "solution": "def op_sorta_absval_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_absval_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_absval_dropzeros([]) == []\nassert op_sorta_absval_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_sorta_absval_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_absval_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_absval_dropzeros([10]) == [10]\nassert op_sorta_absval_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_absval_dropzeros([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_padto3_dropzeros_double", "entry_point": "op_padto3_dropzeros_double", "primitives": ["padto3", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros, then double each.", "solution": "def op_padto3_dropzeros_double(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_padto3_dropzeros_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_dropzeros_double([]) == []\nassert op_padto3_dropzeros_double([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_padto3_dropzeros_double([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_dropzeros_double([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_dropzeros_double([10]) == [20]\nassert op_padto3_dropzeros_double([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_dropzeros_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_square_odds_evens", "entry_point": "op_square_odds_evens", "primitives": ["square", "odds", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then keep the even numbers.", "solution": "def op_square_odds_evens(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_square_odds_evens([1, 2, 3, 4]) == []\nassert op_square_odds_evens([]) == []\nassert op_square_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_square_odds_evens([5, 5, 5]) == []\nassert op_square_odds_evens([3, 1, 2]) == []\nassert op_square_odds_evens([10]) == []\nassert op_square_odds_evens([2, 4, 6]) == []\nassert op_square_odds_evens([-7, 12, -7]) == []"}
{"id": "op_inc_sortabs_dropzeros", "entry_point": "op_inc_sortabs_dropzeros", "primitives": ["inc", "sortabs", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then drop the zeros.", "solution": "def op_inc_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_inc_sortabs_dropzeros([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sortabs_dropzeros([]) == []\nassert op_inc_sortabs_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, 2, 3]\nassert op_inc_sortabs_dropzeros([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortabs_dropzeros([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sortabs_dropzeros([10]) == [11]\nassert op_inc_sortabs_dropzeros([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sortabs_dropzeros([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_first3_odds_dropwhileneg", "entry_point": "op_first3_odds_dropwhileneg", "primitives": ["first3", "odds", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_first3_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_odds_dropwhileneg([1, 2, 3, 4]) == [1, 3]\nassert op_first3_odds_dropwhileneg([]) == []\nassert op_first3_odds_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_first3_odds_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_first3_odds_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_first3_odds_dropwhileneg([10]) == []\nassert op_first3_odds_dropwhileneg([2, 4, 6]) == []\nassert op_first3_odds_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_sortlen_prefixup_longest", "entry_point": "op_sortlen_prefixup_longest", "primitives": ["sortlen", "prefixup", "longest"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then prefix each with a hash, then return the longest string (empty if none).", "solution": "def op_sortlen_prefixup_longest(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_sortlen_prefixup_longest(['Hello', 'world']) == '#Hello'\nassert op_sortlen_prefixup_longest([]) == ''\nassert op_sortlen_prefixup_longest(['  a ', '', 'BC', 'bc']) == '#  a '\nassert op_sortlen_prefixup_longest(['one', 'one', 'Two']) == '#one'\nassert op_sortlen_prefixup_longest(['x']) == '#x'\nassert op_sortlen_prefixup_longest(['abc', 'de', '']) == '#abc'"}
{"id": "op_clamp10_dropfirst_double", "entry_point": "op_clamp10_dropfirst_double", "primitives": ["clamp10", "dropfirst", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element, then double each.", "solution": "def op_clamp10_dropfirst_double(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_clamp10_dropfirst_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_clamp10_dropfirst_double([]) == []\nassert op_clamp10_dropfirst_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_clamp10_dropfirst_double([5, 5, 5]) == [10, 10]\nassert op_clamp10_dropfirst_double([3, 1, 2]) == [2, 4]\nassert op_clamp10_dropfirst_double([10]) == []\nassert op_clamp10_dropfirst_double([2, 4, 6]) == [8, 12]\nassert op_clamp10_dropfirst_double([-7, 12, -7]) == [20, -14]"}
{"id": "op_ages_negate_add10", "entry_point": "op_ages_negate_add10", "primitives": ["ages", "negate", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then add ten to each.", "solution": "def op_ages_negate_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_negate_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-26, -2]\nassert op_ages_negate_add10([]) == []\nassert op_ages_negate_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-8, -55, -7]\nassert op_ages_negate_add10([{'name': 'Fi', 'age': 41}]) == [-31]"}
{"id": "op_neg_rev_dropzeros", "entry_point": "op_neg_rev_dropzeros", "primitives": ["neg", "rev", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then drop the zeros.", "solution": "def op_neg_rev_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_neg_rev_dropzeros([1, 2, 3, 4]) == []\nassert op_neg_rev_dropzeros([]) == []\nassert op_neg_rev_dropzeros([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_rev_dropzeros([5, 5, 5]) == []\nassert op_neg_rev_dropzeros([3, 1, 2]) == []\nassert op_neg_rev_dropzeros([10]) == []\nassert op_neg_rev_dropzeros([2, 4, 6]) == []\nassert op_neg_rev_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_beforezero_padto3", "entry_point": "op_neg_beforezero_padto3", "primitives": ["neg", "beforezero", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then pad with zeros to at least three elements.", "solution": "def op_neg_beforezero_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_beforezero_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_neg_beforezero_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([10]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_beforezero_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_square_absval_firsteven", "entry_point": "op_square_absval_firsteven", "primitives": ["square", "absval", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_square_absval_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_absval_firsteven([1, 2, 3, 4]) == 4\nassert op_square_absval_firsteven([]) == 0\nassert op_square_absval_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_square_absval_firsteven([5, 5, 5]) == 0\nassert op_square_absval_firsteven([3, 1, 2]) == 4\nassert op_square_absval_firsteven([10]) == 100\nassert op_square_absval_firsteven([2, 4, 6]) == 4\nassert op_square_absval_firsteven([-7, 12, -7]) == 144"}
{"id": "op_ages_sortd_inc", "entry_point": "op_ages_sortd_inc", "primitives": ["ages", "sortd", "inc"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then add one to each.", "solution": "def op_ages_sortd_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_sortd_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [37, 13]\nassert op_ages_sortd_inc([]) == []\nassert op_ages_sortd_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [66, 19, 18]\nassert op_ages_sortd_inc([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_dropwhileneg_rev_evens", "entry_point": "op_dropwhileneg_rev_evens", "primitives": ["dropwhileneg", "rev", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then keep the even numbers.", "solution": "def op_dropwhileneg_rev_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_rev_evens([1, 2, 3, 4]) == [4, 2]\nassert op_dropwhileneg_rev_evens([]) == []\nassert op_dropwhileneg_rev_evens([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dropwhileneg_rev_evens([5, 5, 5]) == []\nassert op_dropwhileneg_rev_evens([3, 1, 2]) == [2]\nassert op_dropwhileneg_rev_evens([10]) == [10]\nassert op_dropwhileneg_rev_evens([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_rev_evens([-7, 12, -7]) == [12]"}
{"id": "op_neg_oremptyzero_first3", "entry_point": "op_neg_oremptyzero_first3", "primitives": ["neg", "oremptyzero", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero, then keep only the first three.", "solution": "def op_neg_oremptyzero_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    r = r[:3]\n    return r", "tests": "assert op_neg_oremptyzero_first3([1, 2, 3, 4]) == [0]\nassert op_neg_oremptyzero_first3([]) == [0]\nassert op_neg_oremptyzero_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_oremptyzero_first3([5, 5, 5]) == [0]\nassert op_neg_oremptyzero_first3([3, 1, 2]) == [0]\nassert op_neg_oremptyzero_first3([10]) == [0]\nassert op_neg_oremptyzero_first3([2, 4, 6]) == [0]\nassert op_neg_oremptyzero_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_negate_rev_add10", "entry_point": "op_negate_rev_add10", "primitives": ["negate", "rev", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then reverse the order, then add ten to each.", "solution": "def op_negate_rev_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_rev_add10([1, 2, 3, 4]) == [6, 7, 8, 9]\nassert op_negate_rev_add10([]) == []\nassert op_negate_rev_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_negate_rev_add10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_rev_add10([3, 1, 2]) == [8, 9, 7]\nassert op_negate_rev_add10([10]) == [0]\nassert op_negate_rev_add10([2, 4, 6]) == [4, 6, 8]\nassert op_negate_rev_add10([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_gt5_div3_issorted", "entry_point": "op_gt5_div3_issorted", "primitives": ["gt5", "div3", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_gt5_div3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_gt5_div3_issorted([1, 2, 3, 4]) == True\nassert op_gt5_div3_issorted([]) == True\nassert op_gt5_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_div3_issorted([5, 5, 5]) == True\nassert op_gt5_div3_issorted([3, 1, 2]) == True\nassert op_gt5_div3_issorted([10]) == True\nassert op_gt5_div3_issorted([2, 4, 6]) == True\nassert op_gt5_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_last3_dropfirst_max", "entry_point": "op_last3_dropfirst_max", "primitives": ["last3", "dropfirst", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_last3_dropfirst_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_last3_dropfirst_max([1, 2, 3, 4]) == 4\nassert op_last3_dropfirst_max([]) == 0\nassert op_last3_dropfirst_max([-2, -1, 0, 1, 2]) == 2\nassert op_last3_dropfirst_max([5, 5, 5]) == 5\nassert op_last3_dropfirst_max([3, 1, 2]) == 2\nassert op_last3_dropfirst_max([10]) == 0\nassert op_last3_dropfirst_max([2, 4, 6]) == 6\nassert op_last3_dropfirst_max([-7, 12, -7]) == 12"}
{"id": "op_div3_dropfirst_anyeven", "entry_point": "op_div3_dropfirst_anyeven", "primitives": ["div3", "dropfirst", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then return whether any value is even.", "solution": "def op_div3_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_dropfirst_anyeven([1, 2, 3, 4]) == False\nassert op_div3_dropfirst_anyeven([]) == False\nassert op_div3_dropfirst_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_div3_dropfirst_anyeven([5, 5, 5]) == False\nassert op_div3_dropfirst_anyeven([3, 1, 2]) == False\nassert op_div3_dropfirst_anyeven([10]) == False\nassert op_div3_dropfirst_anyeven([2, 4, 6]) == False\nassert op_div3_dropfirst_anyeven([-7, 12, -7]) == False"}
{"id": "op_sortabs_takewhilepos_gt5", "entry_point": "op_sortabs_takewhilepos_gt5", "primitives": ["sortabs", "takewhilepos", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then keep values greater than five.", "solution": "def op_sortabs_takewhilepos_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_takewhilepos_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_takewhilepos_gt5([]) == []\nassert op_sortabs_takewhilepos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_takewhilepos_gt5([5, 5, 5]) == []\nassert op_sortabs_takewhilepos_gt5([3, 1, 2]) == []\nassert op_sortabs_takewhilepos_gt5([10]) == [10]\nassert op_sortabs_takewhilepos_gt5([2, 4, 6]) == [6]\nassert op_sortabs_takewhilepos_gt5([-7, 12, -7]) == []"}
{"id": "op_double_pos_square", "entry_point": "op_double_pos_square", "primitives": ["double", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then square each.", "solution": "def op_double_pos_square(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_double_pos_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_double_pos_square([]) == []\nassert op_double_pos_square([-2, -1, 0, 1, 2]) == [4, 16]\nassert op_double_pos_square([5, 5, 5]) == [100, 100, 100]\nassert op_double_pos_square([3, 1, 2]) == [36, 4, 16]\nassert op_double_pos_square([10]) == [400]\nassert op_double_pos_square([2, 4, 6]) == [16, 64, 144]\nassert op_double_pos_square([-7, 12, -7]) == [576]"}
{"id": "op_odds_uniq_takewhilepos", "entry_point": "op_odds_uniq_takewhilepos", "primitives": ["odds", "uniq", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then take values while they are positive.", "solution": "def op_odds_uniq_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_odds_uniq_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_uniq_takewhilepos([]) == []\nassert op_odds_uniq_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_odds_uniq_takewhilepos([5, 5, 5]) == [5]\nassert op_odds_uniq_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_odds_uniq_takewhilepos([10]) == []\nassert op_odds_uniq_takewhilepos([2, 4, 6]) == []\nassert op_odds_uniq_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_beforezero_dropwhileneg", "entry_point": "op_oremptyzero_beforezero_dropwhileneg", "primitives": ["oremptyzero", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_oremptyzero_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_beforezero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_beforezero_dropwhileneg([]) == []\nassert op_oremptyzero_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_beforezero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_beforezero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_beforezero_dropwhileneg([10]) == [10]\nassert op_oremptyzero_beforezero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_beforezero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_trimends_first3_gt5", "entry_point": "op_trimends_first3_gt5", "primitives": ["trimends", "first3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the first three, then keep values greater than five.", "solution": "def op_trimends_first3_gt5(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_trimends_first3_gt5([1, 2, 3, 4]) == []\nassert op_trimends_first3_gt5([]) == []\nassert op_trimends_first3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_trimends_first3_gt5([5, 5, 5]) == []\nassert op_trimends_first3_gt5([3, 1, 2]) == []\nassert op_trimends_first3_gt5([10]) == []\nassert op_trimends_first3_gt5([2, 4, 6]) == []\nassert op_trimends_first3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_odds_neg_len", "entry_point": "op_odds_neg_len", "primitives": ["odds", "neg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then return how many remain.", "solution": "def op_odds_neg_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_odds_neg_len([1, 2, 3, 4]) == 0\nassert op_odds_neg_len([]) == 0\nassert op_odds_neg_len([-2, -1, 0, 1, 2]) == 1\nassert op_odds_neg_len([5, 5, 5]) == 0\nassert op_odds_neg_len([3, 1, 2]) == 0\nassert op_odds_neg_len([10]) == 0\nassert op_odds_neg_len([2, 4, 6]) == 0\nassert op_odds_neg_len([-7, 12, -7]) == 2"}
{"id": "op_dropfirst_oremptyzero_trimends", "entry_point": "op_dropfirst_oremptyzero_trimends", "primitives": ["dropfirst", "oremptyzero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_dropfirst_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_oremptyzero_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_oremptyzero_trimends([]) == []\nassert op_dropfirst_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dropfirst_oremptyzero_trimends([5, 5, 5]) == []\nassert op_dropfirst_oremptyzero_trimends([3, 1, 2]) == []\nassert op_dropfirst_oremptyzero_trimends([10]) == []\nassert op_dropfirst_oremptyzero_trimends([2, 4, 6]) == []\nassert op_dropfirst_oremptyzero_trimends([-7, 12, -7]) == []"}
{"id": "op_dropfirst_neg_sortd", "entry_point": "op_dropfirst_neg_sortd", "primitives": ["dropfirst", "neg", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then sort descending.", "solution": "def op_dropfirst_neg_sortd(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropfirst_neg_sortd([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_sortd([]) == []\nassert op_dropfirst_neg_sortd([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg_sortd([5, 5, 5]) == []\nassert op_dropfirst_neg_sortd([3, 1, 2]) == []\nassert op_dropfirst_neg_sortd([10]) == []\nassert op_dropfirst_neg_sortd([2, 4, 6]) == []\nassert op_dropfirst_neg_sortd([-7, 12, -7]) == [-7]"}
{"id": "op_sortabs_neg_allpos", "entry_point": "op_sortabs_neg_allpos", "primitives": ["sortabs", "neg", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then return whether all values are positive.", "solution": "def op_sortabs_neg_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_neg_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_neg_allpos([]) == True\nassert op_sortabs_neg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_neg_allpos([5, 5, 5]) == True\nassert op_sortabs_neg_allpos([3, 1, 2]) == True\nassert op_sortabs_neg_allpos([10]) == True\nassert op_sortabs_neg_allpos([2, 4, 6]) == True\nassert op_sortabs_neg_allpos([-7, 12, -7]) == False"}
{"id": "op_evens_div3_first3", "entry_point": "op_evens_div3_first3", "primitives": ["evens", "div3", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then keep only the first three.", "solution": "def op_evens_div3_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_evens_div3_first3([1, 2, 3, 4]) == []\nassert op_evens_div3_first3([]) == []\nassert op_evens_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_div3_first3([5, 5, 5]) == []\nassert op_evens_div3_first3([3, 1, 2]) == []\nassert op_evens_div3_first3([10]) == []\nassert op_evens_div3_first3([2, 4, 6]) == [6]\nassert op_evens_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_uniq_dropfirst_beforezero", "entry_point": "op_uniq_dropfirst_beforezero", "primitives": ["uniq", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then keep everything before the first zero.", "solution": "def op_uniq_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_dropfirst_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_dropfirst_beforezero([]) == []\nassert op_uniq_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_uniq_dropfirst_beforezero([5, 5, 5]) == []\nassert op_uniq_dropfirst_beforezero([3, 1, 2]) == [1, 2]\nassert op_uniq_dropfirst_beforezero([10]) == []\nassert op_uniq_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_uniq_dropfirst_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_rev_double", "entry_point": "op_sortabs_rev_double", "primitives": ["sortabs", "rev", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then reverse the order, then double each.", "solution": "def op_sortabs_rev_double(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortabs_rev_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortabs_rev_double([]) == []\nassert op_sortabs_rev_double([-2, -1, 0, 1, 2]) == [4, -4, 2, -2, 0]\nassert op_sortabs_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_rev_double([3, 1, 2]) == [6, 4, 2]\nassert op_sortabs_rev_double([10]) == [20]\nassert op_sortabs_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_sortabs_rev_double([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_clamp10_absval_odds", "entry_point": "op_clamp10_absval_odds", "primitives": ["clamp10", "absval", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then keep the odd numbers.", "solution": "def op_clamp10_absval_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_absval_odds([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_absval_odds([]) == []\nassert op_clamp10_absval_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_clamp10_absval_odds([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_absval_odds([3, 1, 2]) == [3, 1]\nassert op_clamp10_absval_odds([10]) == []\nassert op_clamp10_absval_odds([2, 4, 6]) == []\nassert op_clamp10_absval_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_dropfirst_sortd_add10", "entry_point": "op_dropfirst_sortd_add10", "primitives": ["dropfirst", "sortd", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then add ten to each.", "solution": "def op_dropfirst_sortd_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_sortd_add10([1, 2, 3, 4]) == [14, 13, 12]\nassert op_dropfirst_sortd_add10([]) == []\nassert op_dropfirst_sortd_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9]\nassert op_dropfirst_sortd_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_sortd_add10([3, 1, 2]) == [12, 11]\nassert op_dropfirst_sortd_add10([10]) == []\nassert op_dropfirst_sortd_add10([2, 4, 6]) == [16, 14]\nassert op_dropfirst_sortd_add10([-7, 12, -7]) == [22, 3]"}
{"id": "op_square_uniq_div3", "entry_point": "op_square_uniq_div3", "primitives": ["square", "uniq", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then keep multiples of three.", "solution": "def op_square_uniq_div3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_square_uniq_div3([1, 2, 3, 4]) == [9]\nassert op_square_uniq_div3([]) == []\nassert op_square_uniq_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_square_uniq_div3([5, 5, 5]) == []\nassert op_square_uniq_div3([3, 1, 2]) == [9]\nassert op_square_uniq_div3([10]) == []\nassert op_square_uniq_div3([2, 4, 6]) == [36]\nassert op_square_uniq_div3([-7, 12, -7]) == [144]"}
{"id": "op_last3_evens_gt5", "entry_point": "op_last3_evens_gt5", "primitives": ["last3", "evens", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers, then keep values greater than five.", "solution": "def op_last3_evens_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_evens_gt5([1, 2, 3, 4]) == []\nassert op_last3_evens_gt5([]) == []\nassert op_last3_evens_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_evens_gt5([5, 5, 5]) == []\nassert op_last3_evens_gt5([3, 1, 2]) == []\nassert op_last3_evens_gt5([10]) == [10]\nassert op_last3_evens_gt5([2, 4, 6]) == [6]\nassert op_last3_evens_gt5([-7, 12, -7]) == [12]"}
{"id": "op_uniq_negate_trimends", "entry_point": "op_uniq_negate_trimends", "primitives": ["uniq", "negate", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then drop the first and last elements.", "solution": "def op_uniq_negate_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_negate_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_uniq_negate_trimends([]) == []\nassert op_uniq_negate_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_uniq_negate_trimends([5, 5, 5]) == []\nassert op_uniq_negate_trimends([3, 1, 2]) == [-1]\nassert op_uniq_negate_trimends([10]) == []\nassert op_uniq_negate_trimends([2, 4, 6]) == [-4]\nassert op_uniq_negate_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_first3_takewhilepos", "entry_point": "op_add10_first3_takewhilepos", "primitives": ["add10", "first3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then take values while they are positive.", "solution": "def op_add10_first3_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_add10_first3_takewhilepos([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_first3_takewhilepos([]) == []\nassert op_add10_first3_takewhilepos([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3_takewhilepos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_first3_takewhilepos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_first3_takewhilepos([10]) == [20]\nassert op_add10_first3_takewhilepos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_first3_takewhilepos([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_rev_padto3_oremptyzero", "entry_point": "op_rev_padto3_oremptyzero", "primitives": ["rev", "padto3", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_rev_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_padto3_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_rev_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_padto3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_padto3_oremptyzero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_padto3_oremptyzero([10]) == [10, 0, 0]\nassert op_rev_padto3_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_padto3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sorta_clamp10_issorted", "entry_point": "op_sorta_clamp10_issorted", "primitives": ["sorta", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_sorta_clamp10_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_sorta_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_sorta_clamp10_issorted([]) == True\nassert op_sorta_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_clamp10_issorted([5, 5, 5]) == True\nassert op_sorta_clamp10_issorted([3, 1, 2]) == True\nassert op_sorta_clamp10_issorted([10]) == True\nassert op_sorta_clamp10_issorted([2, 4, 6]) == True\nassert op_sorta_clamp10_issorted([-7, 12, -7]) == True"}
{"id": "op_sortd_inc_first3", "entry_point": "op_sortd_inc_first3", "primitives": ["sortd", "inc", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then keep only the first three.", "solution": "def op_sortd_inc_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_sortd_inc_first3([1, 2, 3, 4]) == [5, 4, 3]\nassert op_sortd_inc_first3([]) == []\nassert op_sortd_inc_first3([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_sortd_inc_first3([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_inc_first3([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_inc_first3([10]) == [11]\nassert op_sortd_inc_first3([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_inc_first3([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_neg_sortd_haszero", "entry_point": "op_neg_sortd_haszero", "primitives": ["neg", "sortd", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending, then return whether the list contains a zero.", "solution": "def op_neg_sortd_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_neg_sortd_haszero([1, 2, 3, 4]) == False\nassert op_neg_sortd_haszero([]) == False\nassert op_neg_sortd_haszero([-2, -1, 0, 1, 2]) == False\nassert op_neg_sortd_haszero([5, 5, 5]) == False\nassert op_neg_sortd_haszero([3, 1, 2]) == False\nassert op_neg_sortd_haszero([10]) == False\nassert op_neg_sortd_haszero([2, 4, 6]) == False\nassert op_neg_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_div3_firsteven", "entry_point": "op_dec_div3_firsteven", "primitives": ["dec", "div3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three, then return the first even value (0 if none).", "solution": "def op_dec_div3_firsteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dec_div3_firsteven([1, 2, 3, 4]) == 0\nassert op_dec_div3_firsteven([]) == 0\nassert op_dec_div3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dec_div3_firsteven([5, 5, 5]) == 0\nassert op_dec_div3_firsteven([3, 1, 2]) == 0\nassert op_dec_div3_firsteven([10]) == 0\nassert op_dec_div3_firsteven([2, 4, 6]) == 0\nassert op_dec_div3_firsteven([-7, 12, -7]) == 0"}
{"id": "op_neg_oremptyzero_sorta", "entry_point": "op_neg_oremptyzero_sorta", "primitives": ["neg", "oremptyzero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero, then sort ascending.", "solution": "def op_neg_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_neg_oremptyzero_sorta([1, 2, 3, 4]) == [0]\nassert op_neg_oremptyzero_sorta([]) == [0]\nassert op_neg_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_oremptyzero_sorta([5, 5, 5]) == [0]\nassert op_neg_oremptyzero_sorta([3, 1, 2]) == [0]\nassert op_neg_oremptyzero_sorta([10]) == [0]\nassert op_neg_oremptyzero_sorta([2, 4, 6]) == [0]\nassert op_neg_oremptyzero_sorta([-7, 12, -7]) == [-7, -7]"}
{"id": "op_evens_double_max", "entry_point": "op_evens_double_max", "primitives": ["evens", "double", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then return the maximum (0 if empty).", "solution": "def op_evens_double_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_evens_double_max([1, 2, 3, 4]) == 8\nassert op_evens_double_max([]) == 0\nassert op_evens_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_evens_double_max([5, 5, 5]) == 0\nassert op_evens_double_max([3, 1, 2]) == 4\nassert op_evens_double_max([10]) == 20\nassert op_evens_double_max([2, 4, 6]) == 12\nassert op_evens_double_max([-7, 12, -7]) == 24"}
{"id": "op_square_sorta_negate", "entry_point": "op_square_sorta_negate", "primitives": ["square", "sorta", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then negate each.", "solution": "def op_square_sorta_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_sorta_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_sorta_negate([]) == []\nassert op_square_sorta_negate([-2, -1, 0, 1, 2]) == [0, -1, -1, -4, -4]\nassert op_square_sorta_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_sorta_negate([3, 1, 2]) == [-1, -4, -9]\nassert op_square_sorta_negate([10]) == [-100]\nassert op_square_sorta_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_sorta_negate([-7, 12, -7]) == [-49, -49, -144]"}
{"id": "op_padto3_inc_uniq", "entry_point": "op_padto3_inc_uniq", "primitives": ["padto3", "inc", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_padto3_inc_uniq(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_padto3_inc_uniq([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_padto3_inc_uniq([]) == [1]\nassert op_padto3_inc_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_padto3_inc_uniq([5, 5, 5]) == [6]\nassert op_padto3_inc_uniq([3, 1, 2]) == [4, 2, 3]\nassert op_padto3_inc_uniq([10]) == [11, 1]\nassert op_padto3_inc_uniq([2, 4, 6]) == [3, 5, 7]\nassert op_padto3_inc_uniq([-7, 12, -7]) == [-6, 13]"}
{"id": "op_negate_takewhilepos_double", "entry_point": "op_negate_takewhilepos_double", "primitives": ["negate", "takewhilepos", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then double each.", "solution": "def op_negate_takewhilepos_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_takewhilepos_double([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos_double([]) == []\nassert op_negate_takewhilepos_double([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_negate_takewhilepos_double([5, 5, 5]) == []\nassert op_negate_takewhilepos_double([3, 1, 2]) == []\nassert op_negate_takewhilepos_double([10]) == []\nassert op_negate_takewhilepos_double([2, 4, 6]) == []\nassert op_negate_takewhilepos_double([-7, 12, -7]) == [14]"}
{"id": "op_dropzeros_double_absval", "entry_point": "op_dropzeros_double_absval", "primitives": ["dropzeros", "double", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then take the absolute value of each.", "solution": "def op_dropzeros_double_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_double_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double_absval([]) == []\nassert op_dropzeros_double_absval([-2, -1, 0, 1, 2]) == [4, 2, 2, 4]\nassert op_dropzeros_double_absval([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_double_absval([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_double_absval([10]) == [20]\nassert op_dropzeros_double_absval([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_double_absval([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_beforezero_double_sortd", "entry_point": "op_beforezero_double_sortd", "primitives": ["beforezero", "double", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then sort descending.", "solution": "def op_beforezero_double_sortd(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_beforezero_double_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_beforezero_double_sortd([]) == []\nassert op_beforezero_double_sortd([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_beforezero_double_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_double_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_beforezero_double_sortd([10]) == [20]\nassert op_beforezero_double_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_beforezero_double_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_lower_sortlen_joinc", "entry_point": "op_lower_sortlen_joinc", "primitives": ["lower", "sortlen", "joinc"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort by length, shortest first, then join them with commas.", "solution": "def op_lower_sortlen_joinc(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    return ','.join(r)", "tests": "assert op_lower_sortlen_joinc(['Hello', 'world']) == 'hello,world'\nassert op_lower_sortlen_joinc([]) == ''\nassert op_lower_sortlen_joinc(['  a ', '', 'BC', 'bc']) == ',bc,bc,  a '\nassert op_lower_sortlen_joinc(['one', 'one', 'Two']) == 'one,one,two'\nassert op_lower_sortlen_joinc(['x']) == 'x'\nassert op_lower_sortlen_joinc(['abc', 'de', '']) == ',de,abc'"}
{"id": "op_gt5_takewhilepos_trimends", "entry_point": "op_gt5_takewhilepos_trimends", "primitives": ["gt5", "takewhilepos", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then drop the first and last elements.", "solution": "def op_gt5_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_gt5_takewhilepos_trimends([1, 2, 3, 4]) == []\nassert op_gt5_takewhilepos_trimends([]) == []\nassert op_gt5_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_gt5_takewhilepos_trimends([5, 5, 5]) == []\nassert op_gt5_takewhilepos_trimends([3, 1, 2]) == []\nassert op_gt5_takewhilepos_trimends([10]) == []\nassert op_gt5_takewhilepos_trimends([2, 4, 6]) == []\nassert op_gt5_takewhilepos_trimends([-7, 12, -7]) == []"}
{"id": "op_firstchar_sortlen_dropshort", "entry_point": "op_firstchar_sortlen_dropshort", "primitives": ["firstchar", "sortlen", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort by length, shortest first, then drop strings shorter than three characters.", "solution": "def op_firstchar_sortlen_dropshort(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_firstchar_sortlen_dropshort(['Hello', 'world']) == []\nassert op_firstchar_sortlen_dropshort([]) == []\nassert op_firstchar_sortlen_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_firstchar_sortlen_dropshort(['one', 'one', 'Two']) == []\nassert op_firstchar_sortlen_dropshort(['x']) == []\nassert op_firstchar_sortlen_dropshort(['abc', 'de', '']) == []"}
{"id": "op_add10_dec_dropwhileneg", "entry_point": "op_add10_dec_dropwhileneg", "primitives": ["add10", "dec", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then drop the leading negative values.", "solution": "def op_add10_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_dec_dropwhileneg([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_dec_dropwhileneg([]) == []\nassert op_add10_dec_dropwhileneg([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_dec_dropwhileneg([5, 5, 5]) == [14, 14, 14]\nassert op_add10_dec_dropwhileneg([3, 1, 2]) == [12, 10, 11]\nassert op_add10_dec_dropwhileneg([10]) == [19]\nassert op_add10_dec_dropwhileneg([2, 4, 6]) == [11, 13, 15]\nassert op_add10_dec_dropwhileneg([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_dropzeros_rev_len", "entry_point": "op_dropzeros_rev_len", "primitives": ["dropzeros", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then return how many remain.", "solution": "def op_dropzeros_rev_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_dropzeros_rev_len([1, 2, 3, 4]) == 4\nassert op_dropzeros_rev_len([]) == 0\nassert op_dropzeros_rev_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_rev_len([5, 5, 5]) == 3\nassert op_dropzeros_rev_len([3, 1, 2]) == 3\nassert op_dropzeros_rev_len([10]) == 1\nassert op_dropzeros_rev_len([2, 4, 6]) == 3\nassert op_dropzeros_rev_len([-7, 12, -7]) == 3"}
{"id": "op_dropfirst_dropwhileneg_square", "entry_point": "op_dropfirst_dropwhileneg_square", "primitives": ["dropfirst", "dropwhileneg", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then square each.", "solution": "def op_dropfirst_dropwhileneg_square(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropfirst_dropwhileneg_square([]) == []\nassert op_dropfirst_dropwhileneg_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropfirst_dropwhileneg_square([5, 5, 5]) == [25, 25]\nassert op_dropfirst_dropwhileneg_square([3, 1, 2]) == [1, 4]\nassert op_dropfirst_dropwhileneg_square([10]) == []\nassert op_dropfirst_dropwhileneg_square([2, 4, 6]) == [16, 36]\nassert op_dropfirst_dropwhileneg_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_gt5_uniq_last3", "entry_point": "op_gt5_uniq_last3", "primitives": ["gt5", "uniq", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop duplicates keeping first occurrence, then keep only the last three.", "solution": "def op_gt5_uniq_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r", "tests": "assert op_gt5_uniq_last3([1, 2, 3, 4]) == []\nassert op_gt5_uniq_last3([]) == []\nassert op_gt5_uniq_last3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_uniq_last3([5, 5, 5]) == []\nassert op_gt5_uniq_last3([3, 1, 2]) == []\nassert op_gt5_uniq_last3([10]) == [10]\nassert op_gt5_uniq_last3([2, 4, 6]) == [6]\nassert op_gt5_uniq_last3([-7, 12, -7]) == [12]"}
{"id": "op_absval_first3_neg", "entry_point": "op_absval_first3_neg", "primitives": ["absval", "first3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then keep the negative numbers.", "solution": "def op_absval_first3_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_first3_neg([1, 2, 3, 4]) == []\nassert op_absval_first3_neg([]) == []\nassert op_absval_first3_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_first3_neg([5, 5, 5]) == []\nassert op_absval_first3_neg([3, 1, 2]) == []\nassert op_absval_first3_neg([10]) == []\nassert op_absval_first3_neg([2, 4, 6]) == []\nassert op_absval_first3_neg([-7, 12, -7]) == []"}
{"id": "op_sorta_oremptyzero_issorted", "entry_point": "op_sorta_oremptyzero_issorted", "primitives": ["sorta", "oremptyzero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then return whether the list is sorted ascending.", "solution": "def op_sorta_oremptyzero_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    return r == sorted(r)", "tests": "assert op_sorta_oremptyzero_issorted([1, 2, 3, 4]) == True\nassert op_sorta_oremptyzero_issorted([]) == True\nassert op_sorta_oremptyzero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_oremptyzero_issorted([5, 5, 5]) == True\nassert op_sorta_oremptyzero_issorted([3, 1, 2]) == True\nassert op_sorta_oremptyzero_issorted([10]) == True\nassert op_sorta_oremptyzero_issorted([2, 4, 6]) == True\nassert op_sorta_oremptyzero_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_dropfirst_negate", "entry_point": "op_padto3_dropfirst_negate", "primitives": ["padto3", "dropfirst", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element, then negate each.", "solution": "def op_padto3_dropfirst_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_dropfirst_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_padto3_dropfirst_negate([]) == [0, 0]\nassert op_padto3_dropfirst_negate([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_padto3_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_padto3_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_padto3_dropfirst_negate([10]) == [0, 0]\nassert op_padto3_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_padto3_dropfirst_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_sortabs_absval_dec", "entry_point": "op_sortabs_absval_dec", "primitives": ["sortabs", "absval", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then subtract one from each.", "solution": "def op_sortabs_absval_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_absval_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortabs_absval_dec([]) == []\nassert op_sortabs_absval_dec([-2, -1, 0, 1, 2]) == [-1, 0, 0, 1, 1]\nassert op_sortabs_absval_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_absval_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sortabs_absval_dec([10]) == [9]\nassert op_sortabs_absval_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sortabs_absval_dec([-7, 12, -7]) == [6, 6, 11]"}
{"id": "op_double_rev_len", "entry_point": "op_double_rev_len", "primitives": ["double", "rev", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then return how many remain.", "solution": "def op_double_rev_len(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_double_rev_len([1, 2, 3, 4]) == 4\nassert op_double_rev_len([]) == 0\nassert op_double_rev_len([-2, -1, 0, 1, 2]) == 5\nassert op_double_rev_len([5, 5, 5]) == 3\nassert op_double_rev_len([3, 1, 2]) == 3\nassert op_double_rev_len([10]) == 1\nassert op_double_rev_len([2, 4, 6]) == 3\nassert op_double_rev_len([-7, 12, -7]) == 3"}
{"id": "op_uniq_sorta_trimends", "entry_point": "op_uniq_sorta_trimends", "primitives": ["uniq", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then drop the first and last elements.", "solution": "def op_uniq_sorta_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_sorta_trimends([]) == []\nassert op_uniq_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_uniq_sorta_trimends([5, 5, 5]) == []\nassert op_uniq_sorta_trimends([3, 1, 2]) == [2]\nassert op_uniq_sorta_trimends([10]) == []\nassert op_uniq_sorta_trimends([2, 4, 6]) == [4]\nassert op_uniq_sorta_trimends([-7, 12, -7]) == []"}
{"id": "op_negate_clamp10_oremptyzero", "entry_point": "op_negate_clamp10_oremptyzero", "primitives": ["negate", "clamp10", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_negate_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_clamp10_oremptyzero([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_clamp10_oremptyzero([]) == [0]\nassert op_negate_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_clamp10_oremptyzero([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_clamp10_oremptyzero([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_clamp10_oremptyzero([10]) == [-10]\nassert op_negate_clamp10_oremptyzero([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_clamp10_oremptyzero([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_last3_odds_oremptyzero", "entry_point": "op_last3_odds_oremptyzero", "primitives": ["last3", "odds", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then if empty, use a single zero.", "solution": "def op_last3_odds_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_odds_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_last3_odds_oremptyzero([]) == [0]\nassert op_last3_odds_oremptyzero([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_odds_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_odds_oremptyzero([3, 1, 2]) == [3, 1]\nassert op_last3_odds_oremptyzero([10]) == [0]\nassert op_last3_odds_oremptyzero([2, 4, 6]) == [0]\nassert op_last3_odds_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_evens_dec", "entry_point": "op_dropwhileneg_evens_dec", "primitives": ["dropwhileneg", "evens", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the even numbers, then subtract one from each.", "solution": "def op_dropwhileneg_evens_dec(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_evens_dec([1, 2, 3, 4]) == [1, 3]\nassert op_dropwhileneg_evens_dec([]) == []\nassert op_dropwhileneg_evens_dec([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropwhileneg_evens_dec([5, 5, 5]) == []\nassert op_dropwhileneg_evens_dec([3, 1, 2]) == [1]\nassert op_dropwhileneg_evens_dec([10]) == [9]\nassert op_dropwhileneg_evens_dec([2, 4, 6]) == [1, 3, 5]\nassert op_dropwhileneg_evens_dec([-7, 12, -7]) == [11]"}
{"id": "op_absval_evens_double", "entry_point": "op_absval_evens_double", "primitives": ["absval", "evens", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then double each.", "solution": "def op_absval_evens_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_evens_double([1, 2, 3, 4]) == [4, 8]\nassert op_absval_evens_double([]) == []\nassert op_absval_evens_double([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_absval_evens_double([5, 5, 5]) == []\nassert op_absval_evens_double([3, 1, 2]) == [4]\nassert op_absval_evens_double([10]) == [20]\nassert op_absval_evens_double([2, 4, 6]) == [4, 8, 12]\nassert op_absval_evens_double([-7, 12, -7]) == [24]"}
{"id": "op_sortabs_neg_add10", "entry_point": "op_sortabs_neg_add10", "primitives": ["sortabs", "neg", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then add ten to each.", "solution": "def op_sortabs_neg_add10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortabs_neg_add10([1, 2, 3, 4]) == []\nassert op_sortabs_neg_add10([]) == []\nassert op_sortabs_neg_add10([-2, -1, 0, 1, 2]) == [9, 8]\nassert op_sortabs_neg_add10([5, 5, 5]) == []\nassert op_sortabs_neg_add10([3, 1, 2]) == []\nassert op_sortabs_neg_add10([10]) == []\nassert op_sortabs_neg_add10([2, 4, 6]) == []\nassert op_sortabs_neg_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_add10_sortabs_negate", "entry_point": "op_add10_sortabs_negate", "primitives": ["add10", "sortabs", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then negate each.", "solution": "def op_add10_sortabs_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_sortabs_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_add10_sortabs_negate([]) == []\nassert op_add10_sortabs_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_add10_sortabs_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_sortabs_negate([3, 1, 2]) == [-11, -12, -13]\nassert op_add10_sortabs_negate([10]) == [-20]\nassert op_add10_sortabs_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_sortabs_negate([-7, 12, -7]) == [-3, -3, -22]"}
{"id": "op_padto3_clamp10_dropwhileneg", "entry_point": "op_padto3_clamp10_dropwhileneg", "primitives": ["padto3", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cap each value at 10, then drop the leading negative values.", "solution": "def op_padto3_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_clamp10_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_clamp10_dropwhileneg([]) == [0, 0, 0]\nassert op_padto3_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_clamp10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_clamp10_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_clamp10_dropwhileneg([10]) == [10, 0, 0]\nassert op_padto3_clamp10_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_clamp10_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_uniq_trimends_neg", "entry_point": "op_uniq_trimends_neg", "primitives": ["uniq", "trimends", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_uniq_trimends_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_trimends_neg([1, 2, 3, 4]) == []\nassert op_uniq_trimends_neg([]) == []\nassert op_uniq_trimends_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_uniq_trimends_neg([5, 5, 5]) == []\nassert op_uniq_trimends_neg([3, 1, 2]) == []\nassert op_uniq_trimends_neg([10]) == []\nassert op_uniq_trimends_neg([2, 4, 6]) == []\nassert op_uniq_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_neg_first3_trimends", "entry_point": "op_neg_first3_trimends", "primitives": ["neg", "first3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three, then drop the first and last elements.", "solution": "def op_neg_first3_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_neg_first3_trimends([1, 2, 3, 4]) == []\nassert op_neg_first3_trimends([]) == []\nassert op_neg_first3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_neg_first3_trimends([5, 5, 5]) == []\nassert op_neg_first3_trimends([3, 1, 2]) == []\nassert op_neg_first3_trimends([10]) == []\nassert op_neg_first3_trimends([2, 4, 6]) == []\nassert op_neg_first3_trimends([-7, 12, -7]) == []"}
{"id": "op_rev_add10_anyeven", "entry_point": "op_rev_add10_anyeven", "primitives": ["rev", "add10", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then return whether any value is even.", "solution": "def op_rev_add10_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_add10_anyeven([1, 2, 3, 4]) == True\nassert op_rev_add10_anyeven([]) == False\nassert op_rev_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_add10_anyeven([5, 5, 5]) == False\nassert op_rev_add10_anyeven([3, 1, 2]) == True\nassert op_rev_add10_anyeven([10]) == True\nassert op_rev_add10_anyeven([2, 4, 6]) == True\nassert op_rev_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_first3_sorta_oremptyzero", "entry_point": "op_first3_sorta_oremptyzero", "primitives": ["first3", "sorta", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then if empty, use a single zero.", "solution": "def op_first3_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta_oremptyzero([]) == [0]\nassert op_first3_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta_oremptyzero([10]) == [10]\nassert op_first3_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_rev_takewhilepos", "entry_point": "op_beforezero_rev_takewhilepos", "primitives": ["beforezero", "rev", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then take values while they are positive.", "solution": "def op_beforezero_rev_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_rev_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_rev_takewhilepos([]) == []\nassert op_beforezero_rev_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_rev_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_rev_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_beforezero_rev_takewhilepos([10]) == [10]\nassert op_beforezero_rev_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_rev_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_gt5_dropfirst_sum", "entry_point": "op_gt5_dropfirst_sum", "primitives": ["gt5", "dropfirst", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then return their sum.", "solution": "def op_gt5_dropfirst_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return sum(r)", "tests": "assert op_gt5_dropfirst_sum([1, 2, 3, 4]) == 0\nassert op_gt5_dropfirst_sum([]) == 0\nassert op_gt5_dropfirst_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_dropfirst_sum([5, 5, 5]) == 0\nassert op_gt5_dropfirst_sum([3, 1, 2]) == 0\nassert op_gt5_dropfirst_sum([10]) == 0\nassert op_gt5_dropfirst_sum([2, 4, 6]) == 0\nassert op_gt5_dropfirst_sum([-7, 12, -7]) == 0"}
{"id": "op_trimends_rev_takewhilepos", "entry_point": "op_trimends_rev_takewhilepos", "primitives": ["trimends", "rev", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then take values while they are positive.", "solution": "def op_trimends_rev_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_trimends_rev_takewhilepos([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_rev_takewhilepos([]) == []\nassert op_trimends_rev_takewhilepos([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_rev_takewhilepos([5, 5, 5]) == [5]\nassert op_trimends_rev_takewhilepos([3, 1, 2]) == [1]\nassert op_trimends_rev_takewhilepos([10]) == []\nassert op_trimends_rev_takewhilepos([2, 4, 6]) == [4]\nassert op_trimends_rev_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_double_trimends", "entry_point": "op_beforezero_double_trimends", "primitives": ["beforezero", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then drop the first and last elements.", "solution": "def op_beforezero_double_trimends(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_beforezero_double_trimends([1, 2, 3, 4]) == [4, 6]\nassert op_beforezero_double_trimends([]) == []\nassert op_beforezero_double_trimends([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_double_trimends([5, 5, 5]) == [10]\nassert op_beforezero_double_trimends([3, 1, 2]) == [2]\nassert op_beforezero_double_trimends([10]) == []\nassert op_beforezero_double_trimends([2, 4, 6]) == [8]\nassert op_beforezero_double_trimends([-7, 12, -7]) == [24]"}
{"id": "op_absval_sorta_len", "entry_point": "op_absval_sorta_len", "primitives": ["absval", "sorta", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then return how many remain.", "solution": "def op_absval_sorta_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return len(r)", "tests": "assert op_absval_sorta_len([1, 2, 3, 4]) == 4\nassert op_absval_sorta_len([]) == 0\nassert op_absval_sorta_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_sorta_len([5, 5, 5]) == 3\nassert op_absval_sorta_len([3, 1, 2]) == 3\nassert op_absval_sorta_len([10]) == 1\nassert op_absval_sorta_len([2, 4, 6]) == 3\nassert op_absval_sorta_len([-7, 12, -7]) == 3"}
{"id": "op_sortd_dropfirst_evens", "entry_point": "op_sortd_dropfirst_evens", "primitives": ["sortd", "dropfirst", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then keep the even numbers.", "solution": "def op_sortd_dropfirst_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_dropfirst_evens([1, 2, 3, 4]) == [2]\nassert op_sortd_dropfirst_evens([]) == []\nassert op_sortd_dropfirst_evens([-2, -1, 0, 1, 2]) == [0, -2]\nassert op_sortd_dropfirst_evens([5, 5, 5]) == []\nassert op_sortd_dropfirst_evens([3, 1, 2]) == [2]\nassert op_sortd_dropfirst_evens([10]) == []\nassert op_sortd_dropfirst_evens([2, 4, 6]) == [4, 2]\nassert op_sortd_dropfirst_evens([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_padto3_add10", "entry_point": "op_dropwhileneg_padto3_add10", "primitives": ["dropwhileneg", "padto3", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements, then add ten to each.", "solution": "def op_dropwhileneg_padto3_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_padto3_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_padto3_add10([]) == [10, 10, 10]\nassert op_dropwhileneg_padto3_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_padto3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_padto3_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_padto3_add10([10]) == [20, 10, 10]\nassert op_dropwhileneg_padto3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_padto3_add10([-7, 12, -7]) == [22, 3, 10]"}
{"id": "op_sortabs_neg_beforezero", "entry_point": "op_sortabs_neg_beforezero", "primitives": ["sortabs", "neg", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then keep everything before the first zero.", "solution": "def op_sortabs_neg_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortabs_neg_beforezero([1, 2, 3, 4]) == []\nassert op_sortabs_neg_beforezero([]) == []\nassert op_sortabs_neg_beforezero([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortabs_neg_beforezero([5, 5, 5]) == []\nassert op_sortabs_neg_beforezero([3, 1, 2]) == []\nassert op_sortabs_neg_beforezero([10]) == []\nassert op_sortabs_neg_beforezero([2, 4, 6]) == []\nassert op_sortabs_neg_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_sorta_negate", "entry_point": "op_last3_sorta_negate", "primitives": ["last3", "sorta", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then negate each.", "solution": "def op_last3_sorta_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_sorta_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_last3_sorta_negate([]) == []\nassert op_last3_sorta_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_last3_sorta_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_sorta_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_last3_sorta_negate([10]) == [-10]\nassert op_last3_sorta_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_last3_sorta_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_add10_dropzeros_prod", "entry_point": "op_add10_dropzeros_prod", "primitives": ["add10", "dropzeros", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then return their product.", "solution": "def op_add10_dropzeros_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_add10_dropzeros_prod([1, 2, 3, 4]) == 24024\nassert op_add10_dropzeros_prod([]) == 1\nassert op_add10_dropzeros_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_dropzeros_prod([5, 5, 5]) == 3375\nassert op_add10_dropzeros_prod([3, 1, 2]) == 1716\nassert op_add10_dropzeros_prod([10]) == 20\nassert op_add10_dropzeros_prod([2, 4, 6]) == 2688\nassert op_add10_dropzeros_prod([-7, 12, -7]) == 198"}
{"id": "op_square_clamp10_inc", "entry_point": "op_square_clamp10_inc", "primitives": ["square", "clamp10", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then add one to each.", "solution": "def op_square_clamp10_inc(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_square_clamp10_inc([1, 2, 3, 4]) == [2, 5, 10, 11]\nassert op_square_clamp10_inc([]) == []\nassert op_square_clamp10_inc([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_square_clamp10_inc([5, 5, 5]) == [11, 11, 11]\nassert op_square_clamp10_inc([3, 1, 2]) == [10, 2, 5]\nassert op_square_clamp10_inc([10]) == [11]\nassert op_square_clamp10_inc([2, 4, 6]) == [5, 11, 11]\nassert op_square_clamp10_inc([-7, 12, -7]) == [11, 11, 11]"}
{"id": "op_double_absval_add10", "entry_point": "op_double_absval_add10", "primitives": ["double", "absval", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then add ten to each.", "solution": "def op_double_absval_add10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_double_absval_add10([1, 2, 3, 4]) == [12, 14, 16, 18]\nassert op_double_absval_add10([]) == []\nassert op_double_absval_add10([-2, -1, 0, 1, 2]) == [14, 12, 10, 12, 14]\nassert op_double_absval_add10([5, 5, 5]) == [20, 20, 20]\nassert op_double_absval_add10([3, 1, 2]) == [16, 12, 14]\nassert op_double_absval_add10([10]) == [30]\nassert op_double_absval_add10([2, 4, 6]) == [14, 18, 22]\nassert op_double_absval_add10([-7, 12, -7]) == [24, 34, 24]"}
{"id": "op_dropfirst_clamp10_allpos", "entry_point": "op_dropfirst_clamp10_allpos", "primitives": ["dropfirst", "clamp10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then return whether all values are positive.", "solution": "def op_dropfirst_clamp10_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_clamp10_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_clamp10_allpos([]) == True\nassert op_dropfirst_clamp10_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_clamp10_allpos([5, 5, 5]) == True\nassert op_dropfirst_clamp10_allpos([3, 1, 2]) == True\nassert op_dropfirst_clamp10_allpos([10]) == True\nassert op_dropfirst_clamp10_allpos([2, 4, 6]) == True\nassert op_dropfirst_clamp10_allpos([-7, 12, -7]) == False"}
{"id": "op_dropzeros_first3_double", "entry_point": "op_dropzeros_first3_double", "primitives": ["dropzeros", "first3", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then double each.", "solution": "def op_dropzeros_first3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_first3_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_dropzeros_first3_double([]) == []\nassert op_dropzeros_first3_double([-2, -1, 0, 1, 2]) == [-4, -2, 2]\nassert op_dropzeros_first3_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_first3_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_first3_double([10]) == [20]\nassert op_dropzeros_first3_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_first3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_absval_gt5_len", "entry_point": "op_absval_gt5_len", "primitives": ["absval", "gt5", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then return how many remain.", "solution": "def op_absval_gt5_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_absval_gt5_len([1, 2, 3, 4]) == 0\nassert op_absval_gt5_len([]) == 0\nassert op_absval_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_absval_gt5_len([5, 5, 5]) == 0\nassert op_absval_gt5_len([3, 1, 2]) == 0\nassert op_absval_gt5_len([10]) == 1\nassert op_absval_gt5_len([2, 4, 6]) == 1\nassert op_absval_gt5_len([-7, 12, -7]) == 3"}
{"id": "op_evens_inc_first3", "entry_point": "op_evens_inc_first3", "primitives": ["evens", "inc", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then keep only the first three.", "solution": "def op_evens_inc_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_evens_inc_first3([1, 2, 3, 4]) == [3, 5]\nassert op_evens_inc_first3([]) == []\nassert op_evens_inc_first3([-2, -1, 0, 1, 2]) == [-1, 1, 3]\nassert op_evens_inc_first3([5, 5, 5]) == []\nassert op_evens_inc_first3([3, 1, 2]) == [3]\nassert op_evens_inc_first3([10]) == [11]\nassert op_evens_inc_first3([2, 4, 6]) == [3, 5, 7]\nassert op_evens_inc_first3([-7, 12, -7]) == [13]"}
{"id": "op_rev_double_oremptyzero", "entry_point": "op_rev_double_oremptyzero", "primitives": ["rev", "double", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then if empty, use a single zero.", "solution": "def op_rev_double_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_double_oremptyzero([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_oremptyzero([]) == [0]\nassert op_rev_double_oremptyzero([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_double_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_oremptyzero([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_oremptyzero([10]) == [20]\nassert op_rev_double_oremptyzero([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_oremptyzero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_ages_sortd_allpos", "entry_point": "op_ages_sortd_allpos", "primitives": ["ages", "sortd", "allpos"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then return whether all values are positive.", "solution": "def op_ages_sortd_allpos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_ages_sortd_allpos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_sortd_allpos([]) == True\nassert op_ages_sortd_allpos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_sortd_allpos([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_rev_trimends_anyeven", "entry_point": "op_rev_trimends_anyeven", "primitives": ["rev", "trimends", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then return whether any value is even.", "solution": "def op_rev_trimends_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_trimends_anyeven([1, 2, 3, 4]) == True\nassert op_rev_trimends_anyeven([]) == False\nassert op_rev_trimends_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_trimends_anyeven([5, 5, 5]) == False\nassert op_rev_trimends_anyeven([3, 1, 2]) == False\nassert op_rev_trimends_anyeven([10]) == False\nassert op_rev_trimends_anyeven([2, 4, 6]) == True\nassert op_rev_trimends_anyeven([-7, 12, -7]) == True"}
{"id": "op_square_sortabs_rev", "entry_point": "op_square_sortabs_rev", "primitives": ["square", "sortabs", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then reverse the order.", "solution": "def op_square_sortabs_rev(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_square_sortabs_rev([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_sortabs_rev([]) == []\nassert op_square_sortabs_rev([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_square_sortabs_rev([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortabs_rev([3, 1, 2]) == [9, 4, 1]\nassert op_square_sortabs_rev([10]) == [100]\nassert op_square_sortabs_rev([2, 4, 6]) == [36, 16, 4]\nassert op_square_sortabs_rev([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_dropwhileneg_clamp10_max", "entry_point": "op_dropwhileneg_clamp10_max", "primitives": ["dropwhileneg", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_clamp10_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_clamp10_max([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_clamp10_max([]) == 0\nassert op_dropwhileneg_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_clamp10_max([5, 5, 5]) == 5\nassert op_dropwhileneg_clamp10_max([3, 1, 2]) == 3\nassert op_dropwhileneg_clamp10_max([10]) == 10\nassert op_dropwhileneg_clamp10_max([2, 4, 6]) == 6\nassert op_dropwhileneg_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_double_oremptyzero_prod", "entry_point": "op_double_oremptyzero_prod", "primitives": ["double", "oremptyzero", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then return their product.", "solution": "def op_double_oremptyzero_prod(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_double_oremptyzero_prod([1, 2, 3, 4]) == 384\nassert op_double_oremptyzero_prod([]) == 0\nassert op_double_oremptyzero_prod([-2, -1, 0, 1, 2]) == 0\nassert op_double_oremptyzero_prod([5, 5, 5]) == 1000\nassert op_double_oremptyzero_prod([3, 1, 2]) == 48\nassert op_double_oremptyzero_prod([10]) == 20\nassert op_double_oremptyzero_prod([2, 4, 6]) == 384\nassert op_double_oremptyzero_prod([-7, 12, -7]) == 4704"}
{"id": "op_ages_dropwhileneg_min", "entry_point": "op_ages_dropwhileneg_min", "primitives": ["ages", "dropwhileneg", "min"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then return the minimum (0 if empty).", "solution": "def op_ages_dropwhileneg_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return min(r) if r else 0", "tests": "assert op_ages_dropwhileneg_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_dropwhileneg_min([]) == 0\nassert op_ages_dropwhileneg_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_dropwhileneg_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_clamp10_sortabs_pos", "entry_point": "op_clamp10_sortabs_pos", "primitives": ["clamp10", "sortabs", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then keep the positive numbers.", "solution": "def op_clamp10_sortabs_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_sortabs_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sortabs_pos([]) == []\nassert op_clamp10_sortabs_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_sortabs_pos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortabs_pos([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sortabs_pos([10]) == [10]\nassert op_clamp10_sortabs_pos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sortabs_pos([-7, 12, -7]) == [10]"}
{"id": "op_double_dropwhileneg_uniq", "entry_point": "op_double_dropwhileneg_uniq", "primitives": ["double", "dropwhileneg", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_double_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_dropwhileneg_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropwhileneg_uniq([]) == []\nassert op_double_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_dropwhileneg_uniq([5, 5, 5]) == [10]\nassert op_double_dropwhileneg_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_double_dropwhileneg_uniq([10]) == [20]\nassert op_double_dropwhileneg_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropwhileneg_uniq([-7, 12, -7]) == [24, -14]"}
{"id": "op_dropfirst_neg_clamp10", "entry_point": "op_dropfirst_neg_clamp10", "primitives": ["dropfirst", "neg", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then cap each value at 10.", "solution": "def op_dropfirst_neg_clamp10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropfirst_neg_clamp10([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_clamp10([]) == []\nassert op_dropfirst_neg_clamp10([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg_clamp10([5, 5, 5]) == []\nassert op_dropfirst_neg_clamp10([3, 1, 2]) == []\nassert op_dropfirst_neg_clamp10([10]) == []\nassert op_dropfirst_neg_clamp10([2, 4, 6]) == []\nassert op_dropfirst_neg_clamp10([-7, 12, -7]) == [-7]"}
{"id": "op_add10_beforezero_dropwhileneg", "entry_point": "op_add10_beforezero_dropwhileneg", "primitives": ["add10", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_add10_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_beforezero_dropwhileneg([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_beforezero_dropwhileneg([]) == []\nassert op_add10_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_beforezero_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_beforezero_dropwhileneg([3, 1, 2]) == [13, 11, 12]\nassert op_add10_beforezero_dropwhileneg([10]) == [20]\nassert op_add10_beforezero_dropwhileneg([2, 4, 6]) == [12, 14, 16]\nassert op_add10_beforezero_dropwhileneg([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_rev_square_counteven", "entry_point": "op_rev_square_counteven", "primitives": ["rev", "square", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then return how many values are even.", "solution": "def op_rev_square_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_square_counteven([1, 2, 3, 4]) == 2\nassert op_rev_square_counteven([]) == 0\nassert op_rev_square_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_rev_square_counteven([5, 5, 5]) == 0\nassert op_rev_square_counteven([3, 1, 2]) == 1\nassert op_rev_square_counteven([10]) == 1\nassert op_rev_square_counteven([2, 4, 6]) == 3\nassert op_rev_square_counteven([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_last3_prod", "entry_point": "op_oremptyzero_last3_prod", "primitives": ["oremptyzero", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then return their product.", "solution": "def op_oremptyzero_last3_prod(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_oremptyzero_last3_prod([1, 2, 3, 4]) == 24\nassert op_oremptyzero_last3_prod([]) == 0\nassert op_oremptyzero_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_last3_prod([5, 5, 5]) == 125\nassert op_oremptyzero_last3_prod([3, 1, 2]) == 6\nassert op_oremptyzero_last3_prod([10]) == 10\nassert op_oremptyzero_last3_prod([2, 4, 6]) == 48\nassert op_oremptyzero_last3_prod([-7, 12, -7]) == 588"}
{"id": "op_oremptyzero_evens_len", "entry_point": "op_oremptyzero_evens_len", "primitives": ["oremptyzero", "evens", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then return how many remain.", "solution": "def op_oremptyzero_evens_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_oremptyzero_evens_len([1, 2, 3, 4]) == 2\nassert op_oremptyzero_evens_len([]) == 1\nassert op_oremptyzero_evens_len([-2, -1, 0, 1, 2]) == 3\nassert op_oremptyzero_evens_len([5, 5, 5]) == 0\nassert op_oremptyzero_evens_len([3, 1, 2]) == 1\nassert op_oremptyzero_evens_len([10]) == 1\nassert op_oremptyzero_evens_len([2, 4, 6]) == 3\nassert op_oremptyzero_evens_len([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_negate_double", "entry_point": "op_dropzeros_negate_double", "primitives": ["dropzeros", "negate", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then double each.", "solution": "def op_dropzeros_negate_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_negate_double([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_dropzeros_negate_double([]) == []\nassert op_dropzeros_negate_double([-2, -1, 0, 1, 2]) == [4, 2, -2, -4]\nassert op_dropzeros_negate_double([5, 5, 5]) == [-10, -10, -10]\nassert op_dropzeros_negate_double([3, 1, 2]) == [-6, -2, -4]\nassert op_dropzeros_negate_double([10]) == [-20]\nassert op_dropzeros_negate_double([2, 4, 6]) == [-4, -8, -12]\nassert op_dropzeros_negate_double([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_neg_takewhilepos_absval", "entry_point": "op_neg_takewhilepos_absval", "primitives": ["neg", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then take the absolute value of each.", "solution": "def op_neg_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_neg_takewhilepos_absval([1, 2, 3, 4]) == []\nassert op_neg_takewhilepos_absval([]) == []\nassert op_neg_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_neg_takewhilepos_absval([5, 5, 5]) == []\nassert op_neg_takewhilepos_absval([3, 1, 2]) == []\nassert op_neg_takewhilepos_absval([10]) == []\nassert op_neg_takewhilepos_absval([2, 4, 6]) == []\nassert op_neg_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_last3_trimends_dropwhileneg", "entry_point": "op_last3_trimends_dropwhileneg", "primitives": ["last3", "trimends", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_last3_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_trimends_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_last3_trimends_dropwhileneg([]) == []\nassert op_last3_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_trimends_dropwhileneg([5, 5, 5]) == [5]\nassert op_last3_trimends_dropwhileneg([3, 1, 2]) == [1]\nassert op_last3_trimends_dropwhileneg([10]) == []\nassert op_last3_trimends_dropwhileneg([2, 4, 6]) == [4]\nassert op_last3_trimends_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_double_evens_prod", "entry_point": "op_double_evens_prod", "primitives": ["double", "evens", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then return their product.", "solution": "def op_double_evens_prod(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_double_evens_prod([1, 2, 3, 4]) == 384\nassert op_double_evens_prod([]) == 1\nassert op_double_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_double_evens_prod([5, 5, 5]) == 1000\nassert op_double_evens_prod([3, 1, 2]) == 48\nassert op_double_evens_prod([10]) == 20\nassert op_double_evens_prod([2, 4, 6]) == 384\nassert op_double_evens_prod([-7, 12, -7]) == 4704"}
{"id": "op_nonempty_strip_anyempty", "entry_point": "op_nonempty_strip_anyempty", "primitives": ["nonempty", "strip", "anyempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then trim whitespace from each, then return whether any string is empty.", "solution": "def op_nonempty_strip_anyempty(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.strip() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_nonempty_strip_anyempty(['Hello', 'world']) == False\nassert op_nonempty_strip_anyempty([]) == False\nassert op_nonempty_strip_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_nonempty_strip_anyempty(['one', 'one', 'Two']) == False\nassert op_nonempty_strip_anyempty(['x']) == False\nassert op_nonempty_strip_anyempty(['abc', 'de', '']) == False"}
{"id": "op_beforezero_add10_trimends", "entry_point": "op_beforezero_add10_trimends", "primitives": ["beforezero", "add10", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add ten to each, then drop the first and last elements.", "solution": "def op_beforezero_add10_trimends(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_beforezero_add10_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_beforezero_add10_trimends([]) == []\nassert op_beforezero_add10_trimends([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_add10_trimends([5, 5, 5]) == [15]\nassert op_beforezero_add10_trimends([3, 1, 2]) == [11]\nassert op_beforezero_add10_trimends([10]) == []\nassert op_beforezero_add10_trimends([2, 4, 6]) == [14]\nassert op_beforezero_add10_trimends([-7, 12, -7]) == [22]"}
{"id": "op_dropwhileneg_pos_haszero", "entry_point": "op_dropwhileneg_pos_haszero", "primitives": ["dropwhileneg", "pos", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_pos_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_dropwhileneg_pos_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_pos_haszero([]) == False\nassert op_dropwhileneg_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_pos_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_pos_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_pos_haszero([10]) == False\nassert op_dropwhileneg_pos_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_absval_rev_dropwhileneg", "entry_point": "op_absval_rev_dropwhileneg", "primitives": ["absval", "rev", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then drop the leading negative values.", "solution": "def op_absval_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_rev_dropwhileneg([]) == []\nassert op_absval_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_rev_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_absval_rev_dropwhileneg([10]) == [10]\nassert op_absval_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_absval_rev_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sorta_last3_sum", "entry_point": "op_sorta_last3_sum", "primitives": ["sorta", "last3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the last three, then return their sum.", "solution": "def op_sorta_last3_sum(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_sorta_last3_sum([1, 2, 3, 4]) == 9\nassert op_sorta_last3_sum([]) == 0\nassert op_sorta_last3_sum([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_last3_sum([5, 5, 5]) == 15\nassert op_sorta_last3_sum([3, 1, 2]) == 6\nassert op_sorta_last3_sum([10]) == 10\nassert op_sorta_last3_sum([2, 4, 6]) == 12\nassert op_sorta_last3_sum([-7, 12, -7]) == -2"}
{"id": "op_first3_trimends_absval", "entry_point": "op_first3_trimends_absval", "primitives": ["first3", "trimends", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_first3_trimends_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_trimends_absval([1, 2, 3, 4]) == [2]\nassert op_first3_trimends_absval([]) == []\nassert op_first3_trimends_absval([-2, -1, 0, 1, 2]) == [1]\nassert op_first3_trimends_absval([5, 5, 5]) == [5]\nassert op_first3_trimends_absval([3, 1, 2]) == [1]\nassert op_first3_trimends_absval([10]) == []\nassert op_first3_trimends_absval([2, 4, 6]) == [4]\nassert op_first3_trimends_absval([-7, 12, -7]) == [12]"}
{"id": "op_odds_pos_anyeven", "entry_point": "op_odds_pos_anyeven", "primitives": ["odds", "pos", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then return whether any value is even.", "solution": "def op_odds_pos_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_odds_pos_anyeven([1, 2, 3, 4]) == False\nassert op_odds_pos_anyeven([]) == False\nassert op_odds_pos_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_odds_pos_anyeven([5, 5, 5]) == False\nassert op_odds_pos_anyeven([3, 1, 2]) == False\nassert op_odds_pos_anyeven([10]) == False\nassert op_odds_pos_anyeven([2, 4, 6]) == False\nassert op_odds_pos_anyeven([-7, 12, -7]) == False"}
{"id": "op_div3_sortd_firsteven", "entry_point": "op_div3_sortd_firsteven", "primitives": ["div3", "sortd", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending, then return the first even value (0 if none).", "solution": "def op_div3_sortd_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_sortd_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_sortd_firsteven([]) == 0\nassert op_div3_sortd_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_sortd_firsteven([5, 5, 5]) == 0\nassert op_div3_sortd_firsteven([3, 1, 2]) == 0\nassert op_div3_sortd_firsteven([10]) == 0\nassert op_div3_sortd_firsteven([2, 4, 6]) == 6\nassert op_div3_sortd_firsteven([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_gt5_beforezero", "entry_point": "op_oremptyzero_gt5_beforezero", "primitives": ["oremptyzero", "gt5", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_oremptyzero_gt5_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_oremptyzero_gt5_beforezero([]) == []\nassert op_oremptyzero_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_gt5_beforezero([5, 5, 5]) == []\nassert op_oremptyzero_gt5_beforezero([3, 1, 2]) == []\nassert op_oremptyzero_gt5_beforezero([10]) == [10]\nassert op_oremptyzero_gt5_beforezero([2, 4, 6]) == [6]\nassert op_oremptyzero_gt5_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_add10_dropfirst_gt5", "entry_point": "op_add10_dropfirst_gt5", "primitives": ["add10", "dropfirst", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then keep values greater than five.", "solution": "def op_add10_dropfirst_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_dropfirst_gt5([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropfirst_gt5([]) == []\nassert op_add10_dropfirst_gt5([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_dropfirst_gt5([5, 5, 5]) == [15, 15]\nassert op_add10_dropfirst_gt5([3, 1, 2]) == [11, 12]\nassert op_add10_dropfirst_gt5([10]) == []\nassert op_add10_dropfirst_gt5([2, 4, 6]) == [14, 16]\nassert op_add10_dropfirst_gt5([-7, 12, -7]) == [22]"}
{"id": "op_inc_clamp10_issorted", "entry_point": "op_inc_clamp10_issorted", "primitives": ["inc", "clamp10", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_inc_clamp10_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_inc_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_inc_clamp10_issorted([]) == True\nassert op_inc_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_clamp10_issorted([5, 5, 5]) == True\nassert op_inc_clamp10_issorted([3, 1, 2]) == False\nassert op_inc_clamp10_issorted([10]) == True\nassert op_inc_clamp10_issorted([2, 4, 6]) == True\nassert op_inc_clamp10_issorted([-7, 12, -7]) == False"}
{"id": "op_dropzeros_clamp10_firsteven", "entry_point": "op_dropzeros_clamp10_firsteven", "primitives": ["dropzeros", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_dropzeros_clamp10_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_clamp10_firsteven([]) == 0\nassert op_dropzeros_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_clamp10_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_clamp10_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_clamp10_firsteven([10]) == 10\nassert op_dropzeros_clamp10_firsteven([2, 4, 6]) == 2\nassert op_dropzeros_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_last3_dropzeros_dec", "entry_point": "op_last3_dropzeros_dec", "primitives": ["last3", "dropzeros", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then subtract one from each.", "solution": "def op_last3_dropzeros_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_dropzeros_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_dropzeros_dec([]) == []\nassert op_last3_dropzeros_dec([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_last3_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_last3_dropzeros_dec([3, 1, 2]) == [2, 0, 1]\nassert op_last3_dropzeros_dec([10]) == [9]\nassert op_last3_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_last3_dropzeros_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_oremptyzero_neg_len", "entry_point": "op_oremptyzero_neg_len", "primitives": ["oremptyzero", "neg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then return how many remain.", "solution": "def op_oremptyzero_neg_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return len(r)", "tests": "assert op_oremptyzero_neg_len([1, 2, 3, 4]) == 0\nassert op_oremptyzero_neg_len([]) == 0\nassert op_oremptyzero_neg_len([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_neg_len([5, 5, 5]) == 0\nassert op_oremptyzero_neg_len([3, 1, 2]) == 0\nassert op_oremptyzero_neg_len([10]) == 0\nassert op_oremptyzero_neg_len([2, 4, 6]) == 0\nassert op_oremptyzero_neg_len([-7, 12, -7]) == 2"}
{"id": "op_takewhilepos_uniq_negate", "entry_point": "op_takewhilepos_uniq_negate", "primitives": ["takewhilepos", "uniq", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_takewhilepos_uniq_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_uniq_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_uniq_negate([]) == []\nassert op_takewhilepos_uniq_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_uniq_negate([5, 5, 5]) == [-5]\nassert op_takewhilepos_uniq_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_takewhilepos_uniq_negate([10]) == [-10]\nassert op_takewhilepos_uniq_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_uniq_negate([-7, 12, -7]) == []"}
{"id": "op_rev_evens_beforezero", "entry_point": "op_rev_evens_beforezero", "primitives": ["rev", "evens", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_rev_evens_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_evens_beforezero([1, 2, 3, 4]) == [4, 2]\nassert op_rev_evens_beforezero([]) == []\nassert op_rev_evens_beforezero([-2, -1, 0, 1, 2]) == [2]\nassert op_rev_evens_beforezero([5, 5, 5]) == []\nassert op_rev_evens_beforezero([3, 1, 2]) == [2]\nassert op_rev_evens_beforezero([10]) == [10]\nassert op_rev_evens_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_rev_oremptyzero_dropwhileneg", "entry_point": "op_rev_oremptyzero_dropwhileneg", "primitives": ["rev", "oremptyzero", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then drop the leading negative values.", "solution": "def op_rev_oremptyzero_dropwhileneg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_rev_oremptyzero_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_dropwhileneg([]) == [0]\nassert op_rev_oremptyzero_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_oremptyzero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_dropwhileneg([10]) == [10]\nassert op_rev_oremptyzero_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortabs_beforezero_odds", "entry_point": "op_sortabs_beforezero_odds", "primitives": ["sortabs", "beforezero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_sortabs_beforezero_odds(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortabs_beforezero_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sortabs_beforezero_odds([]) == []\nassert op_sortabs_beforezero_odds([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_beforezero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_beforezero_odds([3, 1, 2]) == [1, 3]\nassert op_sortabs_beforezero_odds([10]) == []\nassert op_sortabs_beforezero_odds([2, 4, 6]) == []\nassert op_sortabs_beforezero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_inc_uniq_sum", "entry_point": "op_inc_uniq_sum", "primitives": ["inc", "uniq", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_inc_uniq_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_inc_uniq_sum([1, 2, 3, 4]) == 14\nassert op_inc_uniq_sum([]) == 0\nassert op_inc_uniq_sum([-2, -1, 0, 1, 2]) == 5\nassert op_inc_uniq_sum([5, 5, 5]) == 6\nassert op_inc_uniq_sum([3, 1, 2]) == 9\nassert op_inc_uniq_sum([10]) == 11\nassert op_inc_uniq_sum([2, 4, 6]) == 15\nassert op_inc_uniq_sum([-7, 12, -7]) == 7"}
{"id": "op_inc_last3_dropwhileneg", "entry_point": "op_inc_last3_dropwhileneg", "primitives": ["inc", "last3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then drop the leading negative values.", "solution": "def op_inc_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_inc_last3_dropwhileneg([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_last3_dropwhileneg([]) == []\nassert op_inc_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_last3_dropwhileneg([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_dropwhileneg([3, 1, 2]) == [4, 2, 3]\nassert op_inc_last3_dropwhileneg([10]) == [11]\nassert op_inc_last3_dropwhileneg([2, 4, 6]) == [3, 5, 7]\nassert op_inc_last3_dropwhileneg([-7, 12, -7]) == [13, -6]"}
{"id": "op_div3_clamp10_takewhilepos", "entry_point": "op_div3_clamp10_takewhilepos", "primitives": ["div3", "clamp10", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then take values while they are positive.", "solution": "def op_div3_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_div3_clamp10_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_div3_clamp10_takewhilepos([]) == []\nassert op_div3_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_div3_clamp10_takewhilepos([5, 5, 5]) == []\nassert op_div3_clamp10_takewhilepos([3, 1, 2]) == [3]\nassert op_div3_clamp10_takewhilepos([10]) == []\nassert op_div3_clamp10_takewhilepos([2, 4, 6]) == [6]\nassert op_div3_clamp10_takewhilepos([-7, 12, -7]) == [10]"}
{"id": "op_square_first3_firsteven", "entry_point": "op_square_first3_firsteven", "primitives": ["square", "first3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_square_first3_firsteven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_square_first3_firsteven([1, 2, 3, 4]) == 4\nassert op_square_first3_firsteven([]) == 0\nassert op_square_first3_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_square_first3_firsteven([5, 5, 5]) == 0\nassert op_square_first3_firsteven([3, 1, 2]) == 4\nassert op_square_first3_firsteven([10]) == 100\nassert op_square_first3_firsteven([2, 4, 6]) == 4\nassert op_square_first3_firsteven([-7, 12, -7]) == 144"}
{"id": "op_dec_neg_issorted", "entry_point": "op_dec_neg_issorted", "primitives": ["dec", "neg", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_dec_neg_issorted(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_dec_neg_issorted([1, 2, 3, 4]) == True\nassert op_dec_neg_issorted([]) == True\nassert op_dec_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dec_neg_issorted([5, 5, 5]) == True\nassert op_dec_neg_issorted([3, 1, 2]) == True\nassert op_dec_neg_issorted([10]) == True\nassert op_dec_neg_issorted([2, 4, 6]) == True\nassert op_dec_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_inc_uniq", "entry_point": "op_dec_inc_uniq", "primitives": ["dec", "inc", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_dec_inc_uniq(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dec_inc_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc_uniq([]) == []\nassert op_dec_inc_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_dec_inc_uniq([5, 5, 5]) == [5]\nassert op_dec_inc_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_dec_inc_uniq([10]) == [10]\nassert op_dec_inc_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_add10_clamp10_absval", "entry_point": "op_add10_clamp10_absval", "primitives": ["add10", "clamp10", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then take the absolute value of each.", "solution": "def op_add10_clamp10_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_clamp10_absval([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_clamp10_absval([]) == []\nassert op_add10_clamp10_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_clamp10_absval([5, 5, 5]) == [10, 10, 10]\nassert op_add10_clamp10_absval([3, 1, 2]) == [10, 10, 10]\nassert op_add10_clamp10_absval([10]) == [10]\nassert op_add10_clamp10_absval([2, 4, 6]) == [10, 10, 10]\nassert op_add10_clamp10_absval([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_div3_odds_trimends", "entry_point": "op_div3_odds_trimends", "primitives": ["div3", "odds", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_div3_odds_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_odds_trimends([1, 2, 3, 4]) == []\nassert op_div3_odds_trimends([]) == []\nassert op_div3_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_trimends([5, 5, 5]) == []\nassert op_div3_odds_trimends([3, 1, 2]) == []\nassert op_div3_odds_trimends([10]) == []\nassert op_div3_odds_trimends([2, 4, 6]) == []\nassert op_div3_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_ages_evens_beforezero", "entry_point": "op_ages_evens_beforezero", "primitives": ["ages", "evens", "beforezero"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_ages_evens_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_evens_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_evens_beforezero([]) == []\nassert op_ages_evens_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens_beforezero([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_add10_oremptyzero_uniq", "entry_point": "op_add10_oremptyzero_uniq", "primitives": ["add10", "oremptyzero", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_add10_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_add10_oremptyzero_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_oremptyzero_uniq([]) == [0]\nassert op_add10_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_oremptyzero_uniq([5, 5, 5]) == [15]\nassert op_add10_oremptyzero_uniq([3, 1, 2]) == [13, 11, 12]\nassert op_add10_oremptyzero_uniq([10]) == [20]\nassert op_add10_oremptyzero_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_add10_oremptyzero_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropzeros_square_anyeven", "entry_point": "op_dropzeros_square_anyeven", "primitives": ["dropzeros", "square", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then square each, then return whether any value is even.", "solution": "def op_dropzeros_square_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_square_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_square_anyeven([]) == False\nassert op_dropzeros_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_square_anyeven([5, 5, 5]) == False\nassert op_dropzeros_square_anyeven([3, 1, 2]) == True\nassert op_dropzeros_square_anyeven([10]) == True\nassert op_dropzeros_square_anyeven([2, 4, 6]) == True\nassert op_dropzeros_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_beforezero_sortabs", "entry_point": "op_takewhilepos_beforezero_sortabs", "primitives": ["takewhilepos", "beforezero", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then sort by absolute value.", "solution": "def op_takewhilepos_beforezero_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_beforezero_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_beforezero_sortabs([]) == []\nassert op_takewhilepos_beforezero_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_beforezero_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_beforezero_sortabs([10]) == [10]\nassert op_takewhilepos_beforezero_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_beforezero_sortabs([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_last3_evens", "entry_point": "op_dropwhileneg_last3_evens", "primitives": ["dropwhileneg", "last3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then keep the even numbers.", "solution": "def op_dropwhileneg_last3_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_last3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropwhileneg_last3_evens([]) == []\nassert op_dropwhileneg_last3_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropwhileneg_last3_evens([5, 5, 5]) == []\nassert op_dropwhileneg_last3_evens([3, 1, 2]) == [2]\nassert op_dropwhileneg_last3_evens([10]) == [10]\nassert op_dropwhileneg_last3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_last3_evens([-7, 12, -7]) == [12]"}
{"id": "op_sorta_clamp10_sortabs", "entry_point": "op_sorta_clamp10_sortabs", "primitives": ["sorta", "clamp10", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then sort by absolute value.", "solution": "def op_sorta_clamp10_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_clamp10_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10_sortabs([]) == []\nassert op_sorta_clamp10_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sorta_clamp10_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_sortabs([10]) == [10]\nassert op_sorta_clamp10_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_sortabs([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_upper_nonempty_prefixup", "entry_point": "op_upper_nonempty_prefixup", "primitives": ["upper", "nonempty", "prefixup"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop empty strings, then prefix each with a hash.", "solution": "def op_upper_nonempty_prefixup(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_upper_nonempty_prefixup(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_upper_nonempty_prefixup([]) == []\nassert op_upper_nonempty_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ', '#BC', '#BC']\nassert op_upper_nonempty_prefixup(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_upper_nonempty_prefixup(['x']) == ['#X']\nassert op_upper_nonempty_prefixup(['abc', 'de', '']) == ['#ABC', '#DE']"}
{"id": "op_absval_dec_evens", "entry_point": "op_absval_dec_evens", "primitives": ["absval", "dec", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then keep the even numbers.", "solution": "def op_absval_dec_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_dec_evens([1, 2, 3, 4]) == [0, 2]\nassert op_absval_dec_evens([]) == []\nassert op_absval_dec_evens([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_absval_dec_evens([5, 5, 5]) == [4, 4, 4]\nassert op_absval_dec_evens([3, 1, 2]) == [2, 0]\nassert op_absval_dec_evens([10]) == []\nassert op_absval_dec_evens([2, 4, 6]) == []\nassert op_absval_dec_evens([-7, 12, -7]) == [6, 6]"}
{"id": "op_inc_add10_sortd", "entry_point": "op_inc_add10_sortd", "primitives": ["inc", "add10", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then sort descending.", "solution": "def op_inc_add10_sortd(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_inc_add10_sortd([1, 2, 3, 4]) == [15, 14, 13, 12]\nassert op_inc_add10_sortd([]) == []\nassert op_inc_add10_sortd([-2, -1, 0, 1, 2]) == [13, 12, 11, 10, 9]\nassert op_inc_add10_sortd([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10_sortd([3, 1, 2]) == [14, 13, 12]\nassert op_inc_add10_sortd([10]) == [21]\nassert op_inc_add10_sortd([2, 4, 6]) == [17, 15, 13]\nassert op_inc_add10_sortd([-7, 12, -7]) == [23, 4, 4]"}
{"id": "op_sorta_odds_sortabs", "entry_point": "op_sorta_odds_sortabs", "primitives": ["sorta", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers, then sort by absolute value.", "solution": "def op_sorta_odds_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_odds_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_sorta_odds_sortabs([]) == []\nassert op_sorta_odds_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sorta_odds_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_odds_sortabs([3, 1, 2]) == [1, 3]\nassert op_sorta_odds_sortabs([10]) == []\nassert op_sorta_odds_sortabs([2, 4, 6]) == []\nassert op_sorta_odds_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_negate_alldistinct", "entry_point": "op_div3_negate_alldistinct", "primitives": ["div3", "negate", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then return whether all values are distinct.", "solution": "def op_div3_negate_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_div3_negate_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_negate_alldistinct([]) == True\nassert op_div3_negate_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_negate_alldistinct([5, 5, 5]) == True\nassert op_div3_negate_alldistinct([3, 1, 2]) == True\nassert op_div3_negate_alldistinct([10]) == True\nassert op_div3_negate_alldistinct([2, 4, 6]) == True\nassert op_div3_negate_alldistinct([-7, 12, -7]) == True"}
{"id": "op_first3_dropfirst_uniq", "entry_point": "op_first3_dropfirst_uniq", "primitives": ["first3", "dropfirst", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then drop duplicates keeping first occurrence.", "solution": "def op_first3_dropfirst_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_dropfirst_uniq([1, 2, 3, 4]) == [2, 3]\nassert op_first3_dropfirst_uniq([]) == []\nassert op_first3_dropfirst_uniq([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_first3_dropfirst_uniq([5, 5, 5]) == [5]\nassert op_first3_dropfirst_uniq([3, 1, 2]) == [1, 2]\nassert op_first3_dropfirst_uniq([10]) == []\nassert op_first3_dropfirst_uniq([2, 4, 6]) == [4, 6]\nassert op_first3_dropfirst_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_dropfirst_dropzeros_double", "entry_point": "op_dropfirst_dropzeros_double", "primitives": ["dropfirst", "dropzeros", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then double each.", "solution": "def op_dropfirst_dropzeros_double(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropfirst_dropzeros_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_dropfirst_dropzeros_double([]) == []\nassert op_dropfirst_dropzeros_double([-2, -1, 0, 1, 2]) == [-2, 2, 4]\nassert op_dropfirst_dropzeros_double([5, 5, 5]) == [10, 10]\nassert op_dropfirst_dropzeros_double([3, 1, 2]) == [2, 4]\nassert op_dropfirst_dropzeros_double([10]) == []\nassert op_dropfirst_dropzeros_double([2, 4, 6]) == [8, 12]\nassert op_dropfirst_dropzeros_double([-7, 12, -7]) == [24, -14]"}
{"id": "op_clamp10_inc_trimends", "entry_point": "op_clamp10_inc_trimends", "primitives": ["clamp10", "inc", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then drop the first and last elements.", "solution": "def op_clamp10_inc_trimends(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_clamp10_inc_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_clamp10_inc_trimends([]) == []\nassert op_clamp10_inc_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_inc_trimends([5, 5, 5]) == [6]\nassert op_clamp10_inc_trimends([3, 1, 2]) == [2]\nassert op_clamp10_inc_trimends([10]) == []\nassert op_clamp10_inc_trimends([2, 4, 6]) == [5]\nassert op_clamp10_inc_trimends([-7, 12, -7]) == [11]"}
{"id": "op_sorta_gt5_oremptyzero", "entry_point": "op_sorta_gt5_oremptyzero", "primitives": ["sorta", "gt5", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep values greater than five, then if empty, use a single zero.", "solution": "def op_sorta_gt5_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_gt5_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_sorta_gt5_oremptyzero([]) == [0]\nassert op_sorta_gt5_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_sorta_gt5_oremptyzero([5, 5, 5]) == [0]\nassert op_sorta_gt5_oremptyzero([3, 1, 2]) == [0]\nassert op_sorta_gt5_oremptyzero([10]) == [10]\nassert op_sorta_gt5_oremptyzero([2, 4, 6]) == [6]\nassert op_sorta_gt5_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_double_sortd_absval", "entry_point": "op_double_sortd_absval", "primitives": ["double", "sortd", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending, then take the absolute value of each.", "solution": "def op_double_sortd_absval(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_double_sortd_absval([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_sortd_absval([]) == []\nassert op_double_sortd_absval([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_double_sortd_absval([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortd_absval([3, 1, 2]) == [6, 4, 2]\nassert op_double_sortd_absval([10]) == [20]\nassert op_double_sortd_absval([2, 4, 6]) == [12, 8, 4]\nassert op_double_sortd_absval([-7, 12, -7]) == [24, 14, 14]"}
{"id": "op_double_dropzeros_uniq", "entry_point": "op_double_dropzeros_uniq", "primitives": ["double", "dropzeros", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then drop duplicates keeping first occurrence.", "solution": "def op_double_dropzeros_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_dropzeros_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropzeros_uniq([]) == []\nassert op_double_dropzeros_uniq([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_dropzeros_uniq([5, 5, 5]) == [10]\nassert op_double_dropzeros_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_double_dropzeros_uniq([10]) == [20]\nassert op_double_dropzeros_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropzeros_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_double_last3_evens", "entry_point": "op_double_last3_evens", "primitives": ["double", "last3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three, then keep the even numbers.", "solution": "def op_double_last3_evens(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_double_last3_evens([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_last3_evens([]) == []\nassert op_double_last3_evens([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_last3_evens([5, 5, 5]) == [10, 10, 10]\nassert op_double_last3_evens([3, 1, 2]) == [6, 2, 4]\nassert op_double_last3_evens([10]) == [20]\nassert op_double_last3_evens([2, 4, 6]) == [4, 8, 12]\nassert op_double_last3_evens([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_clamp10_last3_sortabs", "entry_point": "op_clamp10_last3_sortabs", "primitives": ["clamp10", "last3", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the last three, then sort by absolute value.", "solution": "def op_clamp10_last3_sortabs(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_clamp10_last3_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_last3_sortabs([]) == []\nassert op_clamp10_last3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_last3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_last3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_last3_sortabs([10]) == [10]\nassert op_clamp10_last3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_last3_sortabs([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_neg_rev_sum", "entry_point": "op_neg_rev_sum", "primitives": ["neg", "rev", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then return their sum.", "solution": "def op_neg_rev_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return sum(r)", "tests": "assert op_neg_rev_sum([1, 2, 3, 4]) == 0\nassert op_neg_rev_sum([]) == 0\nassert op_neg_rev_sum([-2, -1, 0, 1, 2]) == -3\nassert op_neg_rev_sum([5, 5, 5]) == 0\nassert op_neg_rev_sum([3, 1, 2]) == 0\nassert op_neg_rev_sum([10]) == 0\nassert op_neg_rev_sum([2, 4, 6]) == 0\nassert op_neg_rev_sum([-7, 12, -7]) == -14"}
{"id": "op_trimends_neg_anyeven", "entry_point": "op_trimends_neg_anyeven", "primitives": ["trimends", "neg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then return whether any value is even.", "solution": "def op_trimends_neg_anyeven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_trimends_neg_anyeven([1, 2, 3, 4]) == False\nassert op_trimends_neg_anyeven([]) == False\nassert op_trimends_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_trimends_neg_anyeven([5, 5, 5]) == False\nassert op_trimends_neg_anyeven([3, 1, 2]) == False\nassert op_trimends_neg_anyeven([10]) == False\nassert op_trimends_neg_anyeven([2, 4, 6]) == False\nassert op_trimends_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_sortabs_gt5_sum", "entry_point": "op_sortabs_gt5_sum", "primitives": ["sortabs", "gt5", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then return their sum.", "solution": "def op_sortabs_gt5_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_sortabs_gt5_sum([1, 2, 3, 4]) == 0\nassert op_sortabs_gt5_sum([]) == 0\nassert op_sortabs_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_gt5_sum([5, 5, 5]) == 0\nassert op_sortabs_gt5_sum([3, 1, 2]) == 0\nassert op_sortabs_gt5_sum([10]) == 10\nassert op_sortabs_gt5_sum([2, 4, 6]) == 6\nassert op_sortabs_gt5_sum([-7, 12, -7]) == 12"}
{"id": "op_sorta_dec_add10", "entry_point": "op_sorta_dec_add10", "primitives": ["sorta", "dec", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then add ten to each.", "solution": "def op_sorta_dec_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_dec_add10([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_sorta_dec_add10([]) == []\nassert op_sorta_dec_add10([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_sorta_dec_add10([5, 5, 5]) == [14, 14, 14]\nassert op_sorta_dec_add10([3, 1, 2]) == [10, 11, 12]\nassert op_sorta_dec_add10([10]) == [19]\nassert op_sorta_dec_add10([2, 4, 6]) == [11, 13, 15]\nassert op_sorta_dec_add10([-7, 12, -7]) == [2, 2, 21]"}
{"id": "op_padto3_uniq_add10", "entry_point": "op_padto3_uniq_add10", "primitives": ["padto3", "uniq", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_padto3_uniq_add10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_padto3_uniq_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_padto3_uniq_add10([]) == [10]\nassert op_padto3_uniq_add10([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_padto3_uniq_add10([5, 5, 5]) == [15]\nassert op_padto3_uniq_add10([3, 1, 2]) == [13, 11, 12]\nassert op_padto3_uniq_add10([10]) == [20, 10]\nassert op_padto3_uniq_add10([2, 4, 6]) == [12, 14, 16]\nassert op_padto3_uniq_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_sortd_absval_sortabs", "entry_point": "op_sortd_absval_sortabs", "primitives": ["sortd", "absval", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then sort by absolute value.", "solution": "def op_sortd_absval_sortabs(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sortd_absval_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_absval_sortabs([]) == []\nassert op_sortd_absval_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_sortd_absval_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_absval_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_absval_sortabs([10]) == [10]\nassert op_sortd_absval_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_absval_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_sortabs_sorta_alldistinct", "entry_point": "op_sortabs_sorta_alldistinct", "primitives": ["sortabs", "sorta", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then return whether all values are distinct.", "solution": "def op_sortabs_sorta_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_sorta_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_sorta_alldistinct([]) == True\nassert op_sortabs_sorta_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_sorta_alldistinct([5, 5, 5]) == False\nassert op_sortabs_sorta_alldistinct([3, 1, 2]) == True\nassert op_sortabs_sorta_alldistinct([10]) == True\nassert op_sortabs_sorta_alldistinct([2, 4, 6]) == True\nassert op_sortabs_sorta_alldistinct([-7, 12, -7]) == False"}
{"id": "op_trimends_last3_anyeven", "entry_point": "op_trimends_last3_anyeven", "primitives": ["trimends", "last3", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then return whether any value is even.", "solution": "def op_trimends_last3_anyeven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_trimends_last3_anyeven([1, 2, 3, 4]) == True\nassert op_trimends_last3_anyeven([]) == False\nassert op_trimends_last3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_trimends_last3_anyeven([5, 5, 5]) == False\nassert op_trimends_last3_anyeven([3, 1, 2]) == False\nassert op_trimends_last3_anyeven([10]) == False\nassert op_trimends_last3_anyeven([2, 4, 6]) == True\nassert op_trimends_last3_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_first3_dropwhileneg", "entry_point": "op_clamp10_first3_dropwhileneg", "primitives": ["clamp10", "first3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep only the first three, then drop the leading negative values.", "solution": "def op_clamp10_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_first3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_clamp10_first3_dropwhileneg([]) == []\nassert op_clamp10_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_clamp10_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_first3_dropwhileneg([10]) == [10]\nassert op_clamp10_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_first3_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_uniq_double_square", "entry_point": "op_uniq_double_square", "primitives": ["uniq", "double", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then square each.", "solution": "def op_uniq_double_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_double_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_uniq_double_square([]) == []\nassert op_uniq_double_square([-2, -1, 0, 1, 2]) == [16, 4, 0, 4, 16]\nassert op_uniq_double_square([5, 5, 5]) == [100]\nassert op_uniq_double_square([3, 1, 2]) == [36, 4, 16]\nassert op_uniq_double_square([10]) == [400]\nassert op_uniq_double_square([2, 4, 6]) == [16, 64, 144]\nassert op_uniq_double_square([-7, 12, -7]) == [196, 576]"}
{"id": "op_dropfirst_add10_firsteven", "entry_point": "op_dropfirst_add10_firsteven", "primitives": ["dropfirst", "add10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then return the first even value (0 if none).", "solution": "def op_dropfirst_add10_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_add10_firsteven([1, 2, 3, 4]) == 12\nassert op_dropfirst_add10_firsteven([]) == 0\nassert op_dropfirst_add10_firsteven([-2, -1, 0, 1, 2]) == 10\nassert op_dropfirst_add10_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_add10_firsteven([3, 1, 2]) == 12\nassert op_dropfirst_add10_firsteven([10]) == 0\nassert op_dropfirst_add10_firsteven([2, 4, 6]) == 14\nassert op_dropfirst_add10_firsteven([-7, 12, -7]) == 22"}
{"id": "op_dropzeros_padto3_dropfirst", "entry_point": "op_dropzeros_padto3_dropfirst", "primitives": ["dropzeros", "padto3", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_dropzeros_padto3_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_padto3_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_padto3_dropfirst([]) == [0, 0]\nassert op_dropzeros_padto3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_dropzeros_padto3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropzeros_padto3_dropfirst([3, 1, 2]) == [1, 2]\nassert op_dropzeros_padto3_dropfirst([10]) == [0, 0]\nassert op_dropzeros_padto3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropzeros_padto3_dropfirst([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_beforezero_div3", "entry_point": "op_padto3_beforezero_div3", "primitives": ["padto3", "beforezero", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_padto3_beforezero_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_beforezero_div3([]) == []\nassert op_padto3_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_padto3_beforezero_div3([5, 5, 5]) == []\nassert op_padto3_beforezero_div3([3, 1, 2]) == [3]\nassert op_padto3_beforezero_div3([10]) == []\nassert op_padto3_beforezero_div3([2, 4, 6]) == [6]\nassert op_padto3_beforezero_div3([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_add10_alldistinct", "entry_point": "op_takewhilepos_add10_alldistinct", "primitives": ["takewhilepos", "add10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then return whether all values are distinct.", "solution": "def op_takewhilepos_add10_alldistinct(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_takewhilepos_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_takewhilepos_add10_alldistinct([]) == True\nassert op_takewhilepos_add10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_add10_alldistinct([5, 5, 5]) == False\nassert op_takewhilepos_add10_alldistinct([3, 1, 2]) == True\nassert op_takewhilepos_add10_alldistinct([10]) == True\nassert op_takewhilepos_add10_alldistinct([2, 4, 6]) == True\nassert op_takewhilepos_add10_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropzeros_inc_haszero", "entry_point": "op_dropzeros_inc_haszero", "primitives": ["dropzeros", "inc", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then return whether the list contains a zero.", "solution": "def op_dropzeros_inc_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_dropzeros_inc_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_inc_haszero([]) == False\nassert op_dropzeros_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_inc_haszero([5, 5, 5]) == False\nassert op_dropzeros_inc_haszero([3, 1, 2]) == False\nassert op_dropzeros_inc_haszero([10]) == False\nassert op_dropzeros_inc_haszero([2, 4, 6]) == False\nassert op_dropzeros_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_add10_dropzeros_sortabs", "entry_point": "op_add10_dropzeros_sortabs", "primitives": ["add10", "dropzeros", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then sort by absolute value.", "solution": "def op_add10_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_dropzeros_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros_sortabs([]) == []\nassert op_add10_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_add10_dropzeros_sortabs([10]) == [20]\nassert op_add10_dropzeros_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_sortabs_add10_uniq", "entry_point": "op_sortabs_add10_uniq", "primitives": ["sortabs", "add10", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_add10_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_add10_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sortabs_add10_uniq([]) == []\nassert op_sortabs_add10_uniq([-2, -1, 0, 1, 2]) == [10, 9, 11, 8, 12]\nassert op_sortabs_add10_uniq([5, 5, 5]) == [15]\nassert op_sortabs_add10_uniq([3, 1, 2]) == [11, 12, 13]\nassert op_sortabs_add10_uniq([10]) == [20]\nassert op_sortabs_add10_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_sortabs_add10_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_sortalpha_dropshort_lower", "entry_point": "op_sortalpha_dropshort_lower", "primitives": ["sortalpha", "dropshort", "lower"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters, then lowercase each string.", "solution": "def op_sortalpha_dropshort_lower(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_sortalpha_dropshort_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_sortalpha_dropshort_lower([]) == []\nassert op_sortalpha_dropshort_lower(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_sortalpha_dropshort_lower(['one', 'one', 'Two']) == ['two', 'one', 'one']\nassert op_sortalpha_dropshort_lower(['x']) == []\nassert op_sortalpha_dropshort_lower(['abc', 'de', '']) == ['abc']"}
{"id": "op_rev_div3_sum", "entry_point": "op_rev_div3_sum", "primitives": ["rev", "div3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then return their sum.", "solution": "def op_rev_div3_sum(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return sum(r)", "tests": "assert op_rev_div3_sum([1, 2, 3, 4]) == 3\nassert op_rev_div3_sum([]) == 0\nassert op_rev_div3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_rev_div3_sum([5, 5, 5]) == 0\nassert op_rev_div3_sum([3, 1, 2]) == 3\nassert op_rev_div3_sum([10]) == 0\nassert op_rev_div3_sum([2, 4, 6]) == 6\nassert op_rev_div3_sum([-7, 12, -7]) == 12"}
{"id": "op_dec_div3_dropzeros", "entry_point": "op_dec_div3_dropzeros", "primitives": ["dec", "div3", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three, then drop the zeros.", "solution": "def op_dec_div3_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_div3_dropzeros([1, 2, 3, 4]) == [3]\nassert op_dec_div3_dropzeros([]) == []\nassert op_dec_div3_dropzeros([-2, -1, 0, 1, 2]) == [-3]\nassert op_dec_div3_dropzeros([5, 5, 5]) == []\nassert op_dec_div3_dropzeros([3, 1, 2]) == []\nassert op_dec_div3_dropzeros([10]) == [9]\nassert op_dec_div3_dropzeros([2, 4, 6]) == [3]\nassert op_dec_div3_dropzeros([-7, 12, -7]) == []"}
{"id": "op_odds_sorta_evens", "entry_point": "op_odds_sorta_evens", "primitives": ["odds", "sorta", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then keep the even numbers.", "solution": "def op_odds_sorta_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_odds_sorta_evens([1, 2, 3, 4]) == []\nassert op_odds_sorta_evens([]) == []\nassert op_odds_sorta_evens([-2, -1, 0, 1, 2]) == []\nassert op_odds_sorta_evens([5, 5, 5]) == []\nassert op_odds_sorta_evens([3, 1, 2]) == []\nassert op_odds_sorta_evens([10]) == []\nassert op_odds_sorta_evens([2, 4, 6]) == []\nassert op_odds_sorta_evens([-7, 12, -7]) == []"}
{"id": "op_clamp10_evens_double", "entry_point": "op_clamp10_evens_double", "primitives": ["clamp10", "evens", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers, then double each.", "solution": "def op_clamp10_evens_double(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_clamp10_evens_double([1, 2, 3, 4]) == [4, 8]\nassert op_clamp10_evens_double([]) == []\nassert op_clamp10_evens_double([-2, -1, 0, 1, 2]) == [-4, 0, 4]\nassert op_clamp10_evens_double([5, 5, 5]) == []\nassert op_clamp10_evens_double([3, 1, 2]) == [4]\nassert op_clamp10_evens_double([10]) == [20]\nassert op_clamp10_evens_double([2, 4, 6]) == [4, 8, 12]\nassert op_clamp10_evens_double([-7, 12, -7]) == [20]"}
{"id": "op_oremptyzero_clamp10_div3", "entry_point": "op_oremptyzero_clamp10_div3", "primitives": ["oremptyzero", "clamp10", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then keep multiples of three.", "solution": "def op_oremptyzero_clamp10_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_clamp10_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_clamp10_div3([]) == [0]\nassert op_oremptyzero_clamp10_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_clamp10_div3([5, 5, 5]) == []\nassert op_oremptyzero_clamp10_div3([3, 1, 2]) == [3]\nassert op_oremptyzero_clamp10_div3([10]) == []\nassert op_oremptyzero_clamp10_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_clamp10_div3([-7, 12, -7]) == []"}
{"id": "op_padto3_dec_odds", "entry_point": "op_padto3_dec_odds", "primitives": ["padto3", "dec", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then keep the odd numbers.", "solution": "def op_padto3_dec_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_dec_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_dec_odds([]) == [-1, -1, -1]\nassert op_padto3_dec_odds([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_padto3_dec_odds([5, 5, 5]) == []\nassert op_padto3_dec_odds([3, 1, 2]) == [1]\nassert op_padto3_dec_odds([10]) == [9, -1, -1]\nassert op_padto3_dec_odds([2, 4, 6]) == [1, 3, 5]\nassert op_padto3_dec_odds([-7, 12, -7]) == [11]"}
{"id": "op_last3_beforezero_takewhilepos", "entry_point": "op_last3_beforezero_takewhilepos", "primitives": ["last3", "beforezero", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_last3_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_beforezero_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_beforezero_takewhilepos([]) == []\nassert op_last3_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_beforezero_takewhilepos([10]) == [10]\nassert op_last3_beforezero_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_trimends_oremptyzero_rev", "entry_point": "op_trimends_oremptyzero_rev", "primitives": ["trimends", "oremptyzero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then reverse the order.", "solution": "def op_trimends_oremptyzero_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_oremptyzero_rev([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_oremptyzero_rev([]) == [0]\nassert op_trimends_oremptyzero_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_oremptyzero_rev([5, 5, 5]) == [5]\nassert op_trimends_oremptyzero_rev([3, 1, 2]) == [1]\nassert op_trimends_oremptyzero_rev([10]) == [0]\nassert op_trimends_oremptyzero_rev([2, 4, 6]) == [4]\nassert op_trimends_oremptyzero_rev([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_div3_min", "entry_point": "op_beforezero_div3_min", "primitives": ["beforezero", "div3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_beforezero_div3_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_beforezero_div3_min([1, 2, 3, 4]) == 3\nassert op_beforezero_div3_min([]) == 0\nassert op_beforezero_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_div3_min([5, 5, 5]) == 0\nassert op_beforezero_div3_min([3, 1, 2]) == 3\nassert op_beforezero_div3_min([10]) == 0\nassert op_beforezero_div3_min([2, 4, 6]) == 6\nassert op_beforezero_div3_min([-7, 12, -7]) == 12"}
{"id": "op_sortage_names_sortlen", "entry_point": "op_sortage_names_sortlen", "primitives": ["sortage", "names", "sortlen"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the names, then sort by length, shortest first.", "solution": "def op_sortage_names_sortlen(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_sortage_names_sortlen([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Bo', 'Ada']\nassert op_sortage_names_sortlen([]) == []\nassert op_sortage_names_sortlen([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['El', 'Cy', 'Dee']\nassert op_sortage_names_sortlen([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_add10_odds_sortabs", "entry_point": "op_add10_odds_sortabs", "primitives": ["add10", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then sort by absolute value.", "solution": "def op_add10_odds_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_odds_sortabs([1, 2, 3, 4]) == [11, 13]\nassert op_add10_odds_sortabs([]) == []\nassert op_add10_odds_sortabs([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_add10_odds_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_odds_sortabs([3, 1, 2]) == [11, 13]\nassert op_add10_odds_sortabs([10]) == []\nassert op_add10_odds_sortabs([2, 4, 6]) == []\nassert op_add10_odds_sortabs([-7, 12, -7]) == [3, 3]"}
{"id": "op_add10_sorta_gt5", "entry_point": "op_add10_sorta_gt5", "primitives": ["add10", "sorta", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort ascending, then keep values greater than five.", "solution": "def op_add10_sorta_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_sorta_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_sorta_gt5([]) == []\nassert op_add10_sorta_gt5([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_sorta_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sorta_gt5([3, 1, 2]) == [11, 12, 13]\nassert op_add10_sorta_gt5([10]) == [20]\nassert op_add10_sorta_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sorta_gt5([-7, 12, -7]) == [22]"}
{"id": "op_sorta_pos_evens", "entry_point": "op_sorta_pos_evens", "primitives": ["sorta", "pos", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers, then keep the even numbers.", "solution": "def op_sorta_pos_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_pos_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_pos_evens([]) == []\nassert op_sorta_pos_evens([-2, -1, 0, 1, 2]) == [2]\nassert op_sorta_pos_evens([5, 5, 5]) == []\nassert op_sorta_pos_evens([3, 1, 2]) == [2]\nassert op_sorta_pos_evens([10]) == [10]\nassert op_sorta_pos_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_pos_evens([-7, 12, -7]) == [12]"}
{"id": "op_odds_add10_pos", "entry_point": "op_odds_add10_pos", "primitives": ["odds", "add10", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then keep the positive numbers.", "solution": "def op_odds_add10_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_odds_add10_pos([1, 2, 3, 4]) == [11, 13]\nassert op_odds_add10_pos([]) == []\nassert op_odds_add10_pos([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_add10_pos([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10_pos([3, 1, 2]) == [13, 11]\nassert op_odds_add10_pos([10]) == []\nassert op_odds_add10_pos([2, 4, 6]) == []\nassert op_odds_add10_pos([-7, 12, -7]) == [3, 3]"}
{"id": "op_sortabs_pos_sum", "entry_point": "op_sortabs_pos_sum", "primitives": ["sortabs", "pos", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then return their sum.", "solution": "def op_sortabs_pos_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    return sum(r)", "tests": "assert op_sortabs_pos_sum([1, 2, 3, 4]) == 10\nassert op_sortabs_pos_sum([]) == 0\nassert op_sortabs_pos_sum([-2, -1, 0, 1, 2]) == 3\nassert op_sortabs_pos_sum([5, 5, 5]) == 15\nassert op_sortabs_pos_sum([3, 1, 2]) == 6\nassert op_sortabs_pos_sum([10]) == 10\nassert op_sortabs_pos_sum([2, 4, 6]) == 12\nassert op_sortabs_pos_sum([-7, 12, -7]) == 12"}
{"id": "op_last3_dropwhileneg_anyeven", "entry_point": "op_last3_dropwhileneg_anyeven", "primitives": ["last3", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then return whether any value is even.", "solution": "def op_last3_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_last3_dropwhileneg_anyeven([]) == False\nassert op_last3_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_last3_dropwhileneg_anyeven([3, 1, 2]) == True\nassert op_last3_dropwhileneg_anyeven([10]) == True\nassert op_last3_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_last3_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_odds_counteven", "entry_point": "op_clamp10_odds_counteven", "primitives": ["clamp10", "odds", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then return how many values are even.", "solution": "def op_clamp10_odds_counteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_clamp10_odds_counteven([1, 2, 3, 4]) == 0\nassert op_clamp10_odds_counteven([]) == 0\nassert op_clamp10_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_odds_counteven([5, 5, 5]) == 0\nassert op_clamp10_odds_counteven([3, 1, 2]) == 0\nassert op_clamp10_odds_counteven([10]) == 0\nassert op_clamp10_odds_counteven([2, 4, 6]) == 0\nassert op_clamp10_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_padto3_first3_min", "entry_point": "op_padto3_first3_min", "primitives": ["padto3", "first3", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_padto3_first3_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_padto3_first3_min([1, 2, 3, 4]) == 1\nassert op_padto3_first3_min([]) == 0\nassert op_padto3_first3_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_first3_min([5, 5, 5]) == 5\nassert op_padto3_first3_min([3, 1, 2]) == 1\nassert op_padto3_first3_min([10]) == 0\nassert op_padto3_first3_min([2, 4, 6]) == 2\nassert op_padto3_first3_min([-7, 12, -7]) == -7"}
{"id": "op_pos_uniq_prod", "entry_point": "op_pos_uniq_prod", "primitives": ["pos", "uniq", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then return their product.", "solution": "def op_pos_uniq_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_pos_uniq_prod([1, 2, 3, 4]) == 24\nassert op_pos_uniq_prod([]) == 1\nassert op_pos_uniq_prod([-2, -1, 0, 1, 2]) == 2\nassert op_pos_uniq_prod([5, 5, 5]) == 5\nassert op_pos_uniq_prod([3, 1, 2]) == 6\nassert op_pos_uniq_prod([10]) == 10\nassert op_pos_uniq_prod([2, 4, 6]) == 48\nassert op_pos_uniq_prod([-7, 12, -7]) == 12"}
{"id": "op_uniq_clamp10_max", "entry_point": "op_uniq_clamp10_max", "primitives": ["uniq", "clamp10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then return the maximum (0 if empty).", "solution": "def op_uniq_clamp10_max(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return max(r) if r else 0", "tests": "assert op_uniq_clamp10_max([1, 2, 3, 4]) == 4\nassert op_uniq_clamp10_max([]) == 0\nassert op_uniq_clamp10_max([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_clamp10_max([5, 5, 5]) == 5\nassert op_uniq_clamp10_max([3, 1, 2]) == 3\nassert op_uniq_clamp10_max([10]) == 10\nassert op_uniq_clamp10_max([2, 4, 6]) == 6\nassert op_uniq_clamp10_max([-7, 12, -7]) == 10"}
{"id": "op_pos_beforezero_add10", "entry_point": "op_pos_beforezero_add10", "primitives": ["pos", "beforezero", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then add ten to each.", "solution": "def op_pos_beforezero_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_pos_beforezero_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_beforezero_add10([]) == []\nassert op_pos_beforezero_add10([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_beforezero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_pos_beforezero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_pos_beforezero_add10([10]) == [20]\nassert op_pos_beforezero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_pos_beforezero_add10([-7, 12, -7]) == [22]"}
{"id": "op_div3_gt5_allpos", "entry_point": "op_div3_gt5_allpos", "primitives": ["div3", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep values greater than five, then return whether all values are positive.", "solution": "def op_div3_gt5_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_div3_gt5_allpos([1, 2, 3, 4]) == True\nassert op_div3_gt5_allpos([]) == True\nassert op_div3_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_div3_gt5_allpos([5, 5, 5]) == True\nassert op_div3_gt5_allpos([3, 1, 2]) == True\nassert op_div3_gt5_allpos([10]) == True\nassert op_div3_gt5_allpos([2, 4, 6]) == True\nassert op_div3_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_last3_odds_dropfirst", "entry_point": "op_last3_odds_dropfirst", "primitives": ["last3", "odds", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then drop the first element.", "solution": "def op_last3_odds_dropfirst(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_last3_odds_dropfirst([1, 2, 3, 4]) == []\nassert op_last3_odds_dropfirst([]) == []\nassert op_last3_odds_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_last3_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_last3_odds_dropfirst([3, 1, 2]) == [1]\nassert op_last3_odds_dropfirst([10]) == []\nassert op_last3_odds_dropfirst([2, 4, 6]) == []\nassert op_last3_odds_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_sortabs_dropfirst_trimends", "entry_point": "op_sortabs_dropfirst_trimends", "primitives": ["sortabs", "dropfirst", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element, then drop the first and last elements.", "solution": "def op_sortabs_dropfirst_trimends(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortabs_dropfirst_trimends([1, 2, 3, 4]) == [3]\nassert op_sortabs_dropfirst_trimends([]) == []\nassert op_sortabs_dropfirst_trimends([-2, -1, 0, 1, 2]) == [1, -2]\nassert op_sortabs_dropfirst_trimends([5, 5, 5]) == []\nassert op_sortabs_dropfirst_trimends([3, 1, 2]) == []\nassert op_sortabs_dropfirst_trimends([10]) == []\nassert op_sortabs_dropfirst_trimends([2, 4, 6]) == []\nassert op_sortabs_dropfirst_trimends([-7, 12, -7]) == []"}
{"id": "op_padto3_odds_dropwhileneg", "entry_point": "op_padto3_odds_dropwhileneg", "primitives": ["padto3", "odds", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_padto3_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_odds_dropwhileneg([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_odds_dropwhileneg([]) == []\nassert op_padto3_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1]\nassert op_padto3_odds_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_odds_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_padto3_odds_dropwhileneg([10]) == []\nassert op_padto3_odds_dropwhileneg([2, 4, 6]) == []\nassert op_padto3_odds_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_beforezero_dropfirst_counteven", "entry_point": "op_beforezero_dropfirst_counteven", "primitives": ["beforezero", "dropfirst", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then return how many values are even.", "solution": "def op_beforezero_dropfirst_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_dropfirst_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_dropfirst_counteven([]) == 0\nassert op_beforezero_dropfirst_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_dropfirst_counteven([5, 5, 5]) == 0\nassert op_beforezero_dropfirst_counteven([3, 1, 2]) == 1\nassert op_beforezero_dropfirst_counteven([10]) == 0\nassert op_beforezero_dropfirst_counteven([2, 4, 6]) == 2\nassert op_beforezero_dropfirst_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_double_gt5", "entry_point": "op_first3_double_gt5", "primitives": ["first3", "double", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then keep values greater than five.", "solution": "def op_first3_double_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_double_gt5([1, 2, 3, 4]) == [6]\nassert op_first3_double_gt5([]) == []\nassert op_first3_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_first3_double_gt5([3, 1, 2]) == [6]\nassert op_first3_double_gt5([10]) == [20]\nassert op_first3_double_gt5([2, 4, 6]) == [8, 12]\nassert op_first3_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_padto3_add10_odds", "entry_point": "op_padto3_add10_odds", "primitives": ["padto3", "add10", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then keep the odd numbers.", "solution": "def op_padto3_add10_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_add10_odds([1, 2, 3, 4]) == [11, 13]\nassert op_padto3_add10_odds([]) == []\nassert op_padto3_add10_odds([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_padto3_add10_odds([5, 5, 5]) == [15, 15, 15]\nassert op_padto3_add10_odds([3, 1, 2]) == [13, 11]\nassert op_padto3_add10_odds([10]) == []\nassert op_padto3_add10_odds([2, 4, 6]) == []\nassert op_padto3_add10_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_gt5_padto3_beforezero", "entry_point": "op_gt5_padto3_beforezero", "primitives": ["gt5", "padto3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then keep everything before the first zero.", "solution": "def op_gt5_padto3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_gt5_padto3_beforezero([1, 2, 3, 4]) == []\nassert op_gt5_padto3_beforezero([]) == []\nassert op_gt5_padto3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_gt5_padto3_beforezero([5, 5, 5]) == []\nassert op_gt5_padto3_beforezero([3, 1, 2]) == []\nassert op_gt5_padto3_beforezero([10]) == [10]\nassert op_gt5_padto3_beforezero([2, 4, 6]) == [6]\nassert op_gt5_padto3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_dropfirst_add10", "entry_point": "op_sortabs_dropfirst_add10", "primitives": ["sortabs", "dropfirst", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first element, then add ten to each.", "solution": "def op_sortabs_dropfirst_add10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortabs_dropfirst_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_sortabs_dropfirst_add10([]) == []\nassert op_sortabs_dropfirst_add10([-2, -1, 0, 1, 2]) == [9, 11, 8, 12]\nassert op_sortabs_dropfirst_add10([5, 5, 5]) == [15, 15]\nassert op_sortabs_dropfirst_add10([3, 1, 2]) == [12, 13]\nassert op_sortabs_dropfirst_add10([10]) == []\nassert op_sortabs_dropfirst_add10([2, 4, 6]) == [14, 16]\nassert op_sortabs_dropfirst_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropwhileneg_first3_evens", "entry_point": "op_dropwhileneg_first3_evens", "primitives": ["dropwhileneg", "first3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then keep the even numbers.", "solution": "def op_dropwhileneg_first3_evens(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropwhileneg_first3_evens([1, 2, 3, 4]) == [2]\nassert op_dropwhileneg_first3_evens([]) == []\nassert op_dropwhileneg_first3_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropwhileneg_first3_evens([5, 5, 5]) == []\nassert op_dropwhileneg_first3_evens([3, 1, 2]) == [2]\nassert op_dropwhileneg_first3_evens([10]) == [10]\nassert op_dropwhileneg_first3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_first3_evens([-7, 12, -7]) == [12]"}
{"id": "op_sorta_pos_sortd", "entry_point": "op_sorta_pos_sortd", "primitives": ["sorta", "pos", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers, then sort descending.", "solution": "def op_sorta_pos_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_pos_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_pos_sortd([]) == []\nassert op_sorta_pos_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sorta_pos_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_pos_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_pos_sortd([10]) == [10]\nassert op_sorta_pos_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_pos_sortd([-7, 12, -7]) == [12]"}
{"id": "op_trimends_rev_div3", "entry_point": "op_trimends_rev_div3", "primitives": ["trimends", "rev", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then keep multiples of three.", "solution": "def op_trimends_rev_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_rev_div3([1, 2, 3, 4]) == [3]\nassert op_trimends_rev_div3([]) == []\nassert op_trimends_rev_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_rev_div3([5, 5, 5]) == []\nassert op_trimends_rev_div3([3, 1, 2]) == []\nassert op_trimends_rev_div3([10]) == []\nassert op_trimends_rev_div3([2, 4, 6]) == []\nassert op_trimends_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_evens_first3_sum", "entry_point": "op_evens_first3_sum", "primitives": ["evens", "first3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three, then return their sum.", "solution": "def op_evens_first3_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return sum(r)", "tests": "assert op_evens_first3_sum([1, 2, 3, 4]) == 6\nassert op_evens_first3_sum([]) == 0\nassert op_evens_first3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_evens_first3_sum([5, 5, 5]) == 0\nassert op_evens_first3_sum([3, 1, 2]) == 2\nassert op_evens_first3_sum([10]) == 10\nassert op_evens_first3_sum([2, 4, 6]) == 12\nassert op_evens_first3_sum([-7, 12, -7]) == 12"}
{"id": "op_last3_dropzeros_anyeven", "entry_point": "op_last3_dropzeros_anyeven", "primitives": ["last3", "dropzeros", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then return whether any value is even.", "solution": "def op_last3_dropzeros_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_dropzeros_anyeven([1, 2, 3, 4]) == True\nassert op_last3_dropzeros_anyeven([]) == False\nassert op_last3_dropzeros_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_dropzeros_anyeven([5, 5, 5]) == False\nassert op_last3_dropzeros_anyeven([3, 1, 2]) == True\nassert op_last3_dropzeros_anyeven([10]) == True\nassert op_last3_dropzeros_anyeven([2, 4, 6]) == True\nassert op_last3_dropzeros_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortabs_evens_len", "entry_point": "op_sortabs_evens_len", "primitives": ["sortabs", "evens", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then return how many remain.", "solution": "def op_sortabs_evens_len(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_sortabs_evens_len([1, 2, 3, 4]) == 2\nassert op_sortabs_evens_len([]) == 0\nassert op_sortabs_evens_len([-2, -1, 0, 1, 2]) == 3\nassert op_sortabs_evens_len([5, 5, 5]) == 0\nassert op_sortabs_evens_len([3, 1, 2]) == 1\nassert op_sortabs_evens_len([10]) == 1\nassert op_sortabs_evens_len([2, 4, 6]) == 3\nassert op_sortabs_evens_len([-7, 12, -7]) == 1"}
{"id": "op_padto3_uniq_last3", "entry_point": "op_padto3_uniq_last3", "primitives": ["padto3", "uniq", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then keep only the last three.", "solution": "def op_padto3_uniq_last3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r", "tests": "assert op_padto3_uniq_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_uniq_last3([]) == [0]\nassert op_padto3_uniq_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_uniq_last3([5, 5, 5]) == [5]\nassert op_padto3_uniq_last3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_uniq_last3([10]) == [10, 0]\nassert op_padto3_uniq_last3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_uniq_last3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_first3_last3_div3", "entry_point": "op_first3_last3_div3", "primitives": ["first3", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then keep multiples of three.", "solution": "def op_first3_last3_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_last3_div3([1, 2, 3, 4]) == [3]\nassert op_first3_last3_div3([]) == []\nassert op_first3_last3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_last3_div3([5, 5, 5]) == []\nassert op_first3_last3_div3([3, 1, 2]) == [3]\nassert op_first3_last3_div3([10]) == []\nassert op_first3_last3_div3([2, 4, 6]) == [6]\nassert op_first3_last3_div3([-7, 12, -7]) == [12]"}
{"id": "op_names_strip_firstchar", "entry_point": "op_names_strip_firstchar", "primitives": ["names", "strip", "firstchar"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then trim whitespace from each, then keep the first character of each (dropping empties).", "solution": "def op_names_strip_firstchar(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_names_strip_firstchar([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['A', 'B']\nassert op_names_strip_firstchar([]) == []\nassert op_names_strip_firstchar([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['C', 'D', 'E']\nassert op_names_strip_firstchar([{'name': 'Fi', 'age': 41}]) == ['F']"}
{"id": "op_sortd_oremptyzero_odds", "entry_point": "op_sortd_oremptyzero_odds", "primitives": ["sortd", "oremptyzero", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then keep the odd numbers.", "solution": "def op_sortd_oremptyzero_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_oremptyzero_odds([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_oremptyzero_odds([]) == []\nassert op_sortd_oremptyzero_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_oremptyzero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_oremptyzero_odds([3, 1, 2]) == [3, 1]\nassert op_sortd_oremptyzero_odds([10]) == []\nassert op_sortd_oremptyzero_odds([2, 4, 6]) == []\nassert op_sortd_oremptyzero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_dropfirst_beforezero", "entry_point": "op_neg_dropfirst_beforezero", "primitives": ["neg", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then keep everything before the first zero.", "solution": "def op_neg_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_dropfirst_beforezero([1, 2, 3, 4]) == []\nassert op_neg_dropfirst_beforezero([]) == []\nassert op_neg_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_dropfirst_beforezero([5, 5, 5]) == []\nassert op_neg_dropfirst_beforezero([3, 1, 2]) == []\nassert op_neg_dropfirst_beforezero([10]) == []\nassert op_neg_dropfirst_beforezero([2, 4, 6]) == []\nassert op_neg_dropfirst_beforezero([-7, 12, -7]) == [-7]"}
{"id": "op_clamp10_takewhilepos_neg", "entry_point": "op_clamp10_takewhilepos_neg", "primitives": ["clamp10", "takewhilepos", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive, then keep the negative numbers.", "solution": "def op_clamp10_takewhilepos_neg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_clamp10_takewhilepos_neg([1, 2, 3, 4]) == []\nassert op_clamp10_takewhilepos_neg([]) == []\nassert op_clamp10_takewhilepos_neg([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_takewhilepos_neg([5, 5, 5]) == []\nassert op_clamp10_takewhilepos_neg([3, 1, 2]) == []\nassert op_clamp10_takewhilepos_neg([10]) == []\nassert op_clamp10_takewhilepos_neg([2, 4, 6]) == []\nassert op_clamp10_takewhilepos_neg([-7, 12, -7]) == []"}
{"id": "op_div3_uniq_issorted", "entry_point": "op_div3_uniq_issorted", "primitives": ["div3", "uniq", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_div3_uniq_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_div3_uniq_issorted([1, 2, 3, 4]) == True\nassert op_div3_uniq_issorted([]) == True\nassert op_div3_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_div3_uniq_issorted([5, 5, 5]) == True\nassert op_div3_uniq_issorted([3, 1, 2]) == True\nassert op_div3_uniq_issorted([10]) == True\nassert op_div3_uniq_issorted([2, 4, 6]) == True\nassert op_div3_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_absval_padto3_dropwhileneg", "entry_point": "op_absval_padto3_dropwhileneg", "primitives": ["absval", "padto3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_absval_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_padto3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_absval_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_padto3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_absval_padto3_dropwhileneg([10]) == [10, 0, 0]\nassert op_absval_padto3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_absval_padto3_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_gt5_pos_negate", "entry_point": "op_gt5_pos_negate", "primitives": ["gt5", "pos", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then negate each.", "solution": "def op_gt5_pos_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_pos_negate([1, 2, 3, 4]) == []\nassert op_gt5_pos_negate([]) == []\nassert op_gt5_pos_negate([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_negate([5, 5, 5]) == []\nassert op_gt5_pos_negate([3, 1, 2]) == []\nassert op_gt5_pos_negate([10]) == [-10]\nassert op_gt5_pos_negate([2, 4, 6]) == [-6]\nassert op_gt5_pos_negate([-7, 12, -7]) == [-12]"}
{"id": "op_double_inc_firsteven", "entry_point": "op_double_inc_firsteven", "primitives": ["double", "inc", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then add one to each, then return the first even value (0 if none).", "solution": "def op_double_inc_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_inc_firsteven([1, 2, 3, 4]) == 0\nassert op_double_inc_firsteven([]) == 0\nassert op_double_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_double_inc_firsteven([5, 5, 5]) == 0\nassert op_double_inc_firsteven([3, 1, 2]) == 0\nassert op_double_inc_firsteven([10]) == 0\nassert op_double_inc_firsteven([2, 4, 6]) == 0\nassert op_double_inc_firsteven([-7, 12, -7]) == 0"}
{"id": "op_square_double_sum", "entry_point": "op_square_double_sum", "primitives": ["square", "double", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then return their sum.", "solution": "def op_square_double_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return sum(r)", "tests": "assert op_square_double_sum([1, 2, 3, 4]) == 60\nassert op_square_double_sum([]) == 0\nassert op_square_double_sum([-2, -1, 0, 1, 2]) == 20\nassert op_square_double_sum([5, 5, 5]) == 150\nassert op_square_double_sum([3, 1, 2]) == 28\nassert op_square_double_sum([10]) == 200\nassert op_square_double_sum([2, 4, 6]) == 112\nassert op_square_double_sum([-7, 12, -7]) == 484"}
{"id": "op_square_sortabs_dropfirst", "entry_point": "op_square_sortabs_dropfirst", "primitives": ["square", "sortabs", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then drop the first element.", "solution": "def op_square_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_square_sortabs_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_sortabs_dropfirst([]) == []\nassert op_square_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [1, 1, 4, 4]\nassert op_square_sortabs_dropfirst([5, 5, 5]) == [25, 25]\nassert op_square_sortabs_dropfirst([3, 1, 2]) == [4, 9]\nassert op_square_sortabs_dropfirst([10]) == []\nassert op_square_sortabs_dropfirst([2, 4, 6]) == [16, 36]\nassert op_square_sortabs_dropfirst([-7, 12, -7]) == [49, 144]"}
{"id": "op_div3_double_odds", "entry_point": "op_div3_double_odds", "primitives": ["div3", "double", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then double each, then keep the odd numbers.", "solution": "def op_div3_double_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_double_odds([1, 2, 3, 4]) == []\nassert op_div3_double_odds([]) == []\nassert op_div3_double_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_double_odds([5, 5, 5]) == []\nassert op_div3_double_odds([3, 1, 2]) == []\nassert op_div3_double_odds([10]) == []\nassert op_div3_double_odds([2, 4, 6]) == []\nassert op_div3_double_odds([-7, 12, -7]) == []"}
{"id": "op_dec_double_trimends", "entry_point": "op_dec_double_trimends", "primitives": ["dec", "double", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then drop the first and last elements.", "solution": "def op_dec_double_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_double_trimends([1, 2, 3, 4]) == [2, 4]\nassert op_dec_double_trimends([]) == []\nassert op_dec_double_trimends([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_dec_double_trimends([5, 5, 5]) == [8]\nassert op_dec_double_trimends([3, 1, 2]) == [0]\nassert op_dec_double_trimends([10]) == []\nassert op_dec_double_trimends([2, 4, 6]) == [6]\nassert op_dec_double_trimends([-7, 12, -7]) == [22]"}
{"id": "op_evens_beforezero_neg", "entry_point": "op_evens_beforezero_neg", "primitives": ["evens", "beforezero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_evens_beforezero_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_beforezero_neg([1, 2, 3, 4]) == []\nassert op_evens_beforezero_neg([]) == []\nassert op_evens_beforezero_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_beforezero_neg([5, 5, 5]) == []\nassert op_evens_beforezero_neg([3, 1, 2]) == []\nassert op_evens_beforezero_neg([10]) == []\nassert op_evens_beforezero_neg([2, 4, 6]) == []\nassert op_evens_beforezero_neg([-7, 12, -7]) == []"}
{"id": "op_sorta_div3_beforezero", "entry_point": "op_sorta_div3_beforezero", "primitives": ["sorta", "div3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_sorta_div3_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_div3_beforezero([1, 2, 3, 4]) == [3]\nassert op_sorta_div3_beforezero([]) == []\nassert op_sorta_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_sorta_div3_beforezero([5, 5, 5]) == []\nassert op_sorta_div3_beforezero([3, 1, 2]) == [3]\nassert op_sorta_div3_beforezero([10]) == []\nassert op_sorta_div3_beforezero([2, 4, 6]) == [6]\nassert op_sorta_div3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_trimends_sorta_takewhilepos", "entry_point": "op_trimends_sorta_takewhilepos", "primitives": ["trimends", "sorta", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending, then take values while they are positive.", "solution": "def op_trimends_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_trimends_sorta_takewhilepos([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_sorta_takewhilepos([]) == []\nassert op_trimends_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_trimends_sorta_takewhilepos([5, 5, 5]) == [5]\nassert op_trimends_sorta_takewhilepos([3, 1, 2]) == [1]\nassert op_trimends_sorta_takewhilepos([10]) == []\nassert op_trimends_sorta_takewhilepos([2, 4, 6]) == [4]\nassert op_trimends_sorta_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortd_evens", "entry_point": "op_rev_sortd_evens", "primitives": ["rev", "sortd", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then keep the even numbers.", "solution": "def op_rev_sortd_evens(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_rev_sortd_evens([1, 2, 3, 4]) == [4, 2]\nassert op_rev_sortd_evens([]) == []\nassert op_rev_sortd_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_rev_sortd_evens([5, 5, 5]) == []\nassert op_rev_sortd_evens([3, 1, 2]) == [2]\nassert op_rev_sortd_evens([10]) == [10]\nassert op_rev_sortd_evens([2, 4, 6]) == [6, 4, 2]\nassert op_rev_sortd_evens([-7, 12, -7]) == [12]"}
{"id": "op_sortd_absval_takewhilepos", "entry_point": "op_sortd_absval_takewhilepos", "primitives": ["sortd", "absval", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then take values while they are positive.", "solution": "def op_sortd_absval_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortd_absval_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_absval_takewhilepos([]) == []\nassert op_sortd_absval_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_absval_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_absval_takewhilepos([10]) == [10]\nassert op_sortd_absval_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_absval_takewhilepos([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_beforezero_last3_prod", "entry_point": "op_beforezero_last3_prod", "primitives": ["beforezero", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then return their product.", "solution": "def op_beforezero_last3_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_last3_prod([1, 2, 3, 4]) == 24\nassert op_beforezero_last3_prod([]) == 1\nassert op_beforezero_last3_prod([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_last3_prod([5, 5, 5]) == 125\nassert op_beforezero_last3_prod([3, 1, 2]) == 6\nassert op_beforezero_last3_prod([10]) == 10\nassert op_beforezero_last3_prod([2, 4, 6]) == 48\nassert op_beforezero_last3_prod([-7, 12, -7]) == 588"}
{"id": "op_padto3_pos_square", "entry_point": "op_padto3_pos_square", "primitives": ["padto3", "pos", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then square each.", "solution": "def op_padto3_pos_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_pos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_padto3_pos_square([]) == []\nassert op_padto3_pos_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_padto3_pos_square([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_pos_square([3, 1, 2]) == [9, 1, 4]\nassert op_padto3_pos_square([10]) == [100]\nassert op_padto3_pos_square([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_takewhilepos_clamp10_haszero", "entry_point": "op_takewhilepos_clamp10_haszero", "primitives": ["takewhilepos", "clamp10", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then return whether the list contains a zero.", "solution": "def op_takewhilepos_clamp10_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_takewhilepos_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_clamp10_haszero([]) == False\nassert op_takewhilepos_clamp10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_clamp10_haszero([5, 5, 5]) == False\nassert op_takewhilepos_clamp10_haszero([3, 1, 2]) == False\nassert op_takewhilepos_clamp10_haszero([10]) == False\nassert op_takewhilepos_clamp10_haszero([2, 4, 6]) == False\nassert op_takewhilepos_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_negate_trimends_add10", "entry_point": "op_negate_trimends_add10", "primitives": ["negate", "trimends", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first and last elements, then add ten to each.", "solution": "def op_negate_trimends_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_trimends_add10([1, 2, 3, 4]) == [8, 7]\nassert op_negate_trimends_add10([]) == []\nassert op_negate_trimends_add10([-2, -1, 0, 1, 2]) == [11, 10, 9]\nassert op_negate_trimends_add10([5, 5, 5]) == [5]\nassert op_negate_trimends_add10([3, 1, 2]) == [9]\nassert op_negate_trimends_add10([10]) == []\nassert op_negate_trimends_add10([2, 4, 6]) == [6]\nassert op_negate_trimends_add10([-7, 12, -7]) == [-2]"}
{"id": "op_dropwhileneg_clamp10_double", "entry_point": "op_dropwhileneg_clamp10_double", "primitives": ["dropwhileneg", "clamp10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then double each.", "solution": "def op_dropwhileneg_clamp10_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_clamp10_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_clamp10_double([]) == []\nassert op_dropwhileneg_clamp10_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropwhileneg_clamp10_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_clamp10_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_clamp10_double([10]) == [20]\nassert op_dropwhileneg_clamp10_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_clamp10_double([-7, 12, -7]) == [20, -14]"}
{"id": "op_dropwhileneg_div3_pos", "entry_point": "op_dropwhileneg_div3_pos", "primitives": ["dropwhileneg", "div3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then keep the positive numbers.", "solution": "def op_dropwhileneg_div3_pos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropwhileneg_div3_pos([1, 2, 3, 4]) == [3]\nassert op_dropwhileneg_div3_pos([]) == []\nassert op_dropwhileneg_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_div3_pos([5, 5, 5]) == []\nassert op_dropwhileneg_div3_pos([3, 1, 2]) == [3]\nassert op_dropwhileneg_div3_pos([10]) == []\nassert op_dropwhileneg_div3_pos([2, 4, 6]) == [6]\nassert op_dropwhileneg_div3_pos([-7, 12, -7]) == [12]"}
{"id": "op_odds_square_max", "entry_point": "op_odds_square_max", "primitives": ["odds", "square", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then return the maximum (0 if empty).", "solution": "def op_odds_square_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_odds_square_max([1, 2, 3, 4]) == 9\nassert op_odds_square_max([]) == 0\nassert op_odds_square_max([-2, -1, 0, 1, 2]) == 1\nassert op_odds_square_max([5, 5, 5]) == 25\nassert op_odds_square_max([3, 1, 2]) == 9\nassert op_odds_square_max([10]) == 0\nassert op_odds_square_max([2, 4, 6]) == 0\nassert op_odds_square_max([-7, 12, -7]) == 49"}
{"id": "op_dropwhileneg_last3_padto3", "entry_point": "op_dropwhileneg_last3_padto3", "primitives": ["dropwhileneg", "last3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_dropwhileneg_last3_padto3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropwhileneg_last3_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_last3_padto3([]) == [0, 0, 0]\nassert op_dropwhileneg_last3_padto3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_last3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_last3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_last3_padto3([10]) == [10, 0, 0]\nassert op_dropwhileneg_last3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_last3_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_beforezero_first3_negate", "entry_point": "op_beforezero_first3_negate", "primitives": ["beforezero", "first3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then negate each.", "solution": "def op_beforezero_first3_negate(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_beforezero_first3_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_beforezero_first3_negate([]) == []\nassert op_beforezero_first3_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_first3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_beforezero_first3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_beforezero_first3_negate([10]) == [-10]\nassert op_beforezero_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_beforezero_first3_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_square_div3_takewhilepos", "entry_point": "op_square_div3_takewhilepos", "primitives": ["square", "div3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then take values while they are positive.", "solution": "def op_square_div3_takewhilepos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_square_div3_takewhilepos([1, 2, 3, 4]) == [9]\nassert op_square_div3_takewhilepos([]) == []\nassert op_square_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_square_div3_takewhilepos([5, 5, 5]) == []\nassert op_square_div3_takewhilepos([3, 1, 2]) == [9]\nassert op_square_div3_takewhilepos([10]) == []\nassert op_square_div3_takewhilepos([2, 4, 6]) == [36]\nassert op_square_div3_takewhilepos([-7, 12, -7]) == [144]"}
{"id": "op_gt5_clamp10_firsteven", "entry_point": "op_gt5_clamp10_firsteven", "primitives": ["gt5", "clamp10", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_gt5_clamp10_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_gt5_clamp10_firsteven([1, 2, 3, 4]) == 0\nassert op_gt5_clamp10_firsteven([]) == 0\nassert op_gt5_clamp10_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_clamp10_firsteven([5, 5, 5]) == 0\nassert op_gt5_clamp10_firsteven([3, 1, 2]) == 0\nassert op_gt5_clamp10_firsteven([10]) == 10\nassert op_gt5_clamp10_firsteven([2, 4, 6]) == 6\nassert op_gt5_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_first3_pos_min", "entry_point": "op_first3_pos_min", "primitives": ["first3", "pos", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then return the minimum (0 if empty).", "solution": "def op_first3_pos_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return min(r) if r else 0", "tests": "assert op_first3_pos_min([1, 2, 3, 4]) == 1\nassert op_first3_pos_min([]) == 0\nassert op_first3_pos_min([-2, -1, 0, 1, 2]) == 0\nassert op_first3_pos_min([5, 5, 5]) == 5\nassert op_first3_pos_min([3, 1, 2]) == 1\nassert op_first3_pos_min([10]) == 10\nassert op_first3_pos_min([2, 4, 6]) == 2\nassert op_first3_pos_min([-7, 12, -7]) == 12"}
{"id": "op_lower_nonempty_sortlen", "entry_point": "op_lower_nonempty_sortlen", "primitives": ["lower", "nonempty", "sortlen"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop empty strings, then sort by length, shortest first.", "solution": "def op_lower_nonempty_sortlen(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if s]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_lower_nonempty_sortlen(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_nonempty_sortlen([]) == []\nassert op_lower_nonempty_sortlen(['  a ', '', 'BC', 'bc']) == ['bc', 'bc', '  a ']\nassert op_lower_nonempty_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_nonempty_sortlen(['x']) == ['x']\nassert op_lower_nonempty_sortlen(['abc', 'de', '']) == ['de', 'abc']"}
{"id": "op_absval_add10_negate", "entry_point": "op_absval_add10_negate", "primitives": ["absval", "add10", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then negate each.", "solution": "def op_absval_add10_negate(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_absval_add10_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_absval_add10_negate([]) == []\nassert op_absval_add10_negate([-2, -1, 0, 1, 2]) == [-12, -11, -10, -11, -12]\nassert op_absval_add10_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_absval_add10_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_absval_add10_negate([10]) == [-20]\nassert op_absval_add10_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_absval_add10_negate([-7, 12, -7]) == [-17, -22, -17]"}
{"id": "op_dropfirst_add10_padto3", "entry_point": "op_dropfirst_add10_padto3", "primitives": ["dropfirst", "add10", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_add10_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_add10_padto3([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_add10_padto3([]) == [0, 0, 0]\nassert op_dropfirst_add10_padto3([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_dropfirst_add10_padto3([5, 5, 5]) == [15, 15, 0]\nassert op_dropfirst_add10_padto3([3, 1, 2]) == [11, 12, 0]\nassert op_dropfirst_add10_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_add10_padto3([2, 4, 6]) == [14, 16, 0]\nassert op_dropfirst_add10_padto3([-7, 12, -7]) == [22, 3, 0]"}
{"id": "op_beforezero_div3_takewhilepos", "entry_point": "op_beforezero_div3_takewhilepos", "primitives": ["beforezero", "div3", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep multiples of three, then take values while they are positive.", "solution": "def op_beforezero_div3_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_div3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_beforezero_div3_takewhilepos([]) == []\nassert op_beforezero_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_div3_takewhilepos([5, 5, 5]) == []\nassert op_beforezero_div3_takewhilepos([3, 1, 2]) == [3]\nassert op_beforezero_div3_takewhilepos([10]) == []\nassert op_beforezero_div3_takewhilepos([2, 4, 6]) == [6]\nassert op_beforezero_div3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_takewhilepos_prod", "entry_point": "op_beforezero_takewhilepos_prod", "primitives": ["beforezero", "takewhilepos", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then return their product.", "solution": "def op_beforezero_takewhilepos_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_takewhilepos_prod([1, 2, 3, 4]) == 24\nassert op_beforezero_takewhilepos_prod([]) == 1\nassert op_beforezero_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_takewhilepos_prod([5, 5, 5]) == 125\nassert op_beforezero_takewhilepos_prod([3, 1, 2]) == 6\nassert op_beforezero_takewhilepos_prod([10]) == 10\nassert op_beforezero_takewhilepos_prod([2, 4, 6]) == 48\nassert op_beforezero_takewhilepos_prod([-7, 12, -7]) == 1"}
{"id": "op_clamp10_dec_gt5", "entry_point": "op_clamp10_dec_gt5", "primitives": ["clamp10", "dec", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then keep values greater than five.", "solution": "def op_clamp10_dec_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_dec_gt5([1, 2, 3, 4]) == []\nassert op_clamp10_dec_gt5([]) == []\nassert op_clamp10_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_dec_gt5([5, 5, 5]) == []\nassert op_clamp10_dec_gt5([3, 1, 2]) == []\nassert op_clamp10_dec_gt5([10]) == [9]\nassert op_clamp10_dec_gt5([2, 4, 6]) == []\nassert op_clamp10_dec_gt5([-7, 12, -7]) == [9]"}
{"id": "op_dropzeros_first3_padto3", "entry_point": "op_dropzeros_first3_padto3", "primitives": ["dropzeros", "first3", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_dropzeros_first3_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropzeros_first3_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_first3_padto3([]) == [0, 0, 0]\nassert op_dropzeros_first3_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 1]\nassert op_dropzeros_first3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_first3_padto3([10]) == [10, 0, 0]\nassert op_dropzeros_first3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_first3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_gt5_trimends_pos", "entry_point": "op_gt5_trimends_pos", "primitives": ["gt5", "trimends", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then keep the positive numbers.", "solution": "def op_gt5_trimends_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_trimends_pos([1, 2, 3, 4]) == []\nassert op_gt5_trimends_pos([]) == []\nassert op_gt5_trimends_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_pos([5, 5, 5]) == []\nassert op_gt5_trimends_pos([3, 1, 2]) == []\nassert op_gt5_trimends_pos([10]) == []\nassert op_gt5_trimends_pos([2, 4, 6]) == []\nassert op_gt5_trimends_pos([-7, 12, -7]) == []"}
{"id": "op_inc_gt5_div3", "entry_point": "op_inc_gt5_div3", "primitives": ["inc", "gt5", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then keep multiples of three.", "solution": "def op_inc_gt5_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_gt5_div3([1, 2, 3, 4]) == []\nassert op_inc_gt5_div3([]) == []\nassert op_inc_gt5_div3([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5_div3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_gt5_div3([3, 1, 2]) == []\nassert op_inc_gt5_div3([10]) == []\nassert op_inc_gt5_div3([2, 4, 6]) == []\nassert op_inc_gt5_div3([-7, 12, -7]) == []"}
{"id": "op_dropzeros_last3_gt5", "entry_point": "op_dropzeros_last3_gt5", "primitives": ["dropzeros", "last3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then keep values greater than five.", "solution": "def op_dropzeros_last3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropzeros_last3_gt5([1, 2, 3, 4]) == []\nassert op_dropzeros_last3_gt5([]) == []\nassert op_dropzeros_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_last3_gt5([5, 5, 5]) == []\nassert op_dropzeros_last3_gt5([3, 1, 2]) == []\nassert op_dropzeros_last3_gt5([10]) == [10]\nassert op_dropzeros_last3_gt5([2, 4, 6]) == [6]\nassert op_dropzeros_last3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_neg_trimends_div3", "entry_point": "op_neg_trimends_div3", "primitives": ["neg", "trimends", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then keep multiples of three.", "solution": "def op_neg_trimends_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_neg_trimends_div3([1, 2, 3, 4]) == []\nassert op_neg_trimends_div3([]) == []\nassert op_neg_trimends_div3([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_div3([5, 5, 5]) == []\nassert op_neg_trimends_div3([3, 1, 2]) == []\nassert op_neg_trimends_div3([10]) == []\nassert op_neg_trimends_div3([2, 4, 6]) == []\nassert op_neg_trimends_div3([-7, 12, -7]) == []"}
{"id": "op_inc_dec_min", "entry_point": "op_inc_dec_min", "primitives": ["inc", "dec", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_inc_dec_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_inc_dec_min([1, 2, 3, 4]) == 1\nassert op_inc_dec_min([]) == 0\nassert op_inc_dec_min([-2, -1, 0, 1, 2]) == -2\nassert op_inc_dec_min([5, 5, 5]) == 5\nassert op_inc_dec_min([3, 1, 2]) == 1\nassert op_inc_dec_min([10]) == 10\nassert op_inc_dec_min([2, 4, 6]) == 2\nassert op_inc_dec_min([-7, 12, -7]) == -7"}
{"id": "op_ages_rev_sorta", "entry_point": "op_ages_rev_sorta", "primitives": ["ages", "rev", "sorta"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then sort ascending.", "solution": "def op_ages_rev_sorta(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = sorted(r)\n    return r", "tests": "assert op_ages_rev_sorta([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_rev_sorta([]) == []\nassert op_ages_rev_sorta([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 18, 65]\nassert op_ages_rev_sorta([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropzeros_sorta_trimends", "entry_point": "op_dropzeros_sorta_trimends", "primitives": ["dropzeros", "sorta", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then drop the first and last elements.", "solution": "def op_dropzeros_sorta_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_dropzeros_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_dropzeros_sorta_trimends([]) == []\nassert op_dropzeros_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_sorta_trimends([5, 5, 5]) == [5]\nassert op_dropzeros_sorta_trimends([3, 1, 2]) == [2]\nassert op_dropzeros_sorta_trimends([10]) == []\nassert op_dropzeros_sorta_trimends([2, 4, 6]) == [4]\nassert op_dropzeros_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_inc_uniq_pos", "entry_point": "op_inc_uniq_pos", "primitives": ["inc", "uniq", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then keep the positive numbers.", "solution": "def op_inc_uniq_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_uniq_pos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_uniq_pos([]) == []\nassert op_inc_uniq_pos([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_uniq_pos([5, 5, 5]) == [6]\nassert op_inc_uniq_pos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_uniq_pos([10]) == [11]\nassert op_inc_uniq_pos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_uniq_pos([-7, 12, -7]) == [13]"}
{"id": "op_div3_takewhilepos_oremptyzero", "entry_point": "op_div3_takewhilepos_oremptyzero", "primitives": ["div3", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_div3_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_div3_takewhilepos_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos_oremptyzero([]) == [0]\nassert op_div3_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_takewhilepos_oremptyzero([5, 5, 5]) == [0]\nassert op_div3_takewhilepos_oremptyzero([3, 1, 2]) == [3]\nassert op_div3_takewhilepos_oremptyzero([10]) == [0]\nassert op_div3_takewhilepos_oremptyzero([2, 4, 6]) == [6]\nassert op_div3_takewhilepos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_square_dropfirst_clamp10", "entry_point": "op_square_dropfirst_clamp10", "primitives": ["square", "dropfirst", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then cap each value at 10.", "solution": "def op_square_dropfirst_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_dropfirst_clamp10([1, 2, 3, 4]) == [4, 9, 10]\nassert op_square_dropfirst_clamp10([]) == []\nassert op_square_dropfirst_clamp10([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_square_dropfirst_clamp10([5, 5, 5]) == [10, 10]\nassert op_square_dropfirst_clamp10([3, 1, 2]) == [1, 4]\nassert op_square_dropfirst_clamp10([10]) == []\nassert op_square_dropfirst_clamp10([2, 4, 6]) == [10, 10]\nassert op_square_dropfirst_clamp10([-7, 12, -7]) == [10, 10]"}
{"id": "op_trimends_odds_allpos", "entry_point": "op_trimends_odds_allpos", "primitives": ["trimends", "odds", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_trimends_odds_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_odds_allpos([1, 2, 3, 4]) == True\nassert op_trimends_odds_allpos([]) == True\nassert op_trimends_odds_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_odds_allpos([5, 5, 5]) == True\nassert op_trimends_odds_allpos([3, 1, 2]) == True\nassert op_trimends_odds_allpos([10]) == True\nassert op_trimends_odds_allpos([2, 4, 6]) == True\nassert op_trimends_odds_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_square_sorta", "entry_point": "op_takewhilepos_square_sorta", "primitives": ["takewhilepos", "square", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then sort ascending.", "solution": "def op_takewhilepos_square_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_square_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_square_sorta([]) == []\nassert op_takewhilepos_square_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_takewhilepos_square_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_takewhilepos_square_sorta([10]) == [100]\nassert op_takewhilepos_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_square_sorta([-7, 12, -7]) == []"}
{"id": "op_odds_first3_evens", "entry_point": "op_odds_first3_evens", "primitives": ["odds", "first3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the first three, then keep the even numbers.", "solution": "def op_odds_first3_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_odds_first3_evens([1, 2, 3, 4]) == []\nassert op_odds_first3_evens([]) == []\nassert op_odds_first3_evens([-2, -1, 0, 1, 2]) == []\nassert op_odds_first3_evens([5, 5, 5]) == []\nassert op_odds_first3_evens([3, 1, 2]) == []\nassert op_odds_first3_evens([10]) == []\nassert op_odds_first3_evens([2, 4, 6]) == []\nassert op_odds_first3_evens([-7, 12, -7]) == []"}
{"id": "op_double_rev_odds", "entry_point": "op_double_rev_odds", "primitives": ["double", "rev", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then keep the odd numbers.", "solution": "def op_double_rev_odds(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_double_rev_odds([1, 2, 3, 4]) == []\nassert op_double_rev_odds([]) == []\nassert op_double_rev_odds([-2, -1, 0, 1, 2]) == []\nassert op_double_rev_odds([5, 5, 5]) == []\nassert op_double_rev_odds([3, 1, 2]) == []\nassert op_double_rev_odds([10]) == []\nassert op_double_rev_odds([2, 4, 6]) == []\nassert op_double_rev_odds([-7, 12, -7]) == []"}
{"id": "op_first3_padto3_rev", "entry_point": "op_first3_padto3_rev", "primitives": ["first3", "padto3", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_first3_padto3_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_padto3_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_padto3_rev([]) == [0, 0, 0]\nassert op_first3_padto3_rev([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_padto3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_first3_padto3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_first3_padto3_rev([10]) == [0, 0, 10]\nassert op_first3_padto3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_first3_padto3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_last3_beforezero_pos", "entry_point": "op_last3_beforezero_pos", "primitives": ["last3", "beforezero", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_last3_beforezero_pos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_last3_beforezero_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_beforezero_pos([]) == []\nassert op_last3_beforezero_pos([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_last3_beforezero_pos([10]) == [10]\nassert op_last3_beforezero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_evens_padto3", "entry_point": "op_clamp10_evens_padto3", "primitives": ["clamp10", "evens", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_clamp10_evens_padto3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_clamp10_evens_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_clamp10_evens_padto3([]) == [0, 0, 0]\nassert op_clamp10_evens_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_clamp10_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_clamp10_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_clamp10_evens_padto3([10]) == [10, 0, 0]\nassert op_clamp10_evens_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_evens_padto3([-7, 12, -7]) == [10, 0, 0]"}
{"id": "op_dropzeros_gt5_clamp10", "entry_point": "op_dropzeros_gt5_clamp10", "primitives": ["dropzeros", "gt5", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep values greater than five, then cap each value at 10.", "solution": "def op_dropzeros_gt5_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_gt5_clamp10([1, 2, 3, 4]) == []\nassert op_dropzeros_gt5_clamp10([]) == []\nassert op_dropzeros_gt5_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_gt5_clamp10([5, 5, 5]) == []\nassert op_dropzeros_gt5_clamp10([3, 1, 2]) == []\nassert op_dropzeros_gt5_clamp10([10]) == [10]\nassert op_dropzeros_gt5_clamp10([2, 4, 6]) == [6]\nassert op_dropzeros_gt5_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_negate_square_min", "entry_point": "op_negate_square_min", "primitives": ["negate", "square", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then return the minimum (0 if empty).", "solution": "def op_negate_square_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return min(r) if r else 0", "tests": "assert op_negate_square_min([1, 2, 3, 4]) == 1\nassert op_negate_square_min([]) == 0\nassert op_negate_square_min([-2, -1, 0, 1, 2]) == 0\nassert op_negate_square_min([5, 5, 5]) == 25\nassert op_negate_square_min([3, 1, 2]) == 1\nassert op_negate_square_min([10]) == 100\nassert op_negate_square_min([2, 4, 6]) == 4\nassert op_negate_square_min([-7, 12, -7]) == 49"}
{"id": "op_takewhilepos_rev_div3", "entry_point": "op_takewhilepos_rev_div3", "primitives": ["takewhilepos", "rev", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then reverse the order, then keep multiples of three.", "solution": "def op_takewhilepos_rev_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_rev_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_rev_div3([]) == []\nassert op_takewhilepos_rev_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_rev_div3([5, 5, 5]) == []\nassert op_takewhilepos_rev_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_rev_div3([10]) == []\nassert op_takewhilepos_rev_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_rev_div3([-7, 12, -7]) == []"}
{"id": "op_last3_gt5_uniq", "entry_point": "op_last3_gt5_uniq", "primitives": ["last3", "gt5", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep values greater than five, then drop duplicates keeping first occurrence.", "solution": "def op_last3_gt5_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_gt5_uniq([1, 2, 3, 4]) == []\nassert op_last3_gt5_uniq([]) == []\nassert op_last3_gt5_uniq([-2, -1, 0, 1, 2]) == []\nassert op_last3_gt5_uniq([5, 5, 5]) == []\nassert op_last3_gt5_uniq([3, 1, 2]) == []\nassert op_last3_gt5_uniq([10]) == [10]\nassert op_last3_gt5_uniq([2, 4, 6]) == [6]\nassert op_last3_gt5_uniq([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_double_dropfirst", "entry_point": "op_clamp10_double_dropfirst", "primitives": ["clamp10", "double", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then drop the first element.", "solution": "def op_clamp10_double_dropfirst(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_clamp10_double_dropfirst([1, 2, 3, 4]) == [4, 6, 8]\nassert op_clamp10_double_dropfirst([]) == []\nassert op_clamp10_double_dropfirst([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_clamp10_double_dropfirst([5, 5, 5]) == [10, 10]\nassert op_clamp10_double_dropfirst([3, 1, 2]) == [2, 4]\nassert op_clamp10_double_dropfirst([10]) == []\nassert op_clamp10_double_dropfirst([2, 4, 6]) == [8, 12]\nassert op_clamp10_double_dropfirst([-7, 12, -7]) == [20, -14]"}
{"id": "op_first3_sortabs_firsteven", "entry_point": "op_first3_sortabs_firsteven", "primitives": ["first3", "sortabs", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_first3_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_first3_sortabs_firsteven([]) == 0\nassert op_first3_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_first3_sortabs_firsteven([5, 5, 5]) == 0\nassert op_first3_sortabs_firsteven([3, 1, 2]) == 2\nassert op_first3_sortabs_firsteven([10]) == 10\nassert op_first3_sortabs_firsteven([2, 4, 6]) == 2\nassert op_first3_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_inc_oremptyzero", "entry_point": "op_dropzeros_inc_oremptyzero", "primitives": ["dropzeros", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then if empty, use a single zero.", "solution": "def op_dropzeros_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_inc_oremptyzero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_dropzeros_inc_oremptyzero([]) == [0]\nassert op_dropzeros_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 2, 3]\nassert op_dropzeros_inc_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_dropzeros_inc_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_dropzeros_inc_oremptyzero([10]) == [11]\nassert op_dropzeros_inc_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_dropzeros_inc_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_dropzeros_sortd_sortabs", "entry_point": "op_dropzeros_sortd_sortabs", "primitives": ["dropzeros", "sortd", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending, then sort by absolute value.", "solution": "def op_dropzeros_sortd_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_sortd_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_sortd_sortabs([]) == []\nassert op_dropzeros_sortd_sortabs([-2, -1, 0, 1, 2]) == [1, -1, 2, -2]\nassert op_dropzeros_sortd_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sortd_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dropzeros_sortd_sortabs([10]) == [10]\nassert op_dropzeros_sortd_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_sortd_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_gt5_sorta", "entry_point": "op_sortabs_gt5_sorta", "primitives": ["sortabs", "gt5", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then sort ascending.", "solution": "def op_sortabs_gt5_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_gt5_sorta([1, 2, 3, 4]) == []\nassert op_sortabs_gt5_sorta([]) == []\nassert op_sortabs_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_gt5_sorta([5, 5, 5]) == []\nassert op_sortabs_gt5_sorta([3, 1, 2]) == []\nassert op_sortabs_gt5_sorta([10]) == [10]\nassert op_sortabs_gt5_sorta([2, 4, 6]) == [6]\nassert op_sortabs_gt5_sorta([-7, 12, -7]) == [12]"}
{"id": "op_div3_clamp10_last3", "entry_point": "op_div3_clamp10_last3", "primitives": ["div3", "clamp10", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then keep only the last three.", "solution": "def op_div3_clamp10_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_clamp10_last3([1, 2, 3, 4]) == [3]\nassert op_div3_clamp10_last3([]) == []\nassert op_div3_clamp10_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_clamp10_last3([5, 5, 5]) == []\nassert op_div3_clamp10_last3([3, 1, 2]) == [3]\nassert op_div3_clamp10_last3([10]) == []\nassert op_div3_clamp10_last3([2, 4, 6]) == [6]\nassert op_div3_clamp10_last3([-7, 12, -7]) == [10]"}
{"id": "op_uniq_add10_dropzeros", "entry_point": "op_uniq_add10_dropzeros", "primitives": ["uniq", "add10", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then drop the zeros.", "solution": "def op_uniq_add10_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_add10_dropzeros([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_add10_dropzeros([]) == []\nassert op_uniq_add10_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_uniq_add10_dropzeros([5, 5, 5]) == [15]\nassert op_uniq_add10_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_add10_dropzeros([10]) == [20]\nassert op_uniq_add10_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_add10_dropzeros([-7, 12, -7]) == [3, 22]"}
{"id": "op_negate_sortd_double", "entry_point": "op_negate_sortd_double", "primitives": ["negate", "sortd", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending, then double each.", "solution": "def op_negate_sortd_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_sortd_double([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_negate_sortd_double([]) == []\nassert op_negate_sortd_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_negate_sortd_double([5, 5, 5]) == [-10, -10, -10]\nassert op_negate_sortd_double([3, 1, 2]) == [-2, -4, -6]\nassert op_negate_sortd_double([10]) == [-20]\nassert op_negate_sortd_double([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_sortd_double([-7, 12, -7]) == [14, 14, -24]"}
{"id": "op_oremptyzero_odds_sortd", "entry_point": "op_oremptyzero_odds_sortd", "primitives": ["oremptyzero", "odds", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then sort descending.", "solution": "def op_oremptyzero_odds_sortd(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_oremptyzero_odds_sortd([1, 2, 3, 4]) == [3, 1]\nassert op_oremptyzero_odds_sortd([]) == []\nassert op_oremptyzero_odds_sortd([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_oremptyzero_odds_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_odds_sortd([3, 1, 2]) == [3, 1]\nassert op_oremptyzero_odds_sortd([10]) == []\nassert op_oremptyzero_odds_sortd([2, 4, 6]) == []\nassert op_oremptyzero_odds_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropzeros_sorta_sortd", "entry_point": "op_dropzeros_sorta_sortd", "primitives": ["dropzeros", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort ascending, then sort descending.", "solution": "def op_dropzeros_sorta_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropzeros_sorta_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_dropzeros_sorta_sortd([]) == []\nassert op_dropzeros_sorta_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_dropzeros_sorta_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_sorta_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_dropzeros_sorta_sortd([10]) == [10]\nassert op_dropzeros_sorta_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_sorta_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_odds_div3_gt5", "entry_point": "op_odds_div3_gt5", "primitives": ["odds", "div3", "gt5"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then keep values greater than five.", "solution": "def op_odds_div3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_div3_gt5([1, 2, 3, 4]) == []\nassert op_odds_div3_gt5([]) == []\nassert op_odds_div3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_gt5([5, 5, 5]) == []\nassert op_odds_div3_gt5([3, 1, 2]) == []\nassert op_odds_div3_gt5([10]) == []\nassert op_odds_div3_gt5([2, 4, 6]) == []\nassert op_odds_div3_gt5([-7, 12, -7]) == []"}
{"id": "op_inc_dec_clamp10", "entry_point": "op_inc_dec_clamp10", "primitives": ["inc", "dec", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then cap each value at 10.", "solution": "def op_inc_dec_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_dec_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_dec_clamp10([]) == []\nassert op_inc_dec_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_dec_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_inc_dec_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_inc_dec_clamp10([10]) == [10]\nassert op_inc_dec_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_inc_dec_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_takewhilepos_last3_negate", "entry_point": "op_takewhilepos_last3_negate", "primitives": ["takewhilepos", "last3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then negate each.", "solution": "def op_takewhilepos_last3_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_last3_negate([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_takewhilepos_last3_negate([]) == []\nassert op_takewhilepos_last3_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_last3_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_takewhilepos_last3_negate([10]) == [-10]\nassert op_takewhilepos_last3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_last3_negate([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_neg_takewhilepos", "entry_point": "op_dropwhileneg_neg_takewhilepos", "primitives": ["dropwhileneg", "neg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then take values while they are positive.", "solution": "def op_dropwhileneg_neg_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg_takewhilepos([]) == []\nassert op_dropwhileneg_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg_takewhilepos([5, 5, 5]) == []\nassert op_dropwhileneg_neg_takewhilepos([3, 1, 2]) == []\nassert op_dropwhileneg_neg_takewhilepos([10]) == []\nassert op_dropwhileneg_neg_takewhilepos([2, 4, 6]) == []\nassert op_dropwhileneg_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_odds_dropfirst_sum", "entry_point": "op_odds_dropfirst_sum", "primitives": ["odds", "dropfirst", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element, then return their sum.", "solution": "def op_odds_dropfirst_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return sum(r)", "tests": "assert op_odds_dropfirst_sum([1, 2, 3, 4]) == 3\nassert op_odds_dropfirst_sum([]) == 0\nassert op_odds_dropfirst_sum([-2, -1, 0, 1, 2]) == 1\nassert op_odds_dropfirst_sum([5, 5, 5]) == 10\nassert op_odds_dropfirst_sum([3, 1, 2]) == 1\nassert op_odds_dropfirst_sum([10]) == 0\nassert op_odds_dropfirst_sum([2, 4, 6]) == 0\nassert op_odds_dropfirst_sum([-7, 12, -7]) == -7"}
{"id": "op_padto3_div3_dropwhileneg", "entry_point": "op_padto3_div3_dropwhileneg", "primitives": ["padto3", "div3", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep multiples of three, then drop the leading negative values.", "solution": "def op_padto3_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_div3_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_padto3_div3_dropwhileneg([]) == [0, 0, 0]\nassert op_padto3_div3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_div3_dropwhileneg([5, 5, 5]) == []\nassert op_padto3_div3_dropwhileneg([3, 1, 2]) == [3]\nassert op_padto3_div3_dropwhileneg([10]) == [0, 0]\nassert op_padto3_div3_dropwhileneg([2, 4, 6]) == [6]\nassert op_padto3_div3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_ages_beforezero_rev", "entry_point": "op_ages_beforezero_rev", "primitives": ["ages", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then reverse the order.", "solution": "def op_ages_beforezero_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_beforezero_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_beforezero_rev([]) == []\nassert op_ages_beforezero_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_beforezero_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_oremptyzero_dropzeros_odds", "entry_point": "op_oremptyzero_dropzeros_odds", "primitives": ["oremptyzero", "dropzeros", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then keep the odd numbers.", "solution": "def op_oremptyzero_dropzeros_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_dropzeros_odds([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_dropzeros_odds([]) == []\nassert op_oremptyzero_dropzeros_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_dropzeros_odds([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropzeros_odds([3, 1, 2]) == [3, 1]\nassert op_oremptyzero_dropzeros_odds([10]) == []\nassert op_oremptyzero_dropzeros_odds([2, 4, 6]) == []\nassert op_oremptyzero_dropzeros_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sorta_sortabs_beforezero", "entry_point": "op_sorta_sortabs_beforezero", "primitives": ["sorta", "sortabs", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_sorta_sortabs_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_sortabs_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_sortabs_beforezero([]) == []\nassert op_sorta_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_sorta_sortabs_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortabs_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_sortabs_beforezero([10]) == [10]\nassert op_sorta_sortabs_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_sortabs_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_oremptyzero_neg_takewhilepos", "entry_point": "op_oremptyzero_neg_takewhilepos", "primitives": ["oremptyzero", "neg", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then take values while they are positive.", "solution": "def op_oremptyzero_neg_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg_takewhilepos([]) == []\nassert op_oremptyzero_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_neg_takewhilepos([5, 5, 5]) == []\nassert op_oremptyzero_neg_takewhilepos([3, 1, 2]) == []\nassert op_oremptyzero_neg_takewhilepos([10]) == []\nassert op_oremptyzero_neg_takewhilepos([2, 4, 6]) == []\nassert op_oremptyzero_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_beforezero_evens_sortd", "entry_point": "op_beforezero_evens_sortd", "primitives": ["beforezero", "evens", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then sort descending.", "solution": "def op_beforezero_evens_sortd(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_beforezero_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_beforezero_evens_sortd([]) == []\nassert op_beforezero_evens_sortd([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_evens_sortd([5, 5, 5]) == []\nassert op_beforezero_evens_sortd([3, 1, 2]) == [2]\nassert op_beforezero_evens_sortd([10]) == [10]\nassert op_beforezero_evens_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_evens_sortd([-7, 12, -7]) == [12]"}
{"id": "op_uniq_beforezero_takewhilepos", "entry_point": "op_uniq_beforezero_takewhilepos", "primitives": ["uniq", "beforezero", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_uniq_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_beforezero_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_beforezero_takewhilepos([]) == []\nassert op_uniq_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_beforezero_takewhilepos([5, 5, 5]) == [5]\nassert op_uniq_beforezero_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_beforezero_takewhilepos([10]) == [10]\nassert op_uniq_beforezero_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropzeros_dropfirst_absval", "entry_point": "op_dropzeros_dropfirst_absval", "primitives": ["dropzeros", "dropfirst", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then take the absolute value of each.", "solution": "def op_dropzeros_dropfirst_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropzeros_dropfirst_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropfirst_absval([]) == []\nassert op_dropzeros_dropfirst_absval([-2, -1, 0, 1, 2]) == [1, 1, 2]\nassert op_dropzeros_dropfirst_absval([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropfirst_absval([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst_absval([10]) == []\nassert op_dropzeros_dropfirst_absval([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropfirst_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_uniq_dropfirst_sortd", "entry_point": "op_uniq_dropfirst_sortd", "primitives": ["uniq", "dropfirst", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then sort descending.", "solution": "def op_uniq_dropfirst_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_dropfirst_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_uniq_dropfirst_sortd([]) == []\nassert op_uniq_dropfirst_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_uniq_dropfirst_sortd([5, 5, 5]) == []\nassert op_uniq_dropfirst_sortd([3, 1, 2]) == [2, 1]\nassert op_uniq_dropfirst_sortd([10]) == []\nassert op_uniq_dropfirst_sortd([2, 4, 6]) == [6, 4]\nassert op_uniq_dropfirst_sortd([-7, 12, -7]) == [12]"}
{"id": "op_ages_clamp10_padto3", "entry_point": "op_ages_clamp10_padto3", "primitives": ["ages", "clamp10", "padto3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_ages_clamp10_padto3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_ages_clamp10_padto3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10, 0]\nassert op_ages_clamp10_padto3([]) == [0, 0, 0]\nassert op_ages_clamp10_padto3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10_padto3([{'name': 'Fi', 'age': 41}]) == [10, 0, 0]"}
{"id": "op_absval_sortd_sortabs", "entry_point": "op_absval_sortd_sortabs", "primitives": ["absval", "sortd", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then sort by absolute value.", "solution": "def op_absval_sortd_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_sortd_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_sortd_sortabs([]) == []\nassert op_absval_sortd_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_absval_sortd_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortd_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortd_sortabs([10]) == [10]\nassert op_absval_sortd_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortd_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_sortabs_double_evens", "entry_point": "op_sortabs_double_evens", "primitives": ["sortabs", "double", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then keep the even numbers.", "solution": "def op_sortabs_double_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_double_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_double_evens([]) == []\nassert op_sortabs_double_evens([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_sortabs_double_evens([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double_evens([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_double_evens([10]) == [20]\nassert op_sortabs_double_evens([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_double_evens([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_last3_padto3_firsteven", "entry_point": "op_last3_padto3_firsteven", "primitives": ["last3", "padto3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then return the first even value (0 if none).", "solution": "def op_last3_padto3_firsteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_last3_padto3_firsteven([1, 2, 3, 4]) == 2\nassert op_last3_padto3_firsteven([]) == 0\nassert op_last3_padto3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_last3_padto3_firsteven([5, 5, 5]) == 0\nassert op_last3_padto3_firsteven([3, 1, 2]) == 2\nassert op_last3_padto3_firsteven([10]) == 10\nassert op_last3_padto3_firsteven([2, 4, 6]) == 2\nassert op_last3_padto3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_square_sortd", "entry_point": "op_dropwhileneg_square_sortd", "primitives": ["dropwhileneg", "square", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then sort descending.", "solution": "def op_dropwhileneg_square_sortd(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropwhileneg_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_dropwhileneg_square_sortd([]) == []\nassert op_dropwhileneg_square_sortd([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_dropwhileneg_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_dropwhileneg_square_sortd([10]) == [100]\nassert op_dropwhileneg_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_dropwhileneg_square_sortd([-7, 12, -7]) == [144, 49]"}
{"id": "op_uniq_beforezero_first3", "entry_point": "op_uniq_beforezero_first3", "primitives": ["uniq", "beforezero", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then keep only the first three.", "solution": "def op_uniq_beforezero_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return r", "tests": "assert op_uniq_beforezero_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_uniq_beforezero_first3([]) == []\nassert op_uniq_beforezero_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_beforezero_first3([5, 5, 5]) == [5]\nassert op_uniq_beforezero_first3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_beforezero_first3([10]) == [10]\nassert op_uniq_beforezero_first3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_beforezero_first3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropfirst_sortabs_sum", "entry_point": "op_dropfirst_sortabs_sum", "primitives": ["dropfirst", "sortabs", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then return their sum.", "solution": "def op_dropfirst_sortabs_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return sum(r)", "tests": "assert op_dropfirst_sortabs_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_sortabs_sum([]) == 0\nassert op_dropfirst_sortabs_sum([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_sortabs_sum([5, 5, 5]) == 10\nassert op_dropfirst_sortabs_sum([3, 1, 2]) == 3\nassert op_dropfirst_sortabs_sum([10]) == 0\nassert op_dropfirst_sortabs_sum([2, 4, 6]) == 10\nassert op_dropfirst_sortabs_sum([-7, 12, -7]) == 5"}
{"id": "op_square_last3_negate", "entry_point": "op_square_last3_negate", "primitives": ["square", "last3", "negate"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then negate each.", "solution": "def op_square_last3_negate(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_square_last3_negate([1, 2, 3, 4]) == [-4, -9, -16]\nassert op_square_last3_negate([]) == []\nassert op_square_last3_negate([-2, -1, 0, 1, 2]) == [0, -1, -4]\nassert op_square_last3_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_square_last3_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_square_last3_negate([10]) == [-100]\nassert op_square_last3_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_square_last3_negate([-7, 12, -7]) == [-49, -144, -49]"}
{"id": "op_last3_dropwhileneg_trimends", "entry_point": "op_last3_dropwhileneg_trimends", "primitives": ["last3", "dropwhileneg", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_last3_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_dropwhileneg_trimends([1, 2, 3, 4]) == [3]\nassert op_last3_dropwhileneg_trimends([]) == []\nassert op_last3_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_last3_dropwhileneg_trimends([3, 1, 2]) == [1]\nassert op_last3_dropwhileneg_trimends([10]) == []\nassert op_last3_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_last3_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_inc_odds_dropwhileneg", "entry_point": "op_inc_odds_dropwhileneg", "primitives": ["inc", "odds", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_inc_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_inc_odds_dropwhileneg([1, 2, 3, 4]) == [3, 5]\nassert op_inc_odds_dropwhileneg([]) == []\nassert op_inc_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 3]\nassert op_inc_odds_dropwhileneg([5, 5, 5]) == []\nassert op_inc_odds_dropwhileneg([3, 1, 2]) == [3]\nassert op_inc_odds_dropwhileneg([10]) == [11]\nassert op_inc_odds_dropwhileneg([2, 4, 6]) == [3, 5, 7]\nassert op_inc_odds_dropwhileneg([-7, 12, -7]) == [13]"}
{"id": "op_inc_beforezero_sorta", "entry_point": "op_inc_beforezero_sorta", "primitives": ["inc", "beforezero", "sorta"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero, then sort ascending.", "solution": "def op_inc_beforezero_sorta(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_inc_beforezero_sorta([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_beforezero_sorta([]) == []\nassert op_inc_beforezero_sorta([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_beforezero_sorta([5, 5, 5]) == [6, 6, 6]\nassert op_inc_beforezero_sorta([3, 1, 2]) == [2, 3, 4]\nassert op_inc_beforezero_sorta([10]) == [11]\nassert op_inc_beforezero_sorta([2, 4, 6]) == [3, 5, 7]\nassert op_inc_beforezero_sorta([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_dropfirst_div3_neg", "entry_point": "op_dropfirst_div3_neg", "primitives": ["dropfirst", "div3", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep multiples of three, then keep the negative numbers.", "solution": "def op_dropfirst_div3_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_div3_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_div3_neg([]) == []\nassert op_dropfirst_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_div3_neg([5, 5, 5]) == []\nassert op_dropfirst_div3_neg([3, 1, 2]) == []\nassert op_dropfirst_div3_neg([10]) == []\nassert op_dropfirst_div3_neg([2, 4, 6]) == []\nassert op_dropfirst_div3_neg([-7, 12, -7]) == []"}
{"id": "op_div3_rev_counteven", "entry_point": "op_div3_rev_counteven", "primitives": ["div3", "rev", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then return how many values are even.", "solution": "def op_div3_rev_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_div3_rev_counteven([1, 2, 3, 4]) == 0\nassert op_div3_rev_counteven([]) == 0\nassert op_div3_rev_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_div3_rev_counteven([5, 5, 5]) == 0\nassert op_div3_rev_counteven([3, 1, 2]) == 0\nassert op_div3_rev_counteven([10]) == 0\nassert op_div3_rev_counteven([2, 4, 6]) == 1\nassert op_div3_rev_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_evens_dropzeros", "entry_point": "op_sortd_evens_dropzeros", "primitives": ["sortd", "evens", "dropzeros"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then drop the zeros.", "solution": "def op_sortd_evens_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortd_evens_dropzeros([1, 2, 3, 4]) == [4, 2]\nassert op_sortd_evens_dropzeros([]) == []\nassert op_sortd_evens_dropzeros([-2, -1, 0, 1, 2]) == [2, -2]\nassert op_sortd_evens_dropzeros([5, 5, 5]) == []\nassert op_sortd_evens_dropzeros([3, 1, 2]) == [2]\nassert op_sortd_evens_dropzeros([10]) == [10]\nassert op_sortd_evens_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_evens_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_double_last3_div3", "entry_point": "op_double_last3_div3", "primitives": ["double", "last3", "div3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three, then keep multiples of three.", "solution": "def op_double_last3_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_last3_div3([1, 2, 3, 4]) == [6]\nassert op_double_last3_div3([]) == []\nassert op_double_last3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_last3_div3([5, 5, 5]) == []\nassert op_double_last3_div3([3, 1, 2]) == [6]\nassert op_double_last3_div3([10]) == []\nassert op_double_last3_div3([2, 4, 6]) == [12]\nassert op_double_last3_div3([-7, 12, -7]) == [24]"}
{"id": "op_absval_dec_sortd", "entry_point": "op_absval_dec_sortd", "primitives": ["absval", "dec", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then sort descending.", "solution": "def op_absval_dec_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_dec_sortd([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_absval_dec_sortd([]) == []\nassert op_absval_dec_sortd([-2, -1, 0, 1, 2]) == [1, 1, 0, 0, -1]\nassert op_absval_dec_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_absval_dec_sortd([3, 1, 2]) == [2, 1, 0]\nassert op_absval_dec_sortd([10]) == [9]\nassert op_absval_dec_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_absval_dec_sortd([-7, 12, -7]) == [11, 6, 6]"}
{"id": "op_evens_absval_haszero", "entry_point": "op_evens_absval_haszero", "primitives": ["evens", "absval", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_evens_absval_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_evens_absval_haszero([1, 2, 3, 4]) == False\nassert op_evens_absval_haszero([]) == False\nassert op_evens_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_evens_absval_haszero([5, 5, 5]) == False\nassert op_evens_absval_haszero([3, 1, 2]) == False\nassert op_evens_absval_haszero([10]) == False\nassert op_evens_absval_haszero([2, 4, 6]) == False\nassert op_evens_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_rev_dropwhileneg_alldistinct", "entry_point": "op_rev_dropwhileneg_alldistinct", "primitives": ["rev", "dropwhileneg", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then return whether all values are distinct.", "solution": "def op_rev_dropwhileneg_alldistinct(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r) == len(set(r))", "tests": "assert op_rev_dropwhileneg_alldistinct([1, 2, 3, 4]) == True\nassert op_rev_dropwhileneg_alldistinct([]) == True\nassert op_rev_dropwhileneg_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_rev_dropwhileneg_alldistinct([5, 5, 5]) == False\nassert op_rev_dropwhileneg_alldistinct([3, 1, 2]) == True\nassert op_rev_dropwhileneg_alldistinct([10]) == True\nassert op_rev_dropwhileneg_alldistinct([2, 4, 6]) == True\nassert op_rev_dropwhileneg_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortabs_gt5_clamp10", "entry_point": "op_sortabs_gt5_clamp10", "primitives": ["sortabs", "gt5", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then cap each value at 10.", "solution": "def op_sortabs_gt5_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_gt5_clamp10([1, 2, 3, 4]) == []\nassert op_sortabs_gt5_clamp10([]) == []\nassert op_sortabs_gt5_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_gt5_clamp10([5, 5, 5]) == []\nassert op_sortabs_gt5_clamp10([3, 1, 2]) == []\nassert op_sortabs_gt5_clamp10([10]) == [10]\nassert op_sortabs_gt5_clamp10([2, 4, 6]) == [6]\nassert op_sortabs_gt5_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_add10_uniq_allpos", "entry_point": "op_add10_uniq_allpos", "primitives": ["add10", "uniq", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_add10_uniq_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_add10_uniq_allpos([1, 2, 3, 4]) == True\nassert op_add10_uniq_allpos([]) == True\nassert op_add10_uniq_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_uniq_allpos([5, 5, 5]) == True\nassert op_add10_uniq_allpos([3, 1, 2]) == True\nassert op_add10_uniq_allpos([10]) == True\nassert op_add10_uniq_allpos([2, 4, 6]) == True\nassert op_add10_uniq_allpos([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_padto3_last3", "entry_point": "op_oremptyzero_padto3_last3", "primitives": ["oremptyzero", "padto3", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_oremptyzero_padto3_last3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_oremptyzero_padto3_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_padto3_last3([]) == [0, 0, 0]\nassert op_oremptyzero_padto3_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_padto3_last3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_padto3_last3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_padto3_last3([10]) == [10, 0, 0]\nassert op_oremptyzero_padto3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_padto3_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_takewhilepos_absval", "entry_point": "op_beforezero_takewhilepos_absval", "primitives": ["beforezero", "takewhilepos", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then take the absolute value of each.", "solution": "def op_beforezero_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_takewhilepos_absval([]) == []\nassert op_beforezero_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_takewhilepos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_takewhilepos_absval([10]) == [10]\nassert op_beforezero_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_gt5_oremptyzero_takewhilepos", "entry_point": "op_gt5_oremptyzero_takewhilepos", "primitives": ["gt5", "oremptyzero", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then take values while they are positive.", "solution": "def op_gt5_oremptyzero_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_oremptyzero_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_oremptyzero_takewhilepos([]) == []\nassert op_gt5_oremptyzero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_oremptyzero_takewhilepos([5, 5, 5]) == []\nassert op_gt5_oremptyzero_takewhilepos([3, 1, 2]) == []\nassert op_gt5_oremptyzero_takewhilepos([10]) == [10]\nassert op_gt5_oremptyzero_takewhilepos([2, 4, 6]) == [6]\nassert op_gt5_oremptyzero_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_odds_add10_evens", "entry_point": "op_odds_add10_evens", "primitives": ["odds", "add10", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then keep the even numbers.", "solution": "def op_odds_add10_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_odds_add10_evens([1, 2, 3, 4]) == []\nassert op_odds_add10_evens([]) == []\nassert op_odds_add10_evens([-2, -1, 0, 1, 2]) == []\nassert op_odds_add10_evens([5, 5, 5]) == []\nassert op_odds_add10_evens([3, 1, 2]) == []\nassert op_odds_add10_evens([10]) == []\nassert op_odds_add10_evens([2, 4, 6]) == []\nassert op_odds_add10_evens([-7, 12, -7]) == []"}
{"id": "op_gt5_clamp10_first3", "entry_point": "op_gt5_clamp10_first3", "primitives": ["gt5", "clamp10", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then keep only the first three.", "solution": "def op_gt5_clamp10_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_clamp10_first3([1, 2, 3, 4]) == []\nassert op_gt5_clamp10_first3([]) == []\nassert op_gt5_clamp10_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_clamp10_first3([5, 5, 5]) == []\nassert op_gt5_clamp10_first3([3, 1, 2]) == []\nassert op_gt5_clamp10_first3([10]) == [10]\nassert op_gt5_clamp10_first3([2, 4, 6]) == [6]\nassert op_gt5_clamp10_first3([-7, 12, -7]) == [10]"}
{"id": "op_evens_last3_beforezero", "entry_point": "op_evens_last3_beforezero", "primitives": ["evens", "last3", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then keep everything before the first zero.", "solution": "def op_evens_last3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_last3_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_last3_beforezero([]) == []\nassert op_evens_last3_beforezero([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_last3_beforezero([5, 5, 5]) == []\nassert op_evens_last3_beforezero([3, 1, 2]) == [2]\nassert op_evens_last3_beforezero([10]) == [10]\nassert op_evens_last3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_last3_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_gt5_div3_square", "entry_point": "op_gt5_div3_square", "primitives": ["gt5", "div3", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then square each.", "solution": "def op_gt5_div3_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_div3_square([1, 2, 3, 4]) == []\nassert op_gt5_div3_square([]) == []\nassert op_gt5_div3_square([-2, -1, 0, 1, 2]) == []\nassert op_gt5_div3_square([5, 5, 5]) == []\nassert op_gt5_div3_square([3, 1, 2]) == []\nassert op_gt5_div3_square([10]) == []\nassert op_gt5_div3_square([2, 4, 6]) == [36]\nassert op_gt5_div3_square([-7, 12, -7]) == [144]"}
{"id": "op_negate_square_dropwhileneg", "entry_point": "op_negate_square_dropwhileneg", "primitives": ["negate", "square", "dropwhileneg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then drop the leading negative values.", "solution": "def op_negate_square_dropwhileneg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_negate_square_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_square_dropwhileneg([]) == []\nassert op_negate_square_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_square_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_negate_square_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_negate_square_dropwhileneg([10]) == [100]\nassert op_negate_square_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_negate_square_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_gt5_dropfirst_odds", "entry_point": "op_gt5_dropfirst_odds", "primitives": ["gt5", "dropfirst", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first element, then keep the odd numbers.", "solution": "def op_gt5_dropfirst_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_dropfirst_odds([1, 2, 3, 4]) == []\nassert op_gt5_dropfirst_odds([]) == []\nassert op_gt5_dropfirst_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropfirst_odds([5, 5, 5]) == []\nassert op_gt5_dropfirst_odds([3, 1, 2]) == []\nassert op_gt5_dropfirst_odds([10]) == []\nassert op_gt5_dropfirst_odds([2, 4, 6]) == []\nassert op_gt5_dropfirst_odds([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_uniq_last3", "entry_point": "op_takewhilepos_uniq_last3", "primitives": ["takewhilepos", "uniq", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence, then keep only the last three.", "solution": "def op_takewhilepos_uniq_last3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r", "tests": "assert op_takewhilepos_uniq_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_uniq_last3([]) == []\nassert op_takewhilepos_uniq_last3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_uniq_last3([5, 5, 5]) == [5]\nassert op_takewhilepos_uniq_last3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_uniq_last3([10]) == [10]\nassert op_takewhilepos_uniq_last3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_uniq_last3([-7, 12, -7]) == []"}
{"id": "op_rev_uniq_double", "entry_point": "op_rev_uniq_double", "primitives": ["rev", "uniq", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then double each.", "solution": "def op_rev_uniq_double(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_rev_uniq_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_uniq_double([]) == []\nassert op_rev_uniq_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_uniq_double([5, 5, 5]) == [10]\nassert op_rev_uniq_double([3, 1, 2]) == [4, 2, 6]\nassert op_rev_uniq_double([10]) == [20]\nassert op_rev_uniq_double([2, 4, 6]) == [12, 8, 4]\nassert op_rev_uniq_double([-7, 12, -7]) == [-14, 24]"}
{"id": "op_negate_evens_max", "entry_point": "op_negate_evens_max", "primitives": ["negate", "evens", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_negate_evens_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_negate_evens_max([1, 2, 3, 4]) == -2\nassert op_negate_evens_max([]) == 0\nassert op_negate_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_negate_evens_max([5, 5, 5]) == 0\nassert op_negate_evens_max([3, 1, 2]) == -2\nassert op_negate_evens_max([10]) == -10\nassert op_negate_evens_max([2, 4, 6]) == -2\nassert op_negate_evens_max([-7, 12, -7]) == -12"}
{"id": "op_takewhilepos_beforezero_double", "entry_point": "op_takewhilepos_beforezero_double", "primitives": ["takewhilepos", "beforezero", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then double each.", "solution": "def op_takewhilepos_beforezero_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_beforezero_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_beforezero_double([]) == []\nassert op_takewhilepos_beforezero_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_beforezero_double([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_beforezero_double([10]) == [20]\nassert op_takewhilepos_beforezero_double([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_beforezero_double([-7, 12, -7]) == []"}
{"id": "op_square_double_neg", "entry_point": "op_square_double_neg", "primitives": ["square", "double", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then keep the negative numbers.", "solution": "def op_square_double_neg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_square_double_neg([1, 2, 3, 4]) == []\nassert op_square_double_neg([]) == []\nassert op_square_double_neg([-2, -1, 0, 1, 2]) == []\nassert op_square_double_neg([5, 5, 5]) == []\nassert op_square_double_neg([3, 1, 2]) == []\nassert op_square_double_neg([10]) == []\nassert op_square_double_neg([2, 4, 6]) == []\nassert op_square_double_neg([-7, 12, -7]) == []"}
{"id": "op_inc_trimends_clamp10", "entry_point": "op_inc_trimends_clamp10", "primitives": ["inc", "trimends", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then cap each value at 10.", "solution": "def op_inc_trimends_clamp10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_inc_trimends_clamp10([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends_clamp10([]) == []\nassert op_inc_trimends_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends_clamp10([5, 5, 5]) == [6]\nassert op_inc_trimends_clamp10([3, 1, 2]) == [2]\nassert op_inc_trimends_clamp10([10]) == []\nassert op_inc_trimends_clamp10([2, 4, 6]) == [5]\nassert op_inc_trimends_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_odds_last3_prod", "entry_point": "op_odds_last3_prod", "primitives": ["odds", "last3", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then return their product.", "solution": "def op_odds_last3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_odds_last3_prod([1, 2, 3, 4]) == 3\nassert op_odds_last3_prod([]) == 1\nassert op_odds_last3_prod([-2, -1, 0, 1, 2]) == -1\nassert op_odds_last3_prod([5, 5, 5]) == 125\nassert op_odds_last3_prod([3, 1, 2]) == 3\nassert op_odds_last3_prod([10]) == 1\nassert op_odds_last3_prod([2, 4, 6]) == 1\nassert op_odds_last3_prod([-7, 12, -7]) == 49"}
{"id": "op_trimends_beforezero_max", "entry_point": "op_trimends_beforezero_max", "primitives": ["trimends", "beforezero", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_trimends_beforezero_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_trimends_beforezero_max([1, 2, 3, 4]) == 3\nassert op_trimends_beforezero_max([]) == 0\nassert op_trimends_beforezero_max([-2, -1, 0, 1, 2]) == -1\nassert op_trimends_beforezero_max([5, 5, 5]) == 5\nassert op_trimends_beforezero_max([3, 1, 2]) == 1\nassert op_trimends_beforezero_max([10]) == 0\nassert op_trimends_beforezero_max([2, 4, 6]) == 4\nassert op_trimends_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_gt5_inc_beforezero", "entry_point": "op_gt5_inc_beforezero", "primitives": ["gt5", "inc", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then keep everything before the first zero.", "solution": "def op_gt5_inc_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_gt5_inc_beforezero([1, 2, 3, 4]) == []\nassert op_gt5_inc_beforezero([]) == []\nassert op_gt5_inc_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_beforezero([5, 5, 5]) == []\nassert op_gt5_inc_beforezero([3, 1, 2]) == []\nassert op_gt5_inc_beforezero([10]) == [11]\nassert op_gt5_inc_beforezero([2, 4, 6]) == [7]\nassert op_gt5_inc_beforezero([-7, 12, -7]) == [13]"}
{"id": "op_first3_beforezero_clamp10", "entry_point": "op_first3_beforezero_clamp10", "primitives": ["first3", "beforezero", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_first3_beforezero_clamp10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_first3_beforezero_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_beforezero_clamp10([]) == []\nassert op_first3_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_beforezero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_first3_beforezero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_first3_beforezero_clamp10([10]) == [10]\nassert op_first3_beforezero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_first3_beforezero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_dropfirst_sorta_evens", "entry_point": "op_dropfirst_sorta_evens", "primitives": ["dropfirst", "sorta", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then keep the even numbers.", "solution": "def op_dropfirst_sorta_evens(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_dropfirst_sorta_evens([1, 2, 3, 4]) == [2, 4]\nassert op_dropfirst_sorta_evens([]) == []\nassert op_dropfirst_sorta_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_dropfirst_sorta_evens([5, 5, 5]) == []\nassert op_dropfirst_sorta_evens([3, 1, 2]) == [2]\nassert op_dropfirst_sorta_evens([10]) == []\nassert op_dropfirst_sorta_evens([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sorta_evens([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortd_first3", "entry_point": "op_rev_sortd_first3", "primitives": ["rev", "sortd", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then keep only the first three.", "solution": "def op_rev_sortd_first3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_rev_sortd_first3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_sortd_first3([]) == []\nassert op_rev_sortd_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_sortd_first3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortd_first3([3, 1, 2]) == [3, 2, 1]\nassert op_rev_sortd_first3([10]) == [10]\nassert op_rev_sortd_first3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_sortd_first3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_dec_gt5_sum", "entry_point": "op_dec_gt5_sum", "primitives": ["dec", "gt5", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then return their sum.", "solution": "def op_dec_gt5_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return sum(r)", "tests": "assert op_dec_gt5_sum([1, 2, 3, 4]) == 0\nassert op_dec_gt5_sum([]) == 0\nassert op_dec_gt5_sum([-2, -1, 0, 1, 2]) == 0\nassert op_dec_gt5_sum([5, 5, 5]) == 0\nassert op_dec_gt5_sum([3, 1, 2]) == 0\nassert op_dec_gt5_sum([10]) == 9\nassert op_dec_gt5_sum([2, 4, 6]) == 0\nassert op_dec_gt5_sum([-7, 12, -7]) == 11"}
{"id": "op_rev_oremptyzero_clamp10", "entry_point": "op_rev_oremptyzero_clamp10", "primitives": ["rev", "oremptyzero", "clamp10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then cap each value at 10.", "solution": "def op_rev_oremptyzero_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_oremptyzero_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_clamp10([]) == [0]\nassert op_rev_oremptyzero_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_oremptyzero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_clamp10([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_clamp10([10]) == [10]\nassert op_rev_oremptyzero_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_sortd_beforezero_absval", "entry_point": "op_sortd_beforezero_absval", "primitives": ["sortd", "beforezero", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_sortd_beforezero_absval(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortd_beforezero_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_beforezero_absval([]) == []\nassert op_sortd_beforezero_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_beforezero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_beforezero_absval([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_beforezero_absval([10]) == [10]\nassert op_sortd_beforezero_absval([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_beforezero_absval([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_dropzeros_takewhilepos_first3", "entry_point": "op_dropzeros_takewhilepos_first3", "primitives": ["dropzeros", "takewhilepos", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take values while they are positive, then keep only the first three.", "solution": "def op_dropzeros_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_takewhilepos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_takewhilepos_first3([]) == []\nassert op_dropzeros_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_takewhilepos_first3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_takewhilepos_first3([10]) == [10]\nassert op_dropzeros_takewhilepos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_neg_last3", "entry_point": "op_dropwhileneg_neg_last3", "primitives": ["dropwhileneg", "neg", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then keep only the last three.", "solution": "def op_dropwhileneg_neg_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_neg_last3([1, 2, 3, 4]) == []\nassert op_dropwhileneg_neg_last3([]) == []\nassert op_dropwhileneg_neg_last3([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_neg_last3([5, 5, 5]) == []\nassert op_dropwhileneg_neg_last3([3, 1, 2]) == []\nassert op_dropwhileneg_neg_last3([10]) == []\nassert op_dropwhileneg_neg_last3([2, 4, 6]) == []\nassert op_dropwhileneg_neg_last3([-7, 12, -7]) == [-7]"}
{"id": "op_dropfirst_dropwhileneg_len", "entry_point": "op_dropfirst_dropwhileneg_len", "primitives": ["dropfirst", "dropwhileneg", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then return how many remain.", "solution": "def op_dropfirst_dropwhileneg_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return len(r)", "tests": "assert op_dropfirst_dropwhileneg_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_dropwhileneg_len([]) == 0\nassert op_dropfirst_dropwhileneg_len([-2, -1, 0, 1, 2]) == 3\nassert op_dropfirst_dropwhileneg_len([5, 5, 5]) == 2\nassert op_dropfirst_dropwhileneg_len([3, 1, 2]) == 2\nassert op_dropfirst_dropwhileneg_len([10]) == 0\nassert op_dropfirst_dropwhileneg_len([2, 4, 6]) == 2\nassert op_dropfirst_dropwhileneg_len([-7, 12, -7]) == 2"}
{"id": "op_inc_square_dropfirst", "entry_point": "op_inc_square_dropfirst", "primitives": ["inc", "square", "dropfirst"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each, then drop the first element.", "solution": "def op_inc_square_dropfirst(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_inc_square_dropfirst([1, 2, 3, 4]) == [9, 16, 25]\nassert op_inc_square_dropfirst([]) == []\nassert op_inc_square_dropfirst([-2, -1, 0, 1, 2]) == [0, 1, 4, 9]\nassert op_inc_square_dropfirst([5, 5, 5]) == [36, 36]\nassert op_inc_square_dropfirst([3, 1, 2]) == [4, 9]\nassert op_inc_square_dropfirst([10]) == []\nassert op_inc_square_dropfirst([2, 4, 6]) == [25, 49]\nassert op_inc_square_dropfirst([-7, 12, -7]) == [169, 36]"}
{"id": "op_add10_dropzeros_sortd", "entry_point": "op_add10_dropzeros_sortd", "primitives": ["add10", "dropzeros", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then sort descending.", "solution": "def op_add10_dropzeros_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_dropzeros_sortd([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_dropzeros_sortd([]) == []\nassert op_add10_dropzeros_sortd([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_dropzeros_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_add10_dropzeros_sortd([10]) == [20]\nassert op_add10_dropzeros_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_add10_dropzeros_sortd([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_rev_absval_evens", "entry_point": "op_rev_absval_evens", "primitives": ["rev", "absval", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then keep the even numbers.", "solution": "def op_rev_absval_evens(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_rev_absval_evens([1, 2, 3, 4]) == [4, 2]\nassert op_rev_absval_evens([]) == []\nassert op_rev_absval_evens([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_rev_absval_evens([5, 5, 5]) == []\nassert op_rev_absval_evens([3, 1, 2]) == [2]\nassert op_rev_absval_evens([10]) == [10]\nassert op_rev_absval_evens([2, 4, 6]) == [6, 4, 2]\nassert op_rev_absval_evens([-7, 12, -7]) == [12]"}
{"id": "op_negate_double_last3", "entry_point": "op_negate_double_last3", "primitives": ["negate", "double", "last3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then keep only the last three.", "solution": "def op_negate_double_last3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_negate_double_last3([1, 2, 3, 4]) == [-4, -6, -8]\nassert op_negate_double_last3([]) == []\nassert op_negate_double_last3([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_negate_double_last3([5, 5, 5]) == [-10, -10, -10]\nassert op_negate_double_last3([3, 1, 2]) == [-6, -2, -4]\nassert op_negate_double_last3([10]) == [-20]\nassert op_negate_double_last3([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_double_last3([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_beforezero_evens_double", "entry_point": "op_beforezero_evens_double", "primitives": ["beforezero", "evens", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the even numbers, then double each.", "solution": "def op_beforezero_evens_double(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_beforezero_evens_double([1, 2, 3, 4]) == [4, 8]\nassert op_beforezero_evens_double([]) == []\nassert op_beforezero_evens_double([-2, -1, 0, 1, 2]) == [-4]\nassert op_beforezero_evens_double([5, 5, 5]) == []\nassert op_beforezero_evens_double([3, 1, 2]) == [4]\nassert op_beforezero_evens_double([10]) == [20]\nassert op_beforezero_evens_double([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_evens_double([-7, 12, -7]) == [24]"}
{"id": "op_rev_add10_allpos", "entry_point": "op_rev_add10_allpos", "primitives": ["rev", "add10", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then return whether all values are positive.", "solution": "def op_rev_add10_allpos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_rev_add10_allpos([1, 2, 3, 4]) == True\nassert op_rev_add10_allpos([]) == True\nassert op_rev_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_rev_add10_allpos([5, 5, 5]) == True\nassert op_rev_add10_allpos([3, 1, 2]) == True\nassert op_rev_add10_allpos([10]) == True\nassert op_rev_add10_allpos([2, 4, 6]) == True\nassert op_rev_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_double_odds", "entry_point": "op_negate_double_odds", "primitives": ["negate", "double", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then keep the odd numbers.", "solution": "def op_negate_double_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_double_odds([1, 2, 3, 4]) == []\nassert op_negate_double_odds([]) == []\nassert op_negate_double_odds([-2, -1, 0, 1, 2]) == []\nassert op_negate_double_odds([5, 5, 5]) == []\nassert op_negate_double_odds([3, 1, 2]) == []\nassert op_negate_double_odds([10]) == []\nassert op_negate_double_odds([2, 4, 6]) == []\nassert op_negate_double_odds([-7, 12, -7]) == []"}
{"id": "op_first3_dropzeros_max", "entry_point": "op_first3_dropzeros_max", "primitives": ["first3", "dropzeros", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then return the maximum (0 if empty).", "solution": "def op_first3_dropzeros_max(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return max(r) if r else 0", "tests": "assert op_first3_dropzeros_max([1, 2, 3, 4]) == 3\nassert op_first3_dropzeros_max([]) == 0\nassert op_first3_dropzeros_max([-2, -1, 0, 1, 2]) == -1\nassert op_first3_dropzeros_max([5, 5, 5]) == 5\nassert op_first3_dropzeros_max([3, 1, 2]) == 3\nassert op_first3_dropzeros_max([10]) == 10\nassert op_first3_dropzeros_max([2, 4, 6]) == 6\nassert op_first3_dropzeros_max([-7, 12, -7]) == 12"}
{"id": "op_names_dropshort_uniqs", "entry_point": "op_names_dropshort_uniqs", "primitives": ["names", "dropshort", "uniqs"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop strings shorter than three characters, then drop duplicate strings keeping the first.", "solution": "def op_names_dropshort_uniqs(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if len(s) >= 3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_names_dropshort_uniqs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada']\nassert op_names_dropshort_uniqs([]) == []\nassert op_names_dropshort_uniqs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Dee']\nassert op_names_dropshort_uniqs([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dec_oremptyzero_takewhilepos", "entry_point": "op_dec_oremptyzero_takewhilepos", "primitives": ["dec", "oremptyzero", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then take values while they are positive.", "solution": "def op_dec_oremptyzero_takewhilepos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dec_oremptyzero_takewhilepos([1, 2, 3, 4]) == []\nassert op_dec_oremptyzero_takewhilepos([]) == []\nassert op_dec_oremptyzero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dec_oremptyzero_takewhilepos([5, 5, 5]) == [4, 4, 4]\nassert op_dec_oremptyzero_takewhilepos([3, 1, 2]) == [2]\nassert op_dec_oremptyzero_takewhilepos([10]) == [9]\nassert op_dec_oremptyzero_takewhilepos([2, 4, 6]) == [1, 3, 5]\nassert op_dec_oremptyzero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_square_odds_sortabs", "entry_point": "op_square_odds_sortabs", "primitives": ["square", "odds", "sortabs"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then sort by absolute value.", "solution": "def op_square_odds_sortabs(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_square_odds_sortabs([1, 2, 3, 4]) == [1, 9]\nassert op_square_odds_sortabs([]) == []\nassert op_square_odds_sortabs([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_odds_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_square_odds_sortabs([3, 1, 2]) == [1, 9]\nassert op_square_odds_sortabs([10]) == []\nassert op_square_odds_sortabs([2, 4, 6]) == []\nassert op_square_odds_sortabs([-7, 12, -7]) == [49, 49]"}
{"id": "op_absval_square_neg", "entry_point": "op_absval_square_neg", "primitives": ["absval", "square", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each, then keep the negative numbers.", "solution": "def op_absval_square_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_square_neg([1, 2, 3, 4]) == []\nassert op_absval_square_neg([]) == []\nassert op_absval_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_square_neg([5, 5, 5]) == []\nassert op_absval_square_neg([3, 1, 2]) == []\nassert op_absval_square_neg([10]) == []\nassert op_absval_square_neg([2, 4, 6]) == []\nassert op_absval_square_neg([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sortabs_double", "entry_point": "op_takewhilepos_sortabs_double", "primitives": ["takewhilepos", "sortabs", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then double each.", "solution": "def op_takewhilepos_sortabs_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_sortabs_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_sortabs_double([]) == []\nassert op_takewhilepos_sortabs_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_double([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_sortabs_double([3, 1, 2]) == [2, 4, 6]\nassert op_takewhilepos_sortabs_double([10]) == [20]\nassert op_takewhilepos_sortabs_double([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_sortabs_double([-7, 12, -7]) == []"}
{"id": "op_ages_last3_div3", "entry_point": "op_ages_last3_div3", "primitives": ["ages", "last3", "div3"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then keep multiples of three.", "solution": "def op_ages_last3_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_last3_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_last3_div3([]) == []\nassert op_ages_last3_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_last3_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_ages_oremptyzero_negate", "entry_point": "op_ages_oremptyzero_negate", "primitives": ["ages", "oremptyzero", "negate"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then if empty, use a single zero, then negate each.", "solution": "def op_ages_oremptyzero_negate(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r if r else [0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_ages_oremptyzero_negate([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_oremptyzero_negate([]) == [0]\nassert op_ages_oremptyzero_negate([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_oremptyzero_negate([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_oremptyzero_dec_absval", "entry_point": "op_oremptyzero_dec_absval", "primitives": ["oremptyzero", "dec", "absval"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then take the absolute value of each.", "solution": "def op_oremptyzero_dec_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_dec_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_oremptyzero_dec_absval([]) == [1]\nassert op_oremptyzero_dec_absval([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, 1]\nassert op_oremptyzero_dec_absval([5, 5, 5]) == [4, 4, 4]\nassert op_oremptyzero_dec_absval([3, 1, 2]) == [2, 0, 1]\nassert op_oremptyzero_dec_absval([10]) == [9]\nassert op_oremptyzero_dec_absval([2, 4, 6]) == [1, 3, 5]\nassert op_oremptyzero_dec_absval([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_oremptyzero_add10_double", "entry_point": "op_oremptyzero_add10_double", "primitives": ["oremptyzero", "add10", "double"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then double each.", "solution": "def op_oremptyzero_add10_double(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_add10_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_oremptyzero_add10_double([]) == [20]\nassert op_oremptyzero_add10_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_oremptyzero_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_oremptyzero_add10_double([3, 1, 2]) == [26, 22, 24]\nassert op_oremptyzero_add10_double([10]) == [40]\nassert op_oremptyzero_add10_double([2, 4, 6]) == [24, 28, 32]\nassert op_oremptyzero_add10_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_rev_add10_max", "entry_point": "op_rev_add10_max", "primitives": ["rev", "add10", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then return the maximum (0 if empty).", "solution": "def op_rev_add10_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return max(r) if r else 0", "tests": "assert op_rev_add10_max([1, 2, 3, 4]) == 14\nassert op_rev_add10_max([]) == 0\nassert op_rev_add10_max([-2, -1, 0, 1, 2]) == 12\nassert op_rev_add10_max([5, 5, 5]) == 15\nassert op_rev_add10_max([3, 1, 2]) == 13\nassert op_rev_add10_max([10]) == 20\nassert op_rev_add10_max([2, 4, 6]) == 16\nassert op_rev_add10_max([-7, 12, -7]) == 22"}
{"id": "op_div3_dec_odds", "entry_point": "op_div3_dec_odds", "primitives": ["div3", "dec", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each, then keep the odd numbers.", "solution": "def op_div3_dec_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_dec_odds([1, 2, 3, 4]) == []\nassert op_div3_dec_odds([]) == []\nassert op_div3_dec_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_dec_odds([5, 5, 5]) == []\nassert op_div3_dec_odds([3, 1, 2]) == []\nassert op_div3_dec_odds([10]) == []\nassert op_div3_dec_odds([2, 4, 6]) == [5]\nassert op_div3_dec_odds([-7, 12, -7]) == [11]"}
{"id": "op_padto3_double_beforezero", "entry_point": "op_padto3_double_beforezero", "primitives": ["padto3", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then keep everything before the first zero.", "solution": "def op_padto3_double_beforezero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_padto3_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_double_beforezero([]) == []\nassert op_padto3_double_beforezero([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_padto3_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_double_beforezero([10]) == [20]\nassert op_padto3_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_double_beforezero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_first3_square_beforezero", "entry_point": "op_first3_square_beforezero", "primitives": ["first3", "square", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each, then keep everything before the first zero.", "solution": "def op_first3_square_beforezero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_first3_square_beforezero([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_square_beforezero([]) == []\nassert op_first3_square_beforezero([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_first3_square_beforezero([5, 5, 5]) == [25, 25, 25]\nassert op_first3_square_beforezero([3, 1, 2]) == [9, 1, 4]\nassert op_first3_square_beforezero([10]) == [100]\nassert op_first3_square_beforezero([2, 4, 6]) == [4, 16, 36]\nassert op_first3_square_beforezero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_add10_uniq_max", "entry_point": "op_add10_uniq_max", "primitives": ["add10", "uniq", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_add10_uniq_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_add10_uniq_max([1, 2, 3, 4]) == 14\nassert op_add10_uniq_max([]) == 0\nassert op_add10_uniq_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_uniq_max([5, 5, 5]) == 15\nassert op_add10_uniq_max([3, 1, 2]) == 13\nassert op_add10_uniq_max([10]) == 20\nassert op_add10_uniq_max([2, 4, 6]) == 16\nassert op_add10_uniq_max([-7, 12, -7]) == 22"}
{"id": "op_takewhilepos_double_firsteven", "entry_point": "op_takewhilepos_double_firsteven", "primitives": ["takewhilepos", "double", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then return the first even value (0 if none).", "solution": "def op_takewhilepos_double_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_double_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_double_firsteven([]) == 0\nassert op_takewhilepos_double_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_double_firsteven([5, 5, 5]) == 10\nassert op_takewhilepos_double_firsteven([3, 1, 2]) == 6\nassert op_takewhilepos_double_firsteven([10]) == 20\nassert op_takewhilepos_double_firsteven([2, 4, 6]) == 4\nassert op_takewhilepos_double_firsteven([-7, 12, -7]) == 0"}
{"id": "op_square_last3_alldistinct", "entry_point": "op_square_last3_alldistinct", "primitives": ["square", "last3", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then return whether all values are distinct.", "solution": "def op_square_last3_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_square_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_square_last3_alldistinct([]) == True\nassert op_square_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_square_last3_alldistinct([5, 5, 5]) == False\nassert op_square_last3_alldistinct([3, 1, 2]) == True\nassert op_square_last3_alldistinct([10]) == True\nassert op_square_last3_alldistinct([2, 4, 6]) == True\nassert op_square_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_add10_gt5_allpos", "entry_point": "op_add10_gt5_allpos", "primitives": ["add10", "gt5", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then return whether all values are positive.", "solution": "def op_add10_gt5_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_gt5_allpos([1, 2, 3, 4]) == True\nassert op_add10_gt5_allpos([]) == True\nassert op_add10_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_gt5_allpos([5, 5, 5]) == True\nassert op_add10_gt5_allpos([3, 1, 2]) == True\nassert op_add10_gt5_allpos([10]) == True\nassert op_add10_gt5_allpos([2, 4, 6]) == True\nassert op_add10_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_pos_clamp10_dec", "entry_point": "op_pos_clamp10_dec", "primitives": ["pos", "clamp10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then subtract one from each.", "solution": "def op_pos_clamp10_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_pos_clamp10_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_pos_clamp10_dec([]) == []\nassert op_pos_clamp10_dec([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_clamp10_dec([5, 5, 5]) == [4, 4, 4]\nassert op_pos_clamp10_dec([3, 1, 2]) == [2, 0, 1]\nassert op_pos_clamp10_dec([10]) == [9]\nassert op_pos_clamp10_dec([2, 4, 6]) == [1, 3, 5]\nassert op_pos_clamp10_dec([-7, 12, -7]) == [9]"}
{"id": "op_uniq_div3_evens", "entry_point": "op_uniq_div3_evens", "primitives": ["uniq", "div3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep multiples of three, then keep the even numbers.", "solution": "def op_uniq_div3_evens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_uniq_div3_evens([1, 2, 3, 4]) == []\nassert op_uniq_div3_evens([]) == []\nassert op_uniq_div3_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_div3_evens([5, 5, 5]) == []\nassert op_uniq_div3_evens([3, 1, 2]) == []\nassert op_uniq_div3_evens([10]) == []\nassert op_uniq_div3_evens([2, 4, 6]) == [6]\nassert op_uniq_div3_evens([-7, 12, -7]) == [12]"}
{"id": "op_padto3_square_uniq", "entry_point": "op_padto3_square_uniq", "primitives": ["padto3", "square", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then drop duplicates keeping first occurrence.", "solution": "def op_padto3_square_uniq(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_padto3_square_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_padto3_square_uniq([]) == [0]\nassert op_padto3_square_uniq([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_padto3_square_uniq([5, 5, 5]) == [25]\nassert op_padto3_square_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_padto3_square_uniq([10]) == [100, 0]\nassert op_padto3_square_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_padto3_square_uniq([-7, 12, -7]) == [49, 144]"}
{"id": "op_dec_first3_max", "entry_point": "op_dec_first3_max", "primitives": ["dec", "first3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_dec_first3_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_dec_first3_max([1, 2, 3, 4]) == 2\nassert op_dec_first3_max([]) == 0\nassert op_dec_first3_max([-2, -1, 0, 1, 2]) == -1\nassert op_dec_first3_max([5, 5, 5]) == 4\nassert op_dec_first3_max([3, 1, 2]) == 2\nassert op_dec_first3_max([10]) == 9\nassert op_dec_first3_max([2, 4, 6]) == 5\nassert op_dec_first3_max([-7, 12, -7]) == 11"}
{"id": "op_evens_square_allpos", "entry_point": "op_evens_square_allpos", "primitives": ["evens", "square", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then square each, then return whether all values are positive.", "solution": "def op_evens_square_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_square_allpos([1, 2, 3, 4]) == True\nassert op_evens_square_allpos([]) == True\nassert op_evens_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_square_allpos([5, 5, 5]) == True\nassert op_evens_square_allpos([3, 1, 2]) == True\nassert op_evens_square_allpos([10]) == True\nassert op_evens_square_allpos([2, 4, 6]) == True\nassert op_evens_square_allpos([-7, 12, -7]) == True"}
{"id": "op_rev_double_add10", "entry_point": "op_rev_double_add10", "primitives": ["rev", "double", "add10"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then add ten to each.", "solution": "def op_rev_double_add10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_rev_double_add10([1, 2, 3, 4]) == [18, 16, 14, 12]\nassert op_rev_double_add10([]) == []\nassert op_rev_double_add10([-2, -1, 0, 1, 2]) == [14, 12, 10, 8, 6]\nassert op_rev_double_add10([5, 5, 5]) == [20, 20, 20]\nassert op_rev_double_add10([3, 1, 2]) == [14, 12, 16]\nassert op_rev_double_add10([10]) == [30]\nassert op_rev_double_add10([2, 4, 6]) == [22, 18, 14]\nassert op_rev_double_add10([-7, 12, -7]) == [-4, 34, -4]"}
{"id": "op_trimends_rev_neg", "entry_point": "op_trimends_rev_neg", "primitives": ["trimends", "rev", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then keep the negative numbers.", "solution": "def op_trimends_rev_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_rev_neg([1, 2, 3, 4]) == []\nassert op_trimends_rev_neg([]) == []\nassert op_trimends_rev_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_rev_neg([5, 5, 5]) == []\nassert op_trimends_rev_neg([3, 1, 2]) == []\nassert op_trimends_rev_neg([10]) == []\nassert op_trimends_rev_neg([2, 4, 6]) == []\nassert op_trimends_rev_neg([-7, 12, -7]) == []"}
{"id": "op_dropfirst_first3_sum", "entry_point": "op_dropfirst_first3_sum", "primitives": ["dropfirst", "first3", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then return their sum.", "solution": "def op_dropfirst_first3_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return sum(r)", "tests": "assert op_dropfirst_first3_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_first3_sum([]) == 0\nassert op_dropfirst_first3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_first3_sum([5, 5, 5]) == 10\nassert op_dropfirst_first3_sum([3, 1, 2]) == 3\nassert op_dropfirst_first3_sum([10]) == 0\nassert op_dropfirst_first3_sum([2, 4, 6]) == 10\nassert op_dropfirst_first3_sum([-7, 12, -7]) == 5"}
{"id": "op_ages_sortd_double", "entry_point": "op_ages_sortd_double", "primitives": ["ages", "sortd", "double"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then double each.", "solution": "def op_ages_sortd_double(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_ages_sortd_double([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [72, 24]\nassert op_ages_sortd_double([]) == []\nassert op_ages_sortd_double([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [130, 36, 34]\nassert op_ages_sortd_double([{'name': 'Fi', 'age': 41}]) == [82]"}
{"id": "op_sortabs_div3_evens", "entry_point": "op_sortabs_div3_evens", "primitives": ["sortabs", "div3", "evens"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then keep the even numbers.", "solution": "def op_sortabs_div3_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_div3_evens([1, 2, 3, 4]) == []\nassert op_sortabs_div3_evens([]) == []\nassert op_sortabs_div3_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_sortabs_div3_evens([5, 5, 5]) == []\nassert op_sortabs_div3_evens([3, 1, 2]) == []\nassert op_sortabs_div3_evens([10]) == []\nassert op_sortabs_div3_evens([2, 4, 6]) == [6]\nassert op_sortabs_div3_evens([-7, 12, -7]) == [12]"}
{"id": "op_dec_div3_trimends", "entry_point": "op_dec_div3_trimends", "primitives": ["dec", "div3", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three, then drop the first and last elements.", "solution": "def op_dec_div3_trimends(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dec_div3_trimends([1, 2, 3, 4]) == []\nassert op_dec_div3_trimends([]) == []\nassert op_dec_div3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dec_div3_trimends([5, 5, 5]) == []\nassert op_dec_div3_trimends([3, 1, 2]) == []\nassert op_dec_div3_trimends([10]) == []\nassert op_dec_div3_trimends([2, 4, 6]) == []\nassert op_dec_div3_trimends([-7, 12, -7]) == []"}
{"id": "op_sortd_clamp10_alldistinct", "entry_point": "op_sortd_clamp10_alldistinct", "primitives": ["sortd", "clamp10", "alldistinct"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_sortd_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_clamp10_alldistinct([]) == True\nassert op_sortd_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_clamp10_alldistinct([5, 5, 5]) == False\nassert op_sortd_clamp10_alldistinct([3, 1, 2]) == True\nassert op_sortd_clamp10_alldistinct([10]) == True\nassert op_sortd_clamp10_alldistinct([2, 4, 6]) == True\nassert op_sortd_clamp10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_add10_prod", "entry_point": "op_last3_add10_prod", "primitives": ["last3", "add10", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then return their product.", "solution": "def op_last3_add10_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_last3_add10_prod([1, 2, 3, 4]) == 2184\nassert op_last3_add10_prod([]) == 1\nassert op_last3_add10_prod([-2, -1, 0, 1, 2]) == 1320\nassert op_last3_add10_prod([5, 5, 5]) == 3375\nassert op_last3_add10_prod([3, 1, 2]) == 1716\nassert op_last3_add10_prod([10]) == 20\nassert op_last3_add10_prod([2, 4, 6]) == 2688\nassert op_last3_add10_prod([-7, 12, -7]) == 198"}
{"id": "op_upper_sortalpha_uniqs", "entry_point": "op_upper_sortalpha_uniqs", "primitives": ["upper", "sortalpha", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort alphabetically, then drop duplicate strings keeping the first.", "solution": "def op_upper_sortalpha_uniqs(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_upper_sortalpha_uniqs(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_sortalpha_uniqs([]) == []\nassert op_upper_sortalpha_uniqs(['  a ', '', 'BC', 'bc']) == ['', '  A ', 'BC']\nassert op_upper_sortalpha_uniqs(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_upper_sortalpha_uniqs(['x']) == ['X']\nassert op_upper_sortalpha_uniqs(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_uniq_dec_first3", "entry_point": "op_uniq_dec_first3", "primitives": ["uniq", "dec", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then keep only the first three.", "solution": "def op_uniq_dec_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_uniq_dec_first3([1, 2, 3, 4]) == [0, 1, 2]\nassert op_uniq_dec_first3([]) == []\nassert op_uniq_dec_first3([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_uniq_dec_first3([5, 5, 5]) == [4]\nassert op_uniq_dec_first3([3, 1, 2]) == [2, 0, 1]\nassert op_uniq_dec_first3([10]) == [9]\nassert op_uniq_dec_first3([2, 4, 6]) == [1, 3, 5]\nassert op_uniq_dec_first3([-7, 12, -7]) == [-8, 11]"}
{"id": "op_dec_beforezero_rev", "entry_point": "op_dec_beforezero_rev", "primitives": ["dec", "beforezero", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then reverse the order.", "solution": "def op_dec_beforezero_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_beforezero_rev([1, 2, 3, 4]) == []\nassert op_dec_beforezero_rev([]) == []\nassert op_dec_beforezero_rev([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_dec_beforezero_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_beforezero_rev([3, 1, 2]) == [2]\nassert op_dec_beforezero_rev([10]) == [9]\nassert op_dec_beforezero_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_beforezero_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_sortage_ages_add10", "entry_point": "op_sortage_ages_add10", "primitives": ["sortage", "ages", "add10"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then add ten to each.", "solution": "def op_sortage_ages_add10(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortage_ages_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [22, 46]\nassert op_sortage_ages_add10([]) == []\nassert op_sortage_ages_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [27, 28, 75]\nassert op_sortage_ages_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_gt5_odds_inc", "entry_point": "op_gt5_odds_inc", "primitives": ["gt5", "odds", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the odd numbers, then add one to each.", "solution": "def op_gt5_odds_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_gt5_odds_inc([1, 2, 3, 4]) == []\nassert op_gt5_odds_inc([]) == []\nassert op_gt5_odds_inc([-2, -1, 0, 1, 2]) == []\nassert op_gt5_odds_inc([5, 5, 5]) == []\nassert op_gt5_odds_inc([3, 1, 2]) == []\nassert op_gt5_odds_inc([10]) == []\nassert op_gt5_odds_inc([2, 4, 6]) == []\nassert op_gt5_odds_inc([-7, 12, -7]) == []"}
{"id": "op_gt5_takewhilepos_allpos", "entry_point": "op_gt5_takewhilepos_allpos", "primitives": ["gt5", "takewhilepos", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then return whether all values are positive.", "solution": "def op_gt5_takewhilepos_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_takewhilepos_allpos([1, 2, 3, 4]) == True\nassert op_gt5_takewhilepos_allpos([]) == True\nassert op_gt5_takewhilepos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_takewhilepos_allpos([5, 5, 5]) == True\nassert op_gt5_takewhilepos_allpos([3, 1, 2]) == True\nassert op_gt5_takewhilepos_allpos([10]) == True\nassert op_gt5_takewhilepos_allpos([2, 4, 6]) == True\nassert op_gt5_takewhilepos_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_uniq_allpos", "entry_point": "op_negate_uniq_allpos", "primitives": ["negate", "uniq", "allpos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_negate_uniq_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_negate_uniq_allpos([1, 2, 3, 4]) == False\nassert op_negate_uniq_allpos([]) == True\nassert op_negate_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_uniq_allpos([5, 5, 5]) == False\nassert op_negate_uniq_allpos([3, 1, 2]) == False\nassert op_negate_uniq_allpos([10]) == False\nassert op_negate_uniq_allpos([2, 4, 6]) == False\nassert op_negate_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_uniq_firsteven", "entry_point": "op_div3_uniq_firsteven", "primitives": ["div3", "uniq", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then return the first even value (0 if none).", "solution": "def op_div3_uniq_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_uniq_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_uniq_firsteven([]) == 0\nassert op_div3_uniq_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_uniq_firsteven([5, 5, 5]) == 0\nassert op_div3_uniq_firsteven([3, 1, 2]) == 0\nassert op_div3_uniq_firsteven([10]) == 0\nassert op_div3_uniq_firsteven([2, 4, 6]) == 6\nassert op_div3_uniq_firsteven([-7, 12, -7]) == 12"}
{"id": "op_pos_takewhilepos_oremptyzero", "entry_point": "op_pos_takewhilepos_oremptyzero", "primitives": ["pos", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_pos_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_pos_takewhilepos_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_takewhilepos_oremptyzero([]) == [0]\nassert op_pos_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_takewhilepos_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_pos_takewhilepos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_pos_takewhilepos_oremptyzero([10]) == [10]\nassert op_pos_takewhilepos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_takewhilepos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_inc_first3", "entry_point": "op_beforezero_inc_first3", "primitives": ["beforezero", "inc", "first3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then keep only the first three.", "solution": "def op_beforezero_inc_first3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_beforezero_inc_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_inc_first3([]) == []\nassert op_beforezero_inc_first3([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_beforezero_inc_first3([5, 5, 5]) == [6, 6, 6]\nassert op_beforezero_inc_first3([3, 1, 2]) == [4, 2, 3]\nassert op_beforezero_inc_first3([10]) == [11]\nassert op_beforezero_inc_first3([2, 4, 6]) == [3, 5, 7]\nassert op_beforezero_inc_first3([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_div3_odds_uniq", "entry_point": "op_div3_odds_uniq", "primitives": ["div3", "odds", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_div3_odds_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_div3_odds_uniq([1, 2, 3, 4]) == [3]\nassert op_div3_odds_uniq([]) == []\nassert op_div3_odds_uniq([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_uniq([5, 5, 5]) == []\nassert op_div3_odds_uniq([3, 1, 2]) == [3]\nassert op_div3_odds_uniq([10]) == []\nassert op_div3_odds_uniq([2, 4, 6]) == []\nassert op_div3_odds_uniq([-7, 12, -7]) == []"}
{"id": "op_gt5_inc_uniq", "entry_point": "op_gt5_inc_uniq", "primitives": ["gt5", "inc", "uniq"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then drop duplicates keeping first occurrence.", "solution": "def op_gt5_inc_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_gt5_inc_uniq([1, 2, 3, 4]) == []\nassert op_gt5_inc_uniq([]) == []\nassert op_gt5_inc_uniq([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_uniq([5, 5, 5]) == []\nassert op_gt5_inc_uniq([3, 1, 2]) == []\nassert op_gt5_inc_uniq([10]) == [11]\nassert op_gt5_inc_uniq([2, 4, 6]) == [7]\nassert op_gt5_inc_uniq([-7, 12, -7]) == [13]"}
{"id": "op_pos_odds_square", "entry_point": "op_pos_odds_square", "primitives": ["pos", "odds", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then square each.", "solution": "def op_pos_odds_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_odds_square([1, 2, 3, 4]) == [1, 9]\nassert op_pos_odds_square([]) == []\nassert op_pos_odds_square([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_odds_square([5, 5, 5]) == [25, 25, 25]\nassert op_pos_odds_square([3, 1, 2]) == [9, 1]\nassert op_pos_odds_square([10]) == []\nassert op_pos_odds_square([2, 4, 6]) == []\nassert op_pos_odds_square([-7, 12, -7]) == []"}
{"id": "op_first3_sortabs_rev", "entry_point": "op_first3_sortabs_rev", "primitives": ["first3", "sortabs", "rev"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then reverse the order.", "solution": "def op_first3_sortabs_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_sortabs_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_sortabs_rev([]) == []\nassert op_first3_sortabs_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_sortabs_rev([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortabs_rev([3, 1, 2]) == [3, 2, 1]\nassert op_first3_sortabs_rev([10]) == [10]\nassert op_first3_sortabs_rev([2, 4, 6]) == [6, 4, 2]\nassert op_first3_sortabs_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_square_takewhilepos", "entry_point": "op_gt5_square_takewhilepos", "primitives": ["gt5", "square", "takewhilepos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then square each, then take values while they are positive.", "solution": "def op_gt5_square_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_square_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_square_takewhilepos([]) == []\nassert op_gt5_square_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_square_takewhilepos([5, 5, 5]) == []\nassert op_gt5_square_takewhilepos([3, 1, 2]) == []\nassert op_gt5_square_takewhilepos([10]) == [100]\nassert op_gt5_square_takewhilepos([2, 4, 6]) == [36]\nassert op_gt5_square_takewhilepos([-7, 12, -7]) == [144]"}
{"id": "op_dropfirst_absval_dec", "entry_point": "op_dropfirst_absval_dec", "primitives": ["dropfirst", "absval", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then subtract one from each.", "solution": "def op_dropfirst_absval_dec(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropfirst_absval_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_absval_dec([]) == []\nassert op_dropfirst_absval_dec([-2, -1, 0, 1, 2]) == [0, -1, 0, 1]\nassert op_dropfirst_absval_dec([5, 5, 5]) == [4, 4]\nassert op_dropfirst_absval_dec([3, 1, 2]) == [0, 1]\nassert op_dropfirst_absval_dec([10]) == []\nassert op_dropfirst_absval_dec([2, 4, 6]) == [3, 5]\nassert op_dropfirst_absval_dec([-7, 12, -7]) == [11, 6]"}
{"id": "op_dropfirst_sortd_issorted", "entry_point": "op_dropfirst_sortd_issorted", "primitives": ["dropfirst", "sortd", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_sortd_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_dropfirst_sortd_issorted([1, 2, 3, 4]) == False\nassert op_dropfirst_sortd_issorted([]) == True\nassert op_dropfirst_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_sortd_issorted([5, 5, 5]) == True\nassert op_dropfirst_sortd_issorted([3, 1, 2]) == False\nassert op_dropfirst_sortd_issorted([10]) == True\nassert op_dropfirst_sortd_issorted([2, 4, 6]) == False\nassert op_dropfirst_sortd_issorted([-7, 12, -7]) == False"}
{"id": "op_div3_square_issorted", "entry_point": "op_div3_square_issorted", "primitives": ["div3", "square", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then return whether the list is sorted ascending.", "solution": "def op_div3_square_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return r == sorted(r)", "tests": "assert op_div3_square_issorted([1, 2, 3, 4]) == True\nassert op_div3_square_issorted([]) == True\nassert op_div3_square_issorted([-2, -1, 0, 1, 2]) == True\nassert op_div3_square_issorted([5, 5, 5]) == True\nassert op_div3_square_issorted([3, 1, 2]) == True\nassert op_div3_square_issorted([10]) == True\nassert op_div3_square_issorted([2, 4, 6]) == True\nassert op_div3_square_issorted([-7, 12, -7]) == True"}
{"id": "op_double_padto3_pos", "entry_point": "op_double_padto3_pos", "primitives": ["double", "padto3", "pos"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements, then keep the positive numbers.", "solution": "def op_double_padto3_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_padto3_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_padto3_pos([]) == []\nassert op_double_padto3_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_double_padto3_pos([5, 5, 5]) == [10, 10, 10]\nassert op_double_padto3_pos([3, 1, 2]) == [6, 2, 4]\nassert op_double_padto3_pos([10]) == [20]\nassert op_double_padto3_pos([2, 4, 6]) == [4, 8, 12]\nassert op_double_padto3_pos([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_uniq_haszero", "entry_point": "op_takewhilepos_uniq_haszero", "primitives": ["takewhilepos", "uniq", "haszero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_takewhilepos_uniq_haszero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_takewhilepos_uniq_haszero([1, 2, 3, 4]) == False\nassert op_takewhilepos_uniq_haszero([]) == False\nassert op_takewhilepos_uniq_haszero([-2, -1, 0, 1, 2]) == False\nassert op_takewhilepos_uniq_haszero([5, 5, 5]) == False\nassert op_takewhilepos_uniq_haszero([3, 1, 2]) == False\nassert op_takewhilepos_uniq_haszero([10]) == False\nassert op_takewhilepos_uniq_haszero([2, 4, 6]) == False\nassert op_takewhilepos_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_sortabs_neg_prod", "entry_point": "op_sortabs_neg_prod", "primitives": ["sortabs", "neg", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then return their product.", "solution": "def op_sortabs_neg_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_neg_prod([1, 2, 3, 4]) == 1\nassert op_sortabs_neg_prod([]) == 1\nassert op_sortabs_neg_prod([-2, -1, 0, 1, 2]) == 2\nassert op_sortabs_neg_prod([5, 5, 5]) == 1\nassert op_sortabs_neg_prod([3, 1, 2]) == 1\nassert op_sortabs_neg_prod([10]) == 1\nassert op_sortabs_neg_prod([2, 4, 6]) == 1\nassert op_sortabs_neg_prod([-7, 12, -7]) == 49"}
{"id": "op_negate_sortabs_trimends", "entry_point": "op_negate_sortabs_trimends", "primitives": ["negate", "sortabs", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then sort by absolute value, then drop the first and last elements.", "solution": "def op_negate_sortabs_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_sortabs_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_negate_sortabs_trimends([]) == []\nassert op_negate_sortabs_trimends([-2, -1, 0, 1, 2]) == [1, -1, 2]\nassert op_negate_sortabs_trimends([5, 5, 5]) == [-5]\nassert op_negate_sortabs_trimends([3, 1, 2]) == [-2]\nassert op_negate_sortabs_trimends([10]) == []\nassert op_negate_sortabs_trimends([2, 4, 6]) == [-4]\nassert op_negate_sortabs_trimends([-7, 12, -7]) == [7]"}
{"id": "op_takewhilepos_oremptyzero_trimends", "entry_point": "op_takewhilepos_oremptyzero_trimends", "primitives": ["takewhilepos", "oremptyzero", "trimends"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_takewhilepos_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_oremptyzero_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_takewhilepos_oremptyzero_trimends([]) == []\nassert op_takewhilepos_oremptyzero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_oremptyzero_trimends([5, 5, 5]) == [5]\nassert op_takewhilepos_oremptyzero_trimends([3, 1, 2]) == [1]\nassert op_takewhilepos_oremptyzero_trimends([10]) == []\nassert op_takewhilepos_oremptyzero_trimends([2, 4, 6]) == [4]\nassert op_takewhilepos_oremptyzero_trimends([-7, 12, -7]) == []"}
{"id": "op_padto3_sortabs_issorted", "entry_point": "op_padto3_sortabs_issorted", "primitives": ["padto3", "sortabs", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_padto3_sortabs_issorted(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_padto3_sortabs_issorted([1, 2, 3, 4]) == True\nassert op_padto3_sortabs_issorted([]) == True\nassert op_padto3_sortabs_issorted([-2, -1, 0, 1, 2]) == False\nassert op_padto3_sortabs_issorted([5, 5, 5]) == True\nassert op_padto3_sortabs_issorted([3, 1, 2]) == True\nassert op_padto3_sortabs_issorted([10]) == True\nassert op_padto3_sortabs_issorted([2, 4, 6]) == True\nassert op_padto3_sortabs_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_oremptyzero_square", "entry_point": "op_uniq_oremptyzero_square", "primitives": ["uniq", "oremptyzero", "square"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then square each.", "solution": "def op_uniq_oremptyzero_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_oremptyzero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_uniq_oremptyzero_square([]) == [0]\nassert op_uniq_oremptyzero_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_uniq_oremptyzero_square([5, 5, 5]) == [25]\nassert op_uniq_oremptyzero_square([3, 1, 2]) == [9, 1, 4]\nassert op_uniq_oremptyzero_square([10]) == [100]\nassert op_uniq_oremptyzero_square([2, 4, 6]) == [4, 16, 36]\nassert op_uniq_oremptyzero_square([-7, 12, -7]) == [49, 144]"}
{"id": "op_rev_div3_dec", "entry_point": "op_rev_div3_dec", "primitives": ["rev", "div3", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then subtract one from each.", "solution": "def op_rev_div3_dec(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_rev_div3_dec([1, 2, 3, 4]) == [2]\nassert op_rev_div3_dec([]) == []\nassert op_rev_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_rev_div3_dec([5, 5, 5]) == []\nassert op_rev_div3_dec([3, 1, 2]) == [2]\nassert op_rev_div3_dec([10]) == []\nassert op_rev_div3_dec([2, 4, 6]) == [5]\nassert op_rev_div3_dec([-7, 12, -7]) == [11]"}
{"id": "op_beforezero_oremptyzero_issorted", "entry_point": "op_beforezero_oremptyzero_issorted", "primitives": ["beforezero", "oremptyzero", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then if empty, use a single zero, then return whether the list is sorted ascending.", "solution": "def op_beforezero_oremptyzero_issorted(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r == sorted(r)", "tests": "assert op_beforezero_oremptyzero_issorted([1, 2, 3, 4]) == True\nassert op_beforezero_oremptyzero_issorted([]) == True\nassert op_beforezero_oremptyzero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_oremptyzero_issorted([5, 5, 5]) == True\nassert op_beforezero_oremptyzero_issorted([3, 1, 2]) == False\nassert op_beforezero_oremptyzero_issorted([10]) == True\nassert op_beforezero_oremptyzero_issorted([2, 4, 6]) == True\nassert op_beforezero_oremptyzero_issorted([-7, 12, -7]) == False"}
{"id": "op_absval_oremptyzero_len", "entry_point": "op_absval_oremptyzero_len", "primitives": ["absval", "oremptyzero", "len"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then if empty, use a single zero, then return how many remain.", "solution": "def op_absval_oremptyzero_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return len(r)", "tests": "assert op_absval_oremptyzero_len([1, 2, 3, 4]) == 4\nassert op_absval_oremptyzero_len([]) == 1\nassert op_absval_oremptyzero_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_oremptyzero_len([5, 5, 5]) == 3\nassert op_absval_oremptyzero_len([3, 1, 2]) == 3\nassert op_absval_oremptyzero_len([10]) == 1\nassert op_absval_oremptyzero_len([2, 4, 6]) == 3\nassert op_absval_oremptyzero_len([-7, 12, -7]) == 3"}
{"id": "op_odds_square_anyeven", "entry_point": "op_odds_square_anyeven", "primitives": ["odds", "square", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then return whether any value is even.", "solution": "def op_odds_square_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_odds_square_anyeven([1, 2, 3, 4]) == False\nassert op_odds_square_anyeven([]) == False\nassert op_odds_square_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_odds_square_anyeven([5, 5, 5]) == False\nassert op_odds_square_anyeven([3, 1, 2]) == False\nassert op_odds_square_anyeven([10]) == False\nassert op_odds_square_anyeven([2, 4, 6]) == False\nassert op_odds_square_anyeven([-7, 12, -7]) == False"}
{"id": "op_odds_padto3_max", "entry_point": "op_odds_padto3_max", "primitives": ["odds", "padto3", "max"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements, then return the maximum (0 if empty).", "solution": "def op_odds_padto3_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return max(r) if r else 0", "tests": "assert op_odds_padto3_max([1, 2, 3, 4]) == 3\nassert op_odds_padto3_max([]) == 0\nassert op_odds_padto3_max([-2, -1, 0, 1, 2]) == 1\nassert op_odds_padto3_max([5, 5, 5]) == 5\nassert op_odds_padto3_max([3, 1, 2]) == 3\nassert op_odds_padto3_max([10]) == 0\nassert op_odds_padto3_max([2, 4, 6]) == 0\nassert op_odds_padto3_max([-7, 12, -7]) == 0"}
{"id": "op_pos_double_beforezero", "entry_point": "op_pos_double_beforezero", "primitives": ["pos", "double", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then keep everything before the first zero.", "solution": "def op_pos_double_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_double_beforezero([]) == []\nassert op_pos_double_beforezero([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_pos_double_beforezero([10]) == [20]\nassert op_pos_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_pos_double_beforezero([-7, 12, -7]) == [24]"}
{"id": "op_double_dropzeros_firsteven", "entry_point": "op_double_dropzeros_firsteven", "primitives": ["double", "dropzeros", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then return the first even value (0 if none).", "solution": "def op_double_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_dropzeros_firsteven([1, 2, 3, 4]) == 2\nassert op_double_dropzeros_firsteven([]) == 0\nassert op_double_dropzeros_firsteven([-2, -1, 0, 1, 2]) == -4\nassert op_double_dropzeros_firsteven([5, 5, 5]) == 10\nassert op_double_dropzeros_firsteven([3, 1, 2]) == 6\nassert op_double_dropzeros_firsteven([10]) == 20\nassert op_double_dropzeros_firsteven([2, 4, 6]) == 4\nassert op_double_dropzeros_firsteven([-7, 12, -7]) == -14"}
{"id": "op_uniq_oremptyzero_neg", "entry_point": "op_uniq_oremptyzero_neg", "primitives": ["uniq", "oremptyzero", "neg"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then keep the negative numbers.", "solution": "def op_uniq_oremptyzero_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_oremptyzero_neg([1, 2, 3, 4]) == []\nassert op_uniq_oremptyzero_neg([]) == []\nassert op_uniq_oremptyzero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_oremptyzero_neg([5, 5, 5]) == []\nassert op_uniq_oremptyzero_neg([3, 1, 2]) == []\nassert op_uniq_oremptyzero_neg([10]) == []\nassert op_uniq_oremptyzero_neg([2, 4, 6]) == []\nassert op_uniq_oremptyzero_neg([-7, 12, -7]) == [-7]"}
{"id": "op_square_takewhilepos_beforezero", "entry_point": "op_square_takewhilepos_beforezero", "primitives": ["square", "takewhilepos", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_square_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_square_takewhilepos_beforezero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos_beforezero([]) == []\nassert op_square_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_takewhilepos_beforezero([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_beforezero([3, 1, 2]) == [9, 1, 4]\nassert op_square_takewhilepos_beforezero([10]) == [100]\nassert op_square_takewhilepos_beforezero([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_beforezero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_ages_negate_len", "entry_point": "op_ages_negate_len", "primitives": ["ages", "negate", "len"], "difficulty": 2, "split": "train", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then return how many remain.", "solution": "def op_ages_negate_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_ages_negate_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_negate_len([]) == 0\nassert op_ages_negate_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_negate_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_sorta_beforezero_firsteven", "entry_point": "op_sorta_beforezero_firsteven", "primitives": ["sorta", "beforezero", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_sorta_beforezero_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_beforezero_firsteven([]) == 0\nassert op_sorta_beforezero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_beforezero_firsteven([5, 5, 5]) == 0\nassert op_sorta_beforezero_firsteven([3, 1, 2]) == 2\nassert op_sorta_beforezero_firsteven([10]) == 10\nassert op_sorta_beforezero_firsteven([2, 4, 6]) == 2\nassert op_sorta_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_uniq_inc_oremptyzero", "entry_point": "op_uniq_inc_oremptyzero", "primitives": ["uniq", "inc", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then if empty, use a single zero.", "solution": "def op_uniq_inc_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_inc_oremptyzero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_uniq_inc_oremptyzero([]) == [0]\nassert op_uniq_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_uniq_inc_oremptyzero([5, 5, 5]) == [6]\nassert op_uniq_inc_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_uniq_inc_oremptyzero([10]) == [11]\nassert op_uniq_inc_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_uniq_inc_oremptyzero([-7, 12, -7]) == [-6, 13]"}
{"id": "op_absval_evens_anyeven", "entry_point": "op_absval_evens_anyeven", "primitives": ["absval", "evens", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then return whether any value is even.", "solution": "def op_absval_evens_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_evens_anyeven([1, 2, 3, 4]) == True\nassert op_absval_evens_anyeven([]) == False\nassert op_absval_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_evens_anyeven([5, 5, 5]) == False\nassert op_absval_evens_anyeven([3, 1, 2]) == True\nassert op_absval_evens_anyeven([10]) == True\nassert op_absval_evens_anyeven([2, 4, 6]) == True\nassert op_absval_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_rev_padto3", "entry_point": "op_clamp10_rev_padto3", "primitives": ["clamp10", "rev", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then pad with zeros to at least three elements.", "solution": "def op_clamp10_rev_padto3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_clamp10_rev_padto3([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_rev_padto3([]) == [0, 0, 0]\nassert op_clamp10_rev_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_rev_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_rev_padto3([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_rev_padto3([10]) == [10, 0, 0]\nassert op_clamp10_rev_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_rev_padto3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_clamp10_dec_anyeven", "entry_point": "op_clamp10_dec_anyeven", "primitives": ["clamp10", "dec", "anyeven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then return whether any value is even.", "solution": "def op_clamp10_dec_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_dec_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_dec_anyeven([]) == False\nassert op_clamp10_dec_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_dec_anyeven([5, 5, 5]) == True\nassert op_clamp10_dec_anyeven([3, 1, 2]) == True\nassert op_clamp10_dec_anyeven([10]) == False\nassert op_clamp10_dec_anyeven([2, 4, 6]) == False\nassert op_clamp10_dec_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_div3_firsteven", "entry_point": "op_negate_div3_firsteven", "primitives": ["negate", "div3", "firsteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then return the first even value (0 if none).", "solution": "def op_negate_div3_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_div3_firsteven([1, 2, 3, 4]) == 0\nassert op_negate_div3_firsteven([]) == 0\nassert op_negate_div3_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_negate_div3_firsteven([5, 5, 5]) == 0\nassert op_negate_div3_firsteven([3, 1, 2]) == 0\nassert op_negate_div3_firsteven([10]) == 0\nassert op_negate_div3_firsteven([2, 4, 6]) == -6\nassert op_negate_div3_firsteven([-7, 12, -7]) == -12"}
{"id": "op_beforezero_square_sum", "entry_point": "op_beforezero_square_sum", "primitives": ["beforezero", "square", "sum"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then square each, then return their sum.", "solution": "def op_beforezero_square_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_beforezero_square_sum([1, 2, 3, 4]) == 30\nassert op_beforezero_square_sum([]) == 0\nassert op_beforezero_square_sum([-2, -1, 0, 1, 2]) == 5\nassert op_beforezero_square_sum([5, 5, 5]) == 75\nassert op_beforezero_square_sum([3, 1, 2]) == 14\nassert op_beforezero_square_sum([10]) == 100\nassert op_beforezero_square_sum([2, 4, 6]) == 56\nassert op_beforezero_square_sum([-7, 12, -7]) == 242"}
{"id": "op_takewhilepos_double_min", "entry_point": "op_takewhilepos_double_min", "primitives": ["takewhilepos", "double", "min"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_double_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_double_min([1, 2, 3, 4]) == 2\nassert op_takewhilepos_double_min([]) == 0\nassert op_takewhilepos_double_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_double_min([5, 5, 5]) == 10\nassert op_takewhilepos_double_min([3, 1, 2]) == 2\nassert op_takewhilepos_double_min([10]) == 20\nassert op_takewhilepos_double_min([2, 4, 6]) == 4\nassert op_takewhilepos_double_min([-7, 12, -7]) == 0"}
{"id": "op_gt5_sorta_sortd", "entry_point": "op_gt5_sorta_sortd", "primitives": ["gt5", "sorta", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then sort descending.", "solution": "def op_gt5_sorta_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_sorta_sortd([1, 2, 3, 4]) == []\nassert op_gt5_sorta_sortd([]) == []\nassert op_gt5_sorta_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_sortd([5, 5, 5]) == []\nassert op_gt5_sorta_sortd([3, 1, 2]) == []\nassert op_gt5_sorta_sortd([10]) == [10]\nassert op_gt5_sorta_sortd([2, 4, 6]) == [6]\nassert op_gt5_sorta_sortd([-7, 12, -7]) == [12]"}
{"id": "op_inc_add10_beforezero", "entry_point": "op_inc_add10_beforezero", "primitives": ["inc", "add10", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then keep everything before the first zero.", "solution": "def op_inc_add10_beforezero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_inc_add10_beforezero([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_inc_add10_beforezero([]) == []\nassert op_inc_add10_beforezero([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_inc_add10_beforezero([5, 5, 5]) == [16, 16, 16]\nassert op_inc_add10_beforezero([3, 1, 2]) == [14, 12, 13]\nassert op_inc_add10_beforezero([10]) == [21]\nassert op_inc_add10_beforezero([2, 4, 6]) == [13, 15, 17]\nassert op_inc_add10_beforezero([-7, 12, -7]) == [4, 23, 4]"}
{"id": "op_uniq_gt5_inc", "entry_point": "op_uniq_gt5_inc", "primitives": ["uniq", "gt5", "inc"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then add one to each.", "solution": "def op_uniq_gt5_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_gt5_inc([1, 2, 3, 4]) == []\nassert op_uniq_gt5_inc([]) == []\nassert op_uniq_gt5_inc([-2, -1, 0, 1, 2]) == []\nassert op_uniq_gt5_inc([5, 5, 5]) == []\nassert op_uniq_gt5_inc([3, 1, 2]) == []\nassert op_uniq_gt5_inc([10]) == [11]\nassert op_uniq_gt5_inc([2, 4, 6]) == [7]\nassert op_uniq_gt5_inc([-7, 12, -7]) == [13]"}
{"id": "op_negate_dropwhileneg_prod", "entry_point": "op_negate_dropwhileneg_prod", "primitives": ["negate", "dropwhileneg", "prod"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then return their product.", "solution": "def op_negate_dropwhileneg_prod(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return __import__('math').prod(r)", "tests": "assert op_negate_dropwhileneg_prod([1, 2, 3, 4]) == 1\nassert op_negate_dropwhileneg_prod([]) == 1\nassert op_negate_dropwhileneg_prod([-2, -1, 0, 1, 2]) == 0\nassert op_negate_dropwhileneg_prod([5, 5, 5]) == 1\nassert op_negate_dropwhileneg_prod([3, 1, 2]) == 1\nassert op_negate_dropwhileneg_prod([10]) == 1\nassert op_negate_dropwhileneg_prod([2, 4, 6]) == 1\nassert op_negate_dropwhileneg_prod([-7, 12, -7]) == -588"}
{"id": "op_sortabs_sorta_oremptyzero", "entry_point": "op_sortabs_sorta_oremptyzero", "primitives": ["sortabs", "sorta", "oremptyzero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then if empty, use a single zero.", "solution": "def op_sortabs_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_sortabs_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_sorta_oremptyzero([]) == [0]\nassert op_sortabs_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortabs_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_sorta_oremptyzero([10]) == [10]\nassert op_sortabs_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_inc_padto3", "entry_point": "op_sortabs_inc_padto3", "primitives": ["sortabs", "inc", "padto3"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then pad with zeros to at least three elements.", "solution": "def op_sortabs_inc_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_inc_padto3([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sortabs_inc_padto3([]) == [0, 0, 0]\nassert op_sortabs_inc_padto3([-2, -1, 0, 1, 2]) == [1, 0, 2, -1, 3]\nassert op_sortabs_inc_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_inc_padto3([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_inc_padto3([10]) == [11, 0, 0]\nassert op_sortabs_inc_padto3([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_inc_padto3([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_trimends_pos_issorted", "entry_point": "op_trimends_pos_issorted", "primitives": ["trimends", "pos", "issorted"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then return whether the list is sorted ascending.", "solution": "def op_trimends_pos_issorted(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r == sorted(r)", "tests": "assert op_trimends_pos_issorted([1, 2, 3, 4]) == True\nassert op_trimends_pos_issorted([]) == True\nassert op_trimends_pos_issorted([-2, -1, 0, 1, 2]) == True\nassert op_trimends_pos_issorted([5, 5, 5]) == True\nassert op_trimends_pos_issorted([3, 1, 2]) == True\nassert op_trimends_pos_issorted([10]) == True\nassert op_trimends_pos_issorted([2, 4, 6]) == True\nassert op_trimends_pos_issorted([-7, 12, -7]) == True"}
{"id": "op_nonempty_prefixup_dropshort", "entry_point": "op_nonempty_prefixup_dropshort", "primitives": ["nonempty", "prefixup", "dropshort"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then prefix each with a hash, then drop strings shorter than three characters.", "solution": "def op_nonempty_prefixup_dropshort(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_nonempty_prefixup_dropshort(['Hello', 'world']) == ['#Hello', '#world']\nassert op_nonempty_prefixup_dropshort([]) == []\nassert op_nonempty_prefixup_dropshort(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_nonempty_prefixup_dropshort(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_nonempty_prefixup_dropshort(['x']) == []\nassert op_nonempty_prefixup_dropshort(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_clamp10_dropfirst_beforezero", "entry_point": "op_clamp10_dropfirst_beforezero", "primitives": ["clamp10", "dropfirst", "beforezero"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first element, then keep everything before the first zero.", "solution": "def op_clamp10_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_clamp10_dropfirst_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_dropfirst_beforezero([]) == []\nassert op_clamp10_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_clamp10_dropfirst_beforezero([5, 5, 5]) == [5, 5]\nassert op_clamp10_dropfirst_beforezero([3, 1, 2]) == [1, 2]\nassert op_clamp10_dropfirst_beforezero([10]) == []\nassert op_clamp10_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_clamp10_dropfirst_beforezero([-7, 12, -7]) == [10, -7]"}
{"id": "op_negate_first3_sortd", "entry_point": "op_negate_first3_sortd", "primitives": ["negate", "first3", "sortd"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three, then sort descending.", "solution": "def op_negate_first3_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_first3_sortd([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_first3_sortd([]) == []\nassert op_negate_first3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_negate_first3_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_first3_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_first3_sortd([10]) == [-10]\nassert op_negate_first3_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_first3_sortd([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_gt5_neg_counteven", "entry_point": "op_gt5_neg_counteven", "primitives": ["gt5", "neg", "counteven"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then return how many values are even.", "solution": "def op_gt5_neg_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_neg_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_neg_counteven([]) == 0\nassert op_gt5_neg_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_neg_counteven([5, 5, 5]) == 0\nassert op_gt5_neg_counteven([3, 1, 2]) == 0\nassert op_gt5_neg_counteven([10]) == 0\nassert op_gt5_neg_counteven([2, 4, 6]) == 0\nassert op_gt5_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_div3_inc_odds", "entry_point": "op_div3_inc_odds", "primitives": ["div3", "inc", "odds"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then keep the odd numbers.", "solution": "def op_div3_inc_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_inc_odds([1, 2, 3, 4]) == []\nassert op_div3_inc_odds([]) == []\nassert op_div3_inc_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_div3_inc_odds([5, 5, 5]) == []\nassert op_div3_inc_odds([3, 1, 2]) == []\nassert op_div3_inc_odds([10]) == []\nassert op_div3_inc_odds([2, 4, 6]) == [7]\nassert op_div3_inc_odds([-7, 12, -7]) == [13]"}
{"id": "op_prefixup_upper_nonempty", "entry_point": "op_prefixup_upper_nonempty", "primitives": ["prefixup", "upper", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then uppercase each string, then drop empty strings.", "solution": "def op_prefixup_upper_nonempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_prefixup_upper_nonempty(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_prefixup_upper_nonempty([]) == []\nassert op_prefixup_upper_nonempty(['  a ', '', 'BC', 'bc']) == ['#  A ', '#', '#BC', '#BC']\nassert op_prefixup_upper_nonempty(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_prefixup_upper_nonempty(['x']) == ['#X']\nassert op_prefixup_upper_nonempty(['abc', 'de', '']) == ['#ABC', '#DE', '#']"}
{"id": "op_sortlen_upper_nonempty", "entry_point": "op_sortlen_upper_nonempty", "primitives": ["sortlen", "upper", "nonempty"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then uppercase each string, then drop empty strings.", "solution": "def op_sortlen_upper_nonempty(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_sortlen_upper_nonempty(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortlen_upper_nonempty([]) == []\nassert op_sortlen_upper_nonempty(['  a ', '', 'BC', 'bc']) == ['BC', 'BC', '  A ']\nassert op_sortlen_upper_nonempty(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_sortlen_upper_nonempty(['x']) == ['X']\nassert op_sortlen_upper_nonempty(['abc', 'de', '']) == ['DE', 'ABC']"}
{"id": "op_last3_clamp10_dec", "entry_point": "op_last3_clamp10_dec", "primitives": ["last3", "clamp10", "dec"], "difficulty": 2, "split": "train", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then subtract one from each.", "solution": "def op_last3_clamp10_dec(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_last3_clamp10_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_clamp10_dec([]) == []\nassert op_last3_clamp10_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_last3_clamp10_dec([5, 5, 5]) == [4, 4, 4]\nassert op_last3_clamp10_dec([3, 1, 2]) == [2, 0, 1]\nassert op_last3_clamp10_dec([10]) == [9]\nassert op_last3_clamp10_dec([2, 4, 6]) == [1, 3, 5]\nassert op_last3_clamp10_dec([-7, 12, -7]) == [-8, 9, -8]"}
{"id": "op_sortlen_prefixup_uniqs", "entry_point": "op_sortlen_prefixup_uniqs", "primitives": ["sortlen", "prefixup", "uniqs"], "difficulty": 2, "split": "train", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then prefix each with a hash, then drop duplicate strings keeping the first.", "solution": "def op_sortlen_prefixup_uniqs(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortlen_prefixup_uniqs(['Hello', 'world']) == ['#Hello', '#world']\nassert op_sortlen_prefixup_uniqs([]) == []\nassert op_sortlen_prefixup_uniqs(['  a ', '', 'BC', 'bc']) == ['#', '#BC', '#bc', '#  a ']\nassert op_sortlen_prefixup_uniqs(['one', 'one', 'Two']) == ['#one', '#Two']\nassert op_sortlen_prefixup_uniqs(['x']) == ['#x']\nassert op_sortlen_prefixup_uniqs(['abc', 'de', '']) == ['#', '#de', '#abc']"}
{"id": "op_evens_last3_sortabs", "entry_point": "op_evens_last3_sortabs", "primitives": ["evens", "last3", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then sort by absolute value.", "solution": "def op_evens_last3_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_evens_last3_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_evens_last3_sortabs([]) == []\nassert op_evens_last3_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_evens_last3_sortabs([5, 5, 5]) == []\nassert op_evens_last3_sortabs([3, 1, 2]) == [2]\nassert op_evens_last3_sortabs([10]) == [10]\nassert op_evens_last3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_evens_last3_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_rev_dropwhileneg_negate", "entry_point": "op_rev_dropwhileneg_negate", "primitives": ["rev", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then negate each.", "solution": "def op_rev_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_rev_dropwhileneg_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_rev_dropwhileneg_negate([]) == []\nassert op_rev_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_rev_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_rev_dropwhileneg_negate([3, 1, 2]) == [-2, -1, -3]\nassert op_rev_dropwhileneg_negate([10]) == [-10]\nassert op_rev_dropwhileneg_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_rev_dropwhileneg_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_pos_uniq_counteven", "entry_point": "op_pos_uniq_counteven", "primitives": ["pos", "uniq", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_pos_uniq_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_pos_uniq_counteven([1, 2, 3, 4]) == 2\nassert op_pos_uniq_counteven([]) == 0\nassert op_pos_uniq_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_pos_uniq_counteven([5, 5, 5]) == 0\nassert op_pos_uniq_counteven([3, 1, 2]) == 1\nassert op_pos_uniq_counteven([10]) == 1\nassert op_pos_uniq_counteven([2, 4, 6]) == 3\nassert op_pos_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_dec_min", "entry_point": "op_rev_dec_min", "primitives": ["rev", "dec", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then subtract one from each, then return the minimum (0 if empty).", "solution": "def op_rev_dec_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_rev_dec_min([1, 2, 3, 4]) == 0\nassert op_rev_dec_min([]) == 0\nassert op_rev_dec_min([-2, -1, 0, 1, 2]) == -3\nassert op_rev_dec_min([5, 5, 5]) == 4\nassert op_rev_dec_min([3, 1, 2]) == 0\nassert op_rev_dec_min([10]) == 9\nassert op_rev_dec_min([2, 4, 6]) == 1\nassert op_rev_dec_min([-7, 12, -7]) == -8"}
{"id": "op_dropwhileneg_first3_sum", "entry_point": "op_dropwhileneg_first3_sum", "primitives": ["dropwhileneg", "first3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then return their sum.", "solution": "def op_dropwhileneg_first3_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return sum(r)", "tests": "assert op_dropwhileneg_first3_sum([1, 2, 3, 4]) == 6\nassert op_dropwhileneg_first3_sum([]) == 0\nassert op_dropwhileneg_first3_sum([-2, -1, 0, 1, 2]) == 3\nassert op_dropwhileneg_first3_sum([5, 5, 5]) == 15\nassert op_dropwhileneg_first3_sum([3, 1, 2]) == 6\nassert op_dropwhileneg_first3_sum([10]) == 10\nassert op_dropwhileneg_first3_sum([2, 4, 6]) == 12\nassert op_dropwhileneg_first3_sum([-7, 12, -7]) == 5"}
{"id": "op_takewhilepos_rev_min", "entry_point": "op_takewhilepos_rev_min", "primitives": ["takewhilepos", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_rev_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_rev_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_rev_min([]) == 0\nassert op_takewhilepos_rev_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_rev_min([5, 5, 5]) == 5\nassert op_takewhilepos_rev_min([3, 1, 2]) == 1\nassert op_takewhilepos_rev_min([10]) == 10\nassert op_takewhilepos_rev_min([2, 4, 6]) == 2\nassert op_takewhilepos_rev_min([-7, 12, -7]) == 0"}
{"id": "op_square_clamp10_oremptyzero", "entry_point": "op_square_clamp10_oremptyzero", "primitives": ["square", "clamp10", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_square_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_square_clamp10_oremptyzero([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_square_clamp10_oremptyzero([]) == [0]\nassert op_square_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_clamp10_oremptyzero([5, 5, 5]) == [10, 10, 10]\nassert op_square_clamp10_oremptyzero([3, 1, 2]) == [9, 1, 4]\nassert op_square_clamp10_oremptyzero([10]) == [10]\nassert op_square_clamp10_oremptyzero([2, 4, 6]) == [4, 10, 10]\nassert op_square_clamp10_oremptyzero([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_sortabs_dropzeros_dec", "entry_point": "op_sortabs_dropzeros_dec", "primitives": ["sortabs", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then subtract one from each.", "solution": "def op_sortabs_dropzeros_dec(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortabs_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortabs_dropzeros_dec([]) == []\nassert op_sortabs_dropzeros_dec([-2, -1, 0, 1, 2]) == [-2, 0, -3, 1]\nassert op_sortabs_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_dropzeros_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sortabs_dropzeros_dec([10]) == [9]\nassert op_sortabs_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sortabs_dropzeros_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_gt5_square_max", "entry_point": "op_gt5_square_max", "primitives": ["gt5", "square", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then square each, then return the maximum (0 if empty).", "solution": "def op_gt5_square_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_gt5_square_max([1, 2, 3, 4]) == 0\nassert op_gt5_square_max([]) == 0\nassert op_gt5_square_max([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_square_max([5, 5, 5]) == 0\nassert op_gt5_square_max([3, 1, 2]) == 0\nassert op_gt5_square_max([10]) == 100\nassert op_gt5_square_max([2, 4, 6]) == 36\nassert op_gt5_square_max([-7, 12, -7]) == 144"}
{"id": "op_first3_oremptyzero_trimends", "entry_point": "op_first3_oremptyzero_trimends", "primitives": ["first3", "oremptyzero", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_first3_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_first3_oremptyzero_trimends([1, 2, 3, 4]) == [2]\nassert op_first3_oremptyzero_trimends([]) == []\nassert op_first3_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_oremptyzero_trimends([5, 5, 5]) == [5]\nassert op_first3_oremptyzero_trimends([3, 1, 2]) == [1]\nassert op_first3_oremptyzero_trimends([10]) == []\nassert op_first3_oremptyzero_trimends([2, 4, 6]) == [4]\nassert op_first3_oremptyzero_trimends([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_negate_absval", "entry_point": "op_dropfirst_negate_absval", "primitives": ["dropfirst", "negate", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then take the absolute value of each.", "solution": "def op_dropfirst_negate_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_negate_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_negate_absval([]) == []\nassert op_dropfirst_negate_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_dropfirst_negate_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_negate_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_negate_absval([10]) == []\nassert op_dropfirst_negate_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_negate_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_odds_sortabs_last3", "entry_point": "op_odds_sortabs_last3", "primitives": ["odds", "sortabs", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then keep only the last three.", "solution": "def op_odds_sortabs_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return r", "tests": "assert op_odds_sortabs_last3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sortabs_last3([]) == []\nassert op_odds_sortabs_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_sortabs_last3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortabs_last3([3, 1, 2]) == [1, 3]\nassert op_odds_sortabs_last3([10]) == []\nassert op_odds_sortabs_last3([2, 4, 6]) == []\nassert op_odds_sortabs_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_trimends_gt5_add10", "entry_point": "op_trimends_gt5_add10", "primitives": ["trimends", "gt5", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep values greater than five, then add ten to each.", "solution": "def op_trimends_gt5_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_gt5_add10([1, 2, 3, 4]) == []\nassert op_trimends_gt5_add10([]) == []\nassert op_trimends_gt5_add10([-2, -1, 0, 1, 2]) == []\nassert op_trimends_gt5_add10([5, 5, 5]) == []\nassert op_trimends_gt5_add10([3, 1, 2]) == []\nassert op_trimends_gt5_add10([10]) == []\nassert op_trimends_gt5_add10([2, 4, 6]) == []\nassert op_trimends_gt5_add10([-7, 12, -7]) == [22]"}
{"id": "op_dropzeros_inc_max", "entry_point": "op_dropzeros_inc_max", "primitives": ["dropzeros", "inc", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then return the maximum (0 if empty).", "solution": "def op_dropzeros_inc_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_inc_max([1, 2, 3, 4]) == 5\nassert op_dropzeros_inc_max([]) == 0\nassert op_dropzeros_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_dropzeros_inc_max([5, 5, 5]) == 6\nassert op_dropzeros_inc_max([3, 1, 2]) == 4\nassert op_dropzeros_inc_max([10]) == 11\nassert op_dropzeros_inc_max([2, 4, 6]) == 7\nassert op_dropzeros_inc_max([-7, 12, -7]) == 13"}
{"id": "op_sortd_neg_pos", "entry_point": "op_sortd_neg_pos", "primitives": ["sortd", "neg", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then keep the positive numbers.", "solution": "def op_sortd_neg_pos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortd_neg_pos([1, 2, 3, 4]) == []\nassert op_sortd_neg_pos([]) == []\nassert op_sortd_neg_pos([-2, -1, 0, 1, 2]) == []\nassert op_sortd_neg_pos([5, 5, 5]) == []\nassert op_sortd_neg_pos([3, 1, 2]) == []\nassert op_sortd_neg_pos([10]) == []\nassert op_sortd_neg_pos([2, 4, 6]) == []\nassert op_sortd_neg_pos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_dropwhileneg_neg", "entry_point": "op_dropfirst_dropwhileneg_neg", "primitives": ["dropfirst", "dropwhileneg", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_dropfirst_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_dropfirst_dropwhileneg_neg([]) == []\nassert op_dropfirst_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_dropwhileneg_neg([5, 5, 5]) == []\nassert op_dropfirst_dropwhileneg_neg([3, 1, 2]) == []\nassert op_dropfirst_dropwhileneg_neg([10]) == []\nassert op_dropfirst_dropwhileneg_neg([2, 4, 6]) == []\nassert op_dropfirst_dropwhileneg_neg([-7, 12, -7]) == [-7]"}
{"id": "op_square_oremptyzero_allpos", "entry_point": "op_square_oremptyzero_allpos", "primitives": ["square", "oremptyzero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_square_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_square_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_square_oremptyzero_allpos([]) == False\nassert op_square_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_square_oremptyzero_allpos([5, 5, 5]) == True\nassert op_square_oremptyzero_allpos([3, 1, 2]) == True\nassert op_square_oremptyzero_allpos([10]) == True\nassert op_square_oremptyzero_allpos([2, 4, 6]) == True\nassert op_square_oremptyzero_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_takewhilepos_first3", "entry_point": "op_sorta_takewhilepos_first3", "primitives": ["sorta", "takewhilepos", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then keep only the first three.", "solution": "def op_sorta_takewhilepos_first3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_sorta_takewhilepos_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_takewhilepos_first3([]) == []\nassert op_sorta_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_takewhilepos_first3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_takewhilepos_first3([10]) == [10]\nassert op_sorta_takewhilepos_first3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_neg_oremptyzero_padto3", "entry_point": "op_neg_oremptyzero_padto3", "primitives": ["neg", "oremptyzero", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_neg_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_oremptyzero_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_neg_oremptyzero_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([10]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_oremptyzero_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_neg_add10_sum", "entry_point": "op_neg_add10_sum", "primitives": ["neg", "add10", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then return their sum.", "solution": "def op_neg_add10_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_neg_add10_sum([1, 2, 3, 4]) == 0\nassert op_neg_add10_sum([]) == 0\nassert op_neg_add10_sum([-2, -1, 0, 1, 2]) == 17\nassert op_neg_add10_sum([5, 5, 5]) == 0\nassert op_neg_add10_sum([3, 1, 2]) == 0\nassert op_neg_add10_sum([10]) == 0\nassert op_neg_add10_sum([2, 4, 6]) == 0\nassert op_neg_add10_sum([-7, 12, -7]) == 6"}
{"id": "op_dec_beforezero_odds", "entry_point": "op_dec_beforezero_odds", "primitives": ["dec", "beforezero", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_dec_beforezero_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_beforezero_odds([1, 2, 3, 4]) == []\nassert op_dec_beforezero_odds([]) == []\nassert op_dec_beforezero_odds([-2, -1, 0, 1, 2]) == [-3, -1]\nassert op_dec_beforezero_odds([5, 5, 5]) == []\nassert op_dec_beforezero_odds([3, 1, 2]) == []\nassert op_dec_beforezero_odds([10]) == [9]\nassert op_dec_beforezero_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_beforezero_odds([-7, 12, -7]) == [11]"}
{"id": "op_takewhilepos_trimends_dec", "entry_point": "op_takewhilepos_trimends_dec", "primitives": ["takewhilepos", "trimends", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then subtract one from each.", "solution": "def op_takewhilepos_trimends_dec(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_trimends_dec([1, 2, 3, 4]) == [1, 2]\nassert op_takewhilepos_trimends_dec([]) == []\nassert op_takewhilepos_trimends_dec([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_trimends_dec([5, 5, 5]) == [4]\nassert op_takewhilepos_trimends_dec([3, 1, 2]) == [0]\nassert op_takewhilepos_trimends_dec([10]) == []\nassert op_takewhilepos_trimends_dec([2, 4, 6]) == [3]\nassert op_takewhilepos_trimends_dec([-7, 12, -7]) == []"}
{"id": "op_div3_dec_firsteven", "entry_point": "op_div3_dec_firsteven", "primitives": ["div3", "dec", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each, then return the first even value (0 if none).", "solution": "def op_div3_dec_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_dec_firsteven([1, 2, 3, 4]) == 2\nassert op_div3_dec_firsteven([]) == 0\nassert op_div3_dec_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_dec_firsteven([5, 5, 5]) == 0\nassert op_div3_dec_firsteven([3, 1, 2]) == 2\nassert op_div3_dec_firsteven([10]) == 0\nassert op_div3_dec_firsteven([2, 4, 6]) == 0\nassert op_div3_dec_firsteven([-7, 12, -7]) == 0"}
{"id": "op_trimends_uniq_double", "entry_point": "op_trimends_uniq_double", "primitives": ["trimends", "uniq", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then double each.", "solution": "def op_trimends_uniq_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_uniq_double([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_uniq_double([]) == []\nassert op_trimends_uniq_double([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_trimends_uniq_double([5, 5, 5]) == [10]\nassert op_trimends_uniq_double([3, 1, 2]) == [2]\nassert op_trimends_uniq_double([10]) == []\nassert op_trimends_uniq_double([2, 4, 6]) == [8]\nassert op_trimends_uniq_double([-7, 12, -7]) == [24]"}
{"id": "op_evens_beforezero_dropzeros", "entry_point": "op_evens_beforezero_dropzeros", "primitives": ["evens", "beforezero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then drop the zeros.", "solution": "def op_evens_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_evens_beforezero_dropzeros([1, 2, 3, 4]) == [2, 4]\nassert op_evens_beforezero_dropzeros([]) == []\nassert op_evens_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_beforezero_dropzeros([5, 5, 5]) == []\nassert op_evens_beforezero_dropzeros([3, 1, 2]) == [2]\nassert op_evens_beforezero_dropzeros([10]) == [10]\nassert op_evens_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_evens_beforezero_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_inc_rev_sortabs", "entry_point": "op_inc_rev_sortabs", "primitives": ["inc", "rev", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then sort by absolute value.", "solution": "def op_inc_rev_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_rev_sortabs([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_rev_sortabs([]) == []\nassert op_inc_rev_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, 3]\nassert op_inc_rev_sortabs([5, 5, 5]) == [6, 6, 6]\nassert op_inc_rev_sortabs([3, 1, 2]) == [2, 3, 4]\nassert op_inc_rev_sortabs([10]) == [11]\nassert op_inc_rev_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_inc_rev_sortabs([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_evens_dropfirst_len", "entry_point": "op_evens_dropfirst_len", "primitives": ["evens", "dropfirst", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then return how many remain.", "solution": "def op_evens_dropfirst_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    return len(r)", "tests": "assert op_evens_dropfirst_len([1, 2, 3, 4]) == 1\nassert op_evens_dropfirst_len([]) == 0\nassert op_evens_dropfirst_len([-2, -1, 0, 1, 2]) == 2\nassert op_evens_dropfirst_len([5, 5, 5]) == 0\nassert op_evens_dropfirst_len([3, 1, 2]) == 0\nassert op_evens_dropfirst_len([10]) == 0\nassert op_evens_dropfirst_len([2, 4, 6]) == 2\nassert op_evens_dropfirst_len([-7, 12, -7]) == 0"}
{"id": "op_trimends_sorta_min", "entry_point": "op_trimends_sorta_min", "primitives": ["trimends", "sorta", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending, then return the minimum (0 if empty).", "solution": "def op_trimends_sorta_min(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    return min(r) if r else 0", "tests": "assert op_trimends_sorta_min([1, 2, 3, 4]) == 2\nassert op_trimends_sorta_min([]) == 0\nassert op_trimends_sorta_min([-2, -1, 0, 1, 2]) == -1\nassert op_trimends_sorta_min([5, 5, 5]) == 5\nassert op_trimends_sorta_min([3, 1, 2]) == 1\nassert op_trimends_sorta_min([10]) == 0\nassert op_trimends_sorta_min([2, 4, 6]) == 4\nassert op_trimends_sorta_min([-7, 12, -7]) == 12"}
{"id": "op_padto3_sorta_dropfirst", "entry_point": "op_padto3_sorta_dropfirst", "primitives": ["padto3", "sorta", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then drop the first element.", "solution": "def op_padto3_sorta_dropfirst(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = r[1:]\n    return r", "tests": "assert op_padto3_sorta_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_sorta_dropfirst([]) == [0, 0]\nassert op_padto3_sorta_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_padto3_sorta_dropfirst([5, 5, 5]) == [5, 5]\nassert op_padto3_sorta_dropfirst([3, 1, 2]) == [2, 3]\nassert op_padto3_sorta_dropfirst([10]) == [0, 10]\nassert op_padto3_sorta_dropfirst([2, 4, 6]) == [4, 6]\nassert op_padto3_sorta_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_trimends_pos_sortabs", "entry_point": "op_trimends_pos_sortabs", "primitives": ["trimends", "pos", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then sort by absolute value.", "solution": "def op_trimends_pos_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_pos_sortabs([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_pos_sortabs([]) == []\nassert op_trimends_pos_sortabs([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_pos_sortabs([5, 5, 5]) == [5]\nassert op_trimends_pos_sortabs([3, 1, 2]) == [1]\nassert op_trimends_pos_sortabs([10]) == []\nassert op_trimends_pos_sortabs([2, 4, 6]) == [4]\nassert op_trimends_pos_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_add10_div3_square", "entry_point": "op_add10_div3_square", "primitives": ["add10", "div3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then square each.", "solution": "def op_add10_div3_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_div3_square([1, 2, 3, 4]) == [144]\nassert op_add10_div3_square([]) == []\nassert op_add10_div3_square([-2, -1, 0, 1, 2]) == [81, 144]\nassert op_add10_div3_square([5, 5, 5]) == [225, 225, 225]\nassert op_add10_div3_square([3, 1, 2]) == [144]\nassert op_add10_div3_square([10]) == []\nassert op_add10_div3_square([2, 4, 6]) == [144]\nassert op_add10_div3_square([-7, 12, -7]) == [9, 9]"}
{"id": "op_oremptyzero_double_gt5", "entry_point": "op_oremptyzero_double_gt5", "primitives": ["oremptyzero", "double", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then double each, then keep values greater than five.", "solution": "def op_oremptyzero_double_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_oremptyzero_double_gt5([]) == []\nassert op_oremptyzero_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_oremptyzero_double_gt5([3, 1, 2]) == [6]\nassert op_oremptyzero_double_gt5([10]) == [20]\nassert op_oremptyzero_double_gt5([2, 4, 6]) == [8, 12]\nassert op_oremptyzero_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_square_sortd_prod", "entry_point": "op_square_sortd_prod", "primitives": ["square", "sortd", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort descending, then return their product.", "solution": "def op_square_sortd_prod(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return __import__('math').prod(r)", "tests": "assert op_square_sortd_prod([1, 2, 3, 4]) == 576\nassert op_square_sortd_prod([]) == 1\nassert op_square_sortd_prod([-2, -1, 0, 1, 2]) == 0\nassert op_square_sortd_prod([5, 5, 5]) == 15625\nassert op_square_sortd_prod([3, 1, 2]) == 36\nassert op_square_sortd_prod([10]) == 100\nassert op_square_sortd_prod([2, 4, 6]) == 2304\nassert op_square_sortd_prod([-7, 12, -7]) == 345744"}
{"id": "op_last3_takewhilepos_double", "entry_point": "op_last3_takewhilepos_double", "primitives": ["last3", "takewhilepos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then double each.", "solution": "def op_last3_takewhilepos_double(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_last3_takewhilepos_double([1, 2, 3, 4]) == [4, 6, 8]\nassert op_last3_takewhilepos_double([]) == []\nassert op_last3_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos_double([5, 5, 5]) == [10, 10, 10]\nassert op_last3_takewhilepos_double([3, 1, 2]) == [6, 2, 4]\nassert op_last3_takewhilepos_double([10]) == [20]\nassert op_last3_takewhilepos_double([2, 4, 6]) == [4, 8, 12]\nassert op_last3_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_double_sortd_inc", "entry_point": "op_double_sortd_inc", "primitives": ["double", "sortd", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending, then add one to each.", "solution": "def op_double_sortd_inc(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_double_sortd_inc([1, 2, 3, 4]) == [9, 7, 5, 3]\nassert op_double_sortd_inc([]) == []\nassert op_double_sortd_inc([-2, -1, 0, 1, 2]) == [5, 3, 1, -1, -3]\nassert op_double_sortd_inc([5, 5, 5]) == [11, 11, 11]\nassert op_double_sortd_inc([3, 1, 2]) == [7, 5, 3]\nassert op_double_sortd_inc([10]) == [21]\nassert op_double_sortd_inc([2, 4, 6]) == [13, 9, 5]\nassert op_double_sortd_inc([-7, 12, -7]) == [25, -13, -13]"}
{"id": "op_gt5_evens_min", "entry_point": "op_gt5_evens_min", "primitives": ["gt5", "evens", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_gt5_evens_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_gt5_evens_min([1, 2, 3, 4]) == 0\nassert op_gt5_evens_min([]) == 0\nassert op_gt5_evens_min([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_evens_min([5, 5, 5]) == 0\nassert op_gt5_evens_min([3, 1, 2]) == 0\nassert op_gt5_evens_min([10]) == 10\nassert op_gt5_evens_min([2, 4, 6]) == 6\nassert op_gt5_evens_min([-7, 12, -7]) == 12"}
{"id": "op_div3_dropfirst_neg", "entry_point": "op_div3_dropfirst_neg", "primitives": ["div3", "dropfirst", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then keep the negative numbers.", "solution": "def op_div3_dropfirst_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_div3_dropfirst_neg([1, 2, 3, 4]) == []\nassert op_div3_dropfirst_neg([]) == []\nassert op_div3_dropfirst_neg([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst_neg([5, 5, 5]) == []\nassert op_div3_dropfirst_neg([3, 1, 2]) == []\nassert op_div3_dropfirst_neg([10]) == []\nassert op_div3_dropfirst_neg([2, 4, 6]) == []\nassert op_div3_dropfirst_neg([-7, 12, -7]) == []"}
{"id": "op_negate_double_first3", "entry_point": "op_negate_double_first3", "primitives": ["negate", "double", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then keep only the first three.", "solution": "def op_negate_double_first3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_negate_double_first3([1, 2, 3, 4]) == [-2, -4, -6]\nassert op_negate_double_first3([]) == []\nassert op_negate_double_first3([-2, -1, 0, 1, 2]) == [4, 2, 0]\nassert op_negate_double_first3([5, 5, 5]) == [-10, -10, -10]\nassert op_negate_double_first3([3, 1, 2]) == [-6, -2, -4]\nassert op_negate_double_first3([10]) == [-20]\nassert op_negate_double_first3([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_double_first3([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_add10_uniq_sortd", "entry_point": "op_add10_uniq_sortd", "primitives": ["add10", "uniq", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_add10_uniq_sortd(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_add10_uniq_sortd([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_uniq_sortd([]) == []\nassert op_add10_uniq_sortd([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_uniq_sortd([5, 5, 5]) == [15]\nassert op_add10_uniq_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_add10_uniq_sortd([10]) == [20]\nassert op_add10_uniq_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_add10_uniq_sortd([-7, 12, -7]) == [22, 3]"}
{"id": "op_sortabs_clamp10_last3", "entry_point": "op_sortabs_clamp10_last3", "primitives": ["sortabs", "clamp10", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then keep only the last three.", "solution": "def op_sortabs_clamp10_last3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_sortabs_clamp10_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_clamp10_last3([]) == []\nassert op_sortabs_clamp10_last3([-2, -1, 0, 1, 2]) == [1, -2, 2]\nassert op_sortabs_clamp10_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_clamp10_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_clamp10_last3([10]) == [10]\nassert op_sortabs_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_clamp10_last3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_dropzeros_uniq_add10", "entry_point": "op_dropzeros_uniq_add10", "primitives": ["dropzeros", "uniq", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_dropzeros_uniq_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropzeros_uniq_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropzeros_uniq_add10([]) == []\nassert op_dropzeros_uniq_add10([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_dropzeros_uniq_add10([5, 5, 5]) == [15]\nassert op_dropzeros_uniq_add10([3, 1, 2]) == [13, 11, 12]\nassert op_dropzeros_uniq_add10([10]) == [20]\nassert op_dropzeros_uniq_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_uniq_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_dropwhileneg_add10_min", "entry_point": "op_dropwhileneg_add10_min", "primitives": ["dropwhileneg", "add10", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_dropwhileneg_add10_min(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dropwhileneg_add10_min([1, 2, 3, 4]) == 11\nassert op_dropwhileneg_add10_min([]) == 0\nassert op_dropwhileneg_add10_min([-2, -1, 0, 1, 2]) == 10\nassert op_dropwhileneg_add10_min([5, 5, 5]) == 15\nassert op_dropwhileneg_add10_min([3, 1, 2]) == 11\nassert op_dropwhileneg_add10_min([10]) == 20\nassert op_dropwhileneg_add10_min([2, 4, 6]) == 12\nassert op_dropwhileneg_add10_min([-7, 12, -7]) == 3"}
{"id": "op_dropfirst_dropzeros_allpos", "entry_point": "op_dropfirst_dropzeros_allpos", "primitives": ["dropfirst", "dropzeros", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the zeros, then return whether all values are positive.", "solution": "def op_dropfirst_dropzeros_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_dropzeros_allpos([]) == True\nassert op_dropfirst_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_dropzeros_allpos([5, 5, 5]) == True\nassert op_dropfirst_dropzeros_allpos([3, 1, 2]) == True\nassert op_dropfirst_dropzeros_allpos([10]) == True\nassert op_dropfirst_dropzeros_allpos([2, 4, 6]) == True\nassert op_dropfirst_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_sortd_dec_dropzeros", "entry_point": "op_sortd_dec_dropzeros", "primitives": ["sortd", "dec", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each, then drop the zeros.", "solution": "def op_sortd_dec_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortd_dec_dropzeros([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dec_dropzeros([]) == []\nassert op_sortd_dec_dropzeros([-2, -1, 0, 1, 2]) == [1, -1, -2, -3]\nassert op_sortd_dec_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_dec_dropzeros([3, 1, 2]) == [2, 1]\nassert op_sortd_dec_dropzeros([10]) == [9]\nassert op_sortd_dec_dropzeros([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_dec_dropzeros([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_evens_odds_dropzeros", "entry_point": "op_evens_odds_dropzeros", "primitives": ["evens", "odds", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then drop the zeros.", "solution": "def op_evens_odds_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_evens_odds_dropzeros([1, 2, 3, 4]) == []\nassert op_evens_odds_dropzeros([]) == []\nassert op_evens_odds_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_dropzeros([5, 5, 5]) == []\nassert op_evens_odds_dropzeros([3, 1, 2]) == []\nassert op_evens_odds_dropzeros([10]) == []\nassert op_evens_odds_dropzeros([2, 4, 6]) == []\nassert op_evens_odds_dropzeros([-7, 12, -7]) == []"}
{"id": "op_trimends_pos_firsteven", "entry_point": "op_trimends_pos_firsteven", "primitives": ["trimends", "pos", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then return the first even value (0 if none).", "solution": "def op_trimends_pos_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_pos_firsteven([1, 2, 3, 4]) == 2\nassert op_trimends_pos_firsteven([]) == 0\nassert op_trimends_pos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_pos_firsteven([5, 5, 5]) == 0\nassert op_trimends_pos_firsteven([3, 1, 2]) == 0\nassert op_trimends_pos_firsteven([10]) == 0\nassert op_trimends_pos_firsteven([2, 4, 6]) == 4\nassert op_trimends_pos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_padto3_sorta_dropzeros", "entry_point": "op_padto3_sorta_dropzeros", "primitives": ["padto3", "sorta", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then drop the zeros.", "solution": "def op_padto3_sorta_dropzeros(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_padto3_sorta_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_sorta_dropzeros([]) == []\nassert op_padto3_sorta_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_padto3_sorta_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_sorta_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_sorta_dropzeros([10]) == [10]\nassert op_padto3_sorta_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_sorta_dropzeros([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_first3_square_clamp10", "entry_point": "op_first3_square_clamp10", "primitives": ["first3", "square", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then square each, then cap each value at 10.", "solution": "def op_first3_square_clamp10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_first3_square_clamp10([1, 2, 3, 4]) == [1, 4, 9]\nassert op_first3_square_clamp10([]) == []\nassert op_first3_square_clamp10([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_first3_square_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_first3_square_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_first3_square_clamp10([10]) == [10]\nassert op_first3_square_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_first3_square_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_ages_clamp10_last3", "entry_point": "op_ages_clamp10_last3", "primitives": ["ages", "clamp10", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then keep only the last three.", "solution": "def op_ages_clamp10_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_ages_clamp10_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_clamp10_last3([]) == []\nassert op_ages_clamp10_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10_last3([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_div3_takewhilepos_firsteven", "entry_point": "op_div3_takewhilepos_firsteven", "primitives": ["div3", "takewhilepos", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_div3_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_takewhilepos_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_takewhilepos_firsteven([]) == 0\nassert op_div3_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_div3_takewhilepos_firsteven([3, 1, 2]) == 0\nassert op_div3_takewhilepos_firsteven([10]) == 0\nassert op_div3_takewhilepos_firsteven([2, 4, 6]) == 6\nassert op_div3_takewhilepos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_evens_rev_oremptyzero", "entry_point": "op_evens_rev_oremptyzero", "primitives": ["evens", "rev", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then if empty, use a single zero.", "solution": "def op_evens_rev_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_rev_oremptyzero([1, 2, 3, 4]) == [4, 2]\nassert op_evens_rev_oremptyzero([]) == [0]\nassert op_evens_rev_oremptyzero([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_rev_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_rev_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_rev_oremptyzero([10]) == [10]\nassert op_evens_rev_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_evens_rev_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_neg_sortabs_evens", "entry_point": "op_neg_sortabs_evens", "primitives": ["neg", "sortabs", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then keep the even numbers.", "solution": "def op_neg_sortabs_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_sortabs_evens([1, 2, 3, 4]) == []\nassert op_neg_sortabs_evens([]) == []\nassert op_neg_sortabs_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_sortabs_evens([5, 5, 5]) == []\nassert op_neg_sortabs_evens([3, 1, 2]) == []\nassert op_neg_sortabs_evens([10]) == []\nassert op_neg_sortabs_evens([2, 4, 6]) == []\nassert op_neg_sortabs_evens([-7, 12, -7]) == []"}
{"id": "op_dropfirst_sorta_max", "entry_point": "op_dropfirst_sorta_max", "primitives": ["dropfirst", "sorta", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_dropfirst_sorta_max(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_dropfirst_sorta_max([1, 2, 3, 4]) == 4\nassert op_dropfirst_sorta_max([]) == 0\nassert op_dropfirst_sorta_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_sorta_max([5, 5, 5]) == 5\nassert op_dropfirst_sorta_max([3, 1, 2]) == 2\nassert op_dropfirst_sorta_max([10]) == 0\nassert op_dropfirst_sorta_max([2, 4, 6]) == 6\nassert op_dropfirst_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_clamp10_trimends_inc", "entry_point": "op_clamp10_trimends_inc", "primitives": ["clamp10", "trimends", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then add one to each.", "solution": "def op_clamp10_trimends_inc(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_clamp10_trimends_inc([1, 2, 3, 4]) == [3, 4]\nassert op_clamp10_trimends_inc([]) == []\nassert op_clamp10_trimends_inc([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_trimends_inc([5, 5, 5]) == [6]\nassert op_clamp10_trimends_inc([3, 1, 2]) == [2]\nassert op_clamp10_trimends_inc([10]) == []\nassert op_clamp10_trimends_inc([2, 4, 6]) == [5]\nassert op_clamp10_trimends_inc([-7, 12, -7]) == [11]"}
{"id": "op_dropzeros_padto3_issorted", "entry_point": "op_dropzeros_padto3_issorted", "primitives": ["dropzeros", "padto3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_padto3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_dropzeros_padto3_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_padto3_issorted([]) == True\nassert op_dropzeros_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_padto3_issorted([5, 5, 5]) == True\nassert op_dropzeros_padto3_issorted([3, 1, 2]) == False\nassert op_dropzeros_padto3_issorted([10]) == False\nassert op_dropzeros_padto3_issorted([2, 4, 6]) == True\nassert op_dropzeros_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_beforezero_last3_absval", "entry_point": "op_beforezero_last3_absval", "primitives": ["beforezero", "last3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then take the absolute value of each.", "solution": "def op_beforezero_last3_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_last3_absval([]) == []\nassert op_beforezero_last3_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_last3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_last3_absval([10]) == [10]\nassert op_beforezero_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_last3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_neg_gt5_len", "entry_point": "op_neg_gt5_len", "primitives": ["neg", "gt5", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep values greater than five, then return how many remain.", "solution": "def op_neg_gt5_len(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return len(r)", "tests": "assert op_neg_gt5_len([1, 2, 3, 4]) == 0\nassert op_neg_gt5_len([]) == 0\nassert op_neg_gt5_len([-2, -1, 0, 1, 2]) == 0\nassert op_neg_gt5_len([5, 5, 5]) == 0\nassert op_neg_gt5_len([3, 1, 2]) == 0\nassert op_neg_gt5_len([10]) == 0\nassert op_neg_gt5_len([2, 4, 6]) == 0\nassert op_neg_gt5_len([-7, 12, -7]) == 0"}
{"id": "op_dec_absval_dropwhileneg", "entry_point": "op_dec_absval_dropwhileneg", "primitives": ["dec", "absval", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then drop the leading negative values.", "solution": "def op_dec_absval_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_absval_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_absval_dropwhileneg([]) == []\nassert op_dec_absval_dropwhileneg([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, 1]\nassert op_dec_absval_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_dec_absval_dropwhileneg([10]) == [9]\nassert op_dec_absval_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_dec_absval_dropwhileneg([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_div3_negate_first3", "entry_point": "op_div3_negate_first3", "primitives": ["div3", "negate", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then keep only the first three.", "solution": "def op_div3_negate_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_div3_negate_first3([1, 2, 3, 4]) == [-3]\nassert op_div3_negate_first3([]) == []\nassert op_div3_negate_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_negate_first3([5, 5, 5]) == []\nassert op_div3_negate_first3([3, 1, 2]) == [-3]\nassert op_div3_negate_first3([10]) == []\nassert op_div3_negate_first3([2, 4, 6]) == [-6]\nassert op_div3_negate_first3([-7, 12, -7]) == [-12]"}
{"id": "op_div3_oremptyzero_allpos", "entry_point": "op_div3_oremptyzero_allpos", "primitives": ["div3", "oremptyzero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_div3_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_div3_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_div3_oremptyzero_allpos([]) == False\nassert op_div3_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_div3_oremptyzero_allpos([5, 5, 5]) == False\nassert op_div3_oremptyzero_allpos([3, 1, 2]) == True\nassert op_div3_oremptyzero_allpos([10]) == False\nassert op_div3_oremptyzero_allpos([2, 4, 6]) == True\nassert op_div3_oremptyzero_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_neg_dropzeros", "entry_point": "op_sorta_neg_dropzeros", "primitives": ["sorta", "neg", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers, then drop the zeros.", "solution": "def op_sorta_neg_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sorta_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_sorta_neg_dropzeros([]) == []\nassert op_sorta_neg_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_neg_dropzeros([5, 5, 5]) == []\nassert op_sorta_neg_dropzeros([3, 1, 2]) == []\nassert op_sorta_neg_dropzeros([10]) == []\nassert op_sorta_neg_dropzeros([2, 4, 6]) == []\nassert op_sorta_neg_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_dropwhileneg_neg_oremptyzero", "entry_point": "op_dropwhileneg_neg_oremptyzero", "primitives": ["dropwhileneg", "neg", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_dropwhileneg_neg_oremptyzero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropwhileneg_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([10]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_dropwhileneg_neg_oremptyzero([-7, 12, -7]) == [-7]"}
{"id": "op_negate_uniq_add10", "entry_point": "op_negate_uniq_add10", "primitives": ["negate", "uniq", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_negate_uniq_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_uniq_add10([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_uniq_add10([]) == []\nassert op_negate_uniq_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_negate_uniq_add10([5, 5, 5]) == [5]\nassert op_negate_uniq_add10([3, 1, 2]) == [7, 9, 8]\nassert op_negate_uniq_add10([10]) == [0]\nassert op_negate_uniq_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_uniq_add10([-7, 12, -7]) == [17, -2]"}
{"id": "op_odds_double_firsteven", "entry_point": "op_odds_double_firsteven", "primitives": ["odds", "double", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each, then return the first even value (0 if none).", "solution": "def op_odds_double_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_odds_double_firsteven([1, 2, 3, 4]) == 2\nassert op_odds_double_firsteven([]) == 0\nassert op_odds_double_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_odds_double_firsteven([5, 5, 5]) == 10\nassert op_odds_double_firsteven([3, 1, 2]) == 6\nassert op_odds_double_firsteven([10]) == 0\nassert op_odds_double_firsteven([2, 4, 6]) == 0\nassert op_odds_double_firsteven([-7, 12, -7]) == -14"}
{"id": "op_odds_pos_max", "entry_point": "op_odds_pos_max", "primitives": ["odds", "pos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_odds_pos_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_odds_pos_max([1, 2, 3, 4]) == 3\nassert op_odds_pos_max([]) == 0\nassert op_odds_pos_max([-2, -1, 0, 1, 2]) == 1\nassert op_odds_pos_max([5, 5, 5]) == 5\nassert op_odds_pos_max([3, 1, 2]) == 3\nassert op_odds_pos_max([10]) == 0\nassert op_odds_pos_max([2, 4, 6]) == 0\nassert op_odds_pos_max([-7, 12, -7]) == 0"}
{"id": "op_last3_trimends_takewhilepos", "entry_point": "op_last3_trimends_takewhilepos", "primitives": ["last3", "trimends", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then take values while they are positive.", "solution": "def op_last3_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_trimends_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_last3_trimends_takewhilepos([]) == []\nassert op_last3_trimends_takewhilepos([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_trimends_takewhilepos([5, 5, 5]) == [5]\nassert op_last3_trimends_takewhilepos([3, 1, 2]) == [1]\nassert op_last3_trimends_takewhilepos([10]) == []\nassert op_last3_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_last3_trimends_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_neg_add10_odds", "entry_point": "op_neg_add10_odds", "primitives": ["neg", "add10", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then keep the odd numbers.", "solution": "def op_neg_add10_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_neg_add10_odds([1, 2, 3, 4]) == []\nassert op_neg_add10_odds([]) == []\nassert op_neg_add10_odds([-2, -1, 0, 1, 2]) == [9]\nassert op_neg_add10_odds([5, 5, 5]) == []\nassert op_neg_add10_odds([3, 1, 2]) == []\nassert op_neg_add10_odds([10]) == []\nassert op_neg_add10_odds([2, 4, 6]) == []\nassert op_neg_add10_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_pos_square_firsteven", "entry_point": "op_pos_square_firsteven", "primitives": ["pos", "square", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then return the first even value (0 if none).", "solution": "def op_pos_square_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_square_firsteven([1, 2, 3, 4]) == 4\nassert op_pos_square_firsteven([]) == 0\nassert op_pos_square_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_pos_square_firsteven([5, 5, 5]) == 0\nassert op_pos_square_firsteven([3, 1, 2]) == 4\nassert op_pos_square_firsteven([10]) == 100\nassert op_pos_square_firsteven([2, 4, 6]) == 4\nassert op_pos_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_dec_padto3_anyeven", "entry_point": "op_dec_padto3_anyeven", "primitives": ["dec", "padto3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_dec_padto3_anyeven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dec_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_dec_padto3_anyeven([]) == True\nassert op_dec_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dec_padto3_anyeven([5, 5, 5]) == True\nassert op_dec_padto3_anyeven([3, 1, 2]) == True\nassert op_dec_padto3_anyeven([10]) == True\nassert op_dec_padto3_anyeven([2, 4, 6]) == False\nassert op_dec_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_uniq_div3", "entry_point": "op_negate_uniq_div3", "primitives": ["negate", "uniq", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then keep multiples of three.", "solution": "def op_negate_uniq_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_uniq_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_uniq_div3([]) == []\nassert op_negate_uniq_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_uniq_div3([5, 5, 5]) == []\nassert op_negate_uniq_div3([3, 1, 2]) == [-3]\nassert op_negate_uniq_div3([10]) == []\nassert op_negate_uniq_div3([2, 4, 6]) == [-6]\nassert op_negate_uniq_div3([-7, 12, -7]) == [-12]"}
{"id": "op_first3_dropfirst_allpos", "entry_point": "op_first3_dropfirst_allpos", "primitives": ["first3", "dropfirst", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then return whether all values are positive.", "solution": "def op_first3_dropfirst_allpos(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_first3_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_first3_dropfirst_allpos([]) == True\nassert op_first3_dropfirst_allpos([-2, -1, 0, 1, 2]) == False\nassert op_first3_dropfirst_allpos([5, 5, 5]) == True\nassert op_first3_dropfirst_allpos([3, 1, 2]) == True\nassert op_first3_dropfirst_allpos([10]) == True\nassert op_first3_dropfirst_allpos([2, 4, 6]) == True\nassert op_first3_dropfirst_allpos([-7, 12, -7]) == False"}
{"id": "op_uniq_neg_counteven", "entry_point": "op_uniq_neg_counteven", "primitives": ["uniq", "neg", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers, then return how many values are even.", "solution": "def op_uniq_neg_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_neg_counteven([1, 2, 3, 4]) == 0\nassert op_uniq_neg_counteven([]) == 0\nassert op_uniq_neg_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_uniq_neg_counteven([5, 5, 5]) == 0\nassert op_uniq_neg_counteven([3, 1, 2]) == 0\nassert op_uniq_neg_counteven([10]) == 0\nassert op_uniq_neg_counteven([2, 4, 6]) == 0\nassert op_uniq_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_sorta_counteven", "entry_point": "op_dropfirst_sorta_counteven", "primitives": ["dropfirst", "sorta", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then return how many values are even.", "solution": "def op_dropfirst_sorta_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_sorta_counteven([]) == 0\nassert op_dropfirst_sorta_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_sorta_counteven([5, 5, 5]) == 0\nassert op_dropfirst_sorta_counteven([3, 1, 2]) == 1\nassert op_dropfirst_sorta_counteven([10]) == 0\nassert op_dropfirst_sorta_counteven([2, 4, 6]) == 2\nassert op_dropfirst_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_square_odds", "entry_point": "op_neg_square_odds", "primitives": ["neg", "square", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each, then keep the odd numbers.", "solution": "def op_neg_square_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_neg_square_odds([1, 2, 3, 4]) == []\nassert op_neg_square_odds([]) == []\nassert op_neg_square_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_neg_square_odds([5, 5, 5]) == []\nassert op_neg_square_odds([3, 1, 2]) == []\nassert op_neg_square_odds([10]) == []\nassert op_neg_square_odds([2, 4, 6]) == []\nassert op_neg_square_odds([-7, 12, -7]) == [49, 49]"}
{"id": "op_sorta_add10_issorted", "entry_point": "op_sorta_add10_issorted", "primitives": ["sorta", "add10", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_sorta_add10_issorted(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_sorta_add10_issorted([1, 2, 3, 4]) == True\nassert op_sorta_add10_issorted([]) == True\nassert op_sorta_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sorta_add10_issorted([5, 5, 5]) == True\nassert op_sorta_add10_issorted([3, 1, 2]) == True\nassert op_sorta_add10_issorted([10]) == True\nassert op_sorta_add10_issorted([2, 4, 6]) == True\nassert op_sorta_add10_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_square_firsteven", "entry_point": "op_padto3_square_firsteven", "primitives": ["padto3", "square", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then square each, then return the first even value (0 if none).", "solution": "def op_padto3_square_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_square_firsteven([1, 2, 3, 4]) == 4\nassert op_padto3_square_firsteven([]) == 0\nassert op_padto3_square_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_padto3_square_firsteven([5, 5, 5]) == 0\nassert op_padto3_square_firsteven([3, 1, 2]) == 4\nassert op_padto3_square_firsteven([10]) == 100\nassert op_padto3_square_firsteven([2, 4, 6]) == 4\nassert op_padto3_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_absval_sorta_square", "entry_point": "op_absval_sorta_square", "primitives": ["absval", "sorta", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then square each.", "solution": "def op_absval_sorta_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_sorta_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_absval_sorta_square([]) == []\nassert op_absval_sorta_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_absval_sorta_square([5, 5, 5]) == [25, 25, 25]\nassert op_absval_sorta_square([3, 1, 2]) == [1, 4, 9]\nassert op_absval_sorta_square([10]) == [100]\nassert op_absval_sorta_square([2, 4, 6]) == [4, 16, 36]\nassert op_absval_sorta_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_beforezero_dropzeros_dropwhileneg", "entry_point": "op_beforezero_dropzeros_dropwhileneg", "primitives": ["beforezero", "dropzeros", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then drop the leading negative values.", "solution": "def op_beforezero_dropzeros_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_dropzeros_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_dropzeros_dropwhileneg([]) == []\nassert op_beforezero_dropzeros_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_dropzeros_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_dropzeros_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_dropzeros_dropwhileneg([10]) == [10]\nassert op_beforezero_dropzeros_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_dropzeros_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_absval_square_double", "entry_point": "op_absval_square_double", "primitives": ["absval", "square", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each, then double each.", "solution": "def op_absval_square_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_square_double([1, 2, 3, 4]) == [2, 8, 18, 32]\nassert op_absval_square_double([]) == []\nassert op_absval_square_double([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_absval_square_double([5, 5, 5]) == [50, 50, 50]\nassert op_absval_square_double([3, 1, 2]) == [18, 2, 8]\nassert op_absval_square_double([10]) == [200]\nassert op_absval_square_double([2, 4, 6]) == [8, 32, 72]\nassert op_absval_square_double([-7, 12, -7]) == [98, 288, 98]"}
{"id": "op_dropfirst_neg_oremptyzero", "entry_point": "op_dropfirst_neg_oremptyzero", "primitives": ["dropfirst", "neg", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_dropfirst_neg_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_dropfirst_neg_oremptyzero([]) == [0]\nassert op_dropfirst_neg_oremptyzero([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_dropfirst_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_dropfirst_neg_oremptyzero([10]) == [0]\nassert op_dropfirst_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_dropfirst_neg_oremptyzero([-7, 12, -7]) == [-7]"}
{"id": "op_uniq_absval_counteven", "entry_point": "op_uniq_absval_counteven", "primitives": ["uniq", "absval", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then return how many values are even.", "solution": "def op_uniq_absval_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_absval_counteven([1, 2, 3, 4]) == 2\nassert op_uniq_absval_counteven([]) == 0\nassert op_uniq_absval_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_uniq_absval_counteven([5, 5, 5]) == 0\nassert op_uniq_absval_counteven([3, 1, 2]) == 1\nassert op_uniq_absval_counteven([10]) == 1\nassert op_uniq_absval_counteven([2, 4, 6]) == 3\nassert op_uniq_absval_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_dec_gt5", "entry_point": "op_neg_dec_gt5", "primitives": ["neg", "dec", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then keep values greater than five.", "solution": "def op_neg_dec_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_dec_gt5([1, 2, 3, 4]) == []\nassert op_neg_dec_gt5([]) == []\nassert op_neg_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_dec_gt5([5, 5, 5]) == []\nassert op_neg_dec_gt5([3, 1, 2]) == []\nassert op_neg_dec_gt5([10]) == []\nassert op_neg_dec_gt5([2, 4, 6]) == []\nassert op_neg_dec_gt5([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_odds_padto3", "entry_point": "op_takewhilepos_odds_padto3", "primitives": ["takewhilepos", "odds", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then pad with zeros to at least three elements.", "solution": "def op_takewhilepos_odds_padto3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_takewhilepos_odds_padto3([1, 2, 3, 4]) == [1, 3, 0]\nassert op_takewhilepos_odds_padto3([]) == [0, 0, 0]\nassert op_takewhilepos_odds_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_odds_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_odds_padto3([3, 1, 2]) == [3, 1, 0]\nassert op_takewhilepos_odds_padto3([10]) == [0, 0, 0]\nassert op_takewhilepos_odds_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_takewhilepos_odds_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_first3_sorta_sortabs", "entry_point": "op_first3_sorta_sortabs", "primitives": ["first3", "sorta", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then sort by absolute value.", "solution": "def op_first3_sorta_sortabs(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_first3_sorta_sortabs([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sorta_sortabs([]) == []\nassert op_first3_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_sorta_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sorta_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sorta_sortabs([10]) == [10]\nassert op_first3_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sorta_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_names_sortlen_strip", "entry_point": "op_names_sortlen_strip", "primitives": ["names", "sortlen", "strip"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort by length, shortest first, then trim whitespace from each.", "solution": "def op_names_sortlen_strip(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_names_sortlen_strip([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Bo', 'Ada']\nassert op_names_sortlen_strip([]) == []\nassert op_names_sortlen_strip([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'El', 'Dee']\nassert op_names_sortlen_strip([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_absval_trimends_firsteven", "entry_point": "op_absval_trimends_firsteven", "primitives": ["absval", "trimends", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_absval_trimends_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_trimends_firsteven([]) == 0\nassert op_absval_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_absval_trimends_firsteven([5, 5, 5]) == 0\nassert op_absval_trimends_firsteven([3, 1, 2]) == 0\nassert op_absval_trimends_firsteven([10]) == 0\nassert op_absval_trimends_firsteven([2, 4, 6]) == 4\nassert op_absval_trimends_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sortd_trimends_alldistinct", "entry_point": "op_sortd_trimends_alldistinct", "primitives": ["sortd", "trimends", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_sortd_trimends_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_trimends_alldistinct([]) == True\nassert op_sortd_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_trimends_alldistinct([5, 5, 5]) == True\nassert op_sortd_trimends_alldistinct([3, 1, 2]) == True\nassert op_sortd_trimends_alldistinct([10]) == True\nassert op_sortd_trimends_alldistinct([2, 4, 6]) == True\nassert op_sortd_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_takewhilepos_negate", "entry_point": "op_div3_takewhilepos_negate", "primitives": ["div3", "takewhilepos", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then negate each.", "solution": "def op_div3_takewhilepos_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return r", "tests": "assert op_div3_takewhilepos_negate([1, 2, 3, 4]) == [-3]\nassert op_div3_takewhilepos_negate([]) == []\nassert op_div3_takewhilepos_negate([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_negate([5, 5, 5]) == []\nassert op_div3_takewhilepos_negate([3, 1, 2]) == [-3]\nassert op_div3_takewhilepos_negate([10]) == []\nassert op_div3_takewhilepos_negate([2, 4, 6]) == [-6]\nassert op_div3_takewhilepos_negate([-7, 12, -7]) == [-12]"}
{"id": "op_first3_takewhilepos_counteven", "entry_point": "op_first3_takewhilepos_counteven", "primitives": ["first3", "takewhilepos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then return how many values are even.", "solution": "def op_first3_takewhilepos_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_takewhilepos_counteven([1, 2, 3, 4]) == 1\nassert op_first3_takewhilepos_counteven([]) == 0\nassert op_first3_takewhilepos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_first3_takewhilepos_counteven([5, 5, 5]) == 0\nassert op_first3_takewhilepos_counteven([3, 1, 2]) == 1\nassert op_first3_takewhilepos_counteven([10]) == 1\nassert op_first3_takewhilepos_counteven([2, 4, 6]) == 3\nassert op_first3_takewhilepos_counteven([-7, 12, -7]) == 0"}
{"id": "op_dropshort_upper_nonempty", "entry_point": "op_dropshort_upper_nonempty", "primitives": ["dropshort", "upper", "nonempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string, then drop empty strings.", "solution": "def op_dropshort_upper_nonempty(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_dropshort_upper_nonempty(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_dropshort_upper_nonempty([]) == []\nassert op_dropshort_upper_nonempty(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_dropshort_upper_nonempty(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_dropshort_upper_nonempty(['x']) == []\nassert op_dropshort_upper_nonempty(['abc', 'de', '']) == ['ABC']"}
{"id": "op_odds_sortd_last3", "entry_point": "op_odds_sortd_last3", "primitives": ["odds", "sortd", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort descending, then keep only the last three.", "solution": "def op_odds_sortd_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return r", "tests": "assert op_odds_sortd_last3([1, 2, 3, 4]) == [3, 1]\nassert op_odds_sortd_last3([]) == []\nassert op_odds_sortd_last3([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_sortd_last3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortd_last3([3, 1, 2]) == [3, 1]\nassert op_odds_sortd_last3([10]) == []\nassert op_odds_sortd_last3([2, 4, 6]) == []\nassert op_odds_sortd_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_absval_neg_counteven", "entry_point": "op_absval_neg_counteven", "primitives": ["absval", "neg", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the negative numbers, then return how many values are even.", "solution": "def op_absval_neg_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_neg_counteven([1, 2, 3, 4]) == 0\nassert op_absval_neg_counteven([]) == 0\nassert op_absval_neg_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_absval_neg_counteven([5, 5, 5]) == 0\nassert op_absval_neg_counteven([3, 1, 2]) == 0\nassert op_absval_neg_counteven([10]) == 0\nassert op_absval_neg_counteven([2, 4, 6]) == 0\nassert op_absval_neg_counteven([-7, 12, -7]) == 0"}
{"id": "op_gt5_beforezero_pos", "entry_point": "op_gt5_beforezero_pos", "primitives": ["gt5", "beforezero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_gt5_beforezero_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_gt5_beforezero_pos([1, 2, 3, 4]) == []\nassert op_gt5_beforezero_pos([]) == []\nassert op_gt5_beforezero_pos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_beforezero_pos([5, 5, 5]) == []\nassert op_gt5_beforezero_pos([3, 1, 2]) == []\nassert op_gt5_beforezero_pos([10]) == [10]\nassert op_gt5_beforezero_pos([2, 4, 6]) == [6]\nassert op_gt5_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_trimends_dec_haszero", "entry_point": "op_trimends_dec_haszero", "primitives": ["trimends", "dec", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_trimends_dec_haszero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_trimends_dec_haszero([1, 2, 3, 4]) == False\nassert op_trimends_dec_haszero([]) == False\nassert op_trimends_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_trimends_dec_haszero([5, 5, 5]) == False\nassert op_trimends_dec_haszero([3, 1, 2]) == True\nassert op_trimends_dec_haszero([10]) == False\nassert op_trimends_dec_haszero([2, 4, 6]) == False\nassert op_trimends_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_takewhilepos_gt5", "entry_point": "op_dropfirst_takewhilepos_gt5", "primitives": ["dropfirst", "takewhilepos", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then keep values greater than five.", "solution": "def op_dropfirst_takewhilepos_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_takewhilepos_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_takewhilepos_gt5([]) == []\nassert op_dropfirst_takewhilepos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_takewhilepos_gt5([5, 5, 5]) == []\nassert op_dropfirst_takewhilepos_gt5([3, 1, 2]) == []\nassert op_dropfirst_takewhilepos_gt5([10]) == []\nassert op_dropfirst_takewhilepos_gt5([2, 4, 6]) == [6]\nassert op_dropfirst_takewhilepos_gt5([-7, 12, -7]) == [12]"}
{"id": "op_padto3_first3_evens", "entry_point": "op_padto3_first3_evens", "primitives": ["padto3", "first3", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then keep the even numbers.", "solution": "def op_padto3_first3_evens(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_padto3_first3_evens([1, 2, 3, 4]) == [2]\nassert op_padto3_first3_evens([]) == [0, 0, 0]\nassert op_padto3_first3_evens([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_padto3_first3_evens([5, 5, 5]) == []\nassert op_padto3_first3_evens([3, 1, 2]) == [2]\nassert op_padto3_first3_evens([10]) == [10, 0, 0]\nassert op_padto3_first3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_first3_evens([-7, 12, -7]) == [12]"}
{"id": "op_div3_sortabs_beforezero", "entry_point": "op_div3_sortabs_beforezero", "primitives": ["div3", "sortabs", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value, then keep everything before the first zero.", "solution": "def op_div3_sortabs_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_div3_sortabs_beforezero([1, 2, 3, 4]) == [3]\nassert op_div3_sortabs_beforezero([]) == []\nassert op_div3_sortabs_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_div3_sortabs_beforezero([5, 5, 5]) == []\nassert op_div3_sortabs_beforezero([3, 1, 2]) == [3]\nassert op_div3_sortabs_beforezero([10]) == []\nassert op_div3_sortabs_beforezero([2, 4, 6]) == [6]\nassert op_div3_sortabs_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_padto3_dropwhileneg", "entry_point": "op_sortabs_padto3_dropwhileneg", "primitives": ["sortabs", "padto3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then drop the leading negative values.", "solution": "def op_sortabs_padto3_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortabs_padto3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_padto3_dropwhileneg([]) == [0, 0, 0]\nassert op_sortabs_padto3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_sortabs_padto3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_padto3_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_padto3_dropwhileneg([10]) == [10, 0, 0]\nassert op_sortabs_padto3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_padto3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_ages_last3_alldistinct", "entry_point": "op_ages_last3_alldistinct", "primitives": ["ages", "last3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then return whether all values are distinct.", "solution": "def op_ages_last3_alldistinct(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_ages_last3_alldistinct([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_last3_alldistinct([]) == True\nassert op_ages_last3_alldistinct([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_last3_alldistinct([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_odds_rev_sortabs", "entry_point": "op_odds_rev_sortabs", "primitives": ["odds", "rev", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then sort by absolute value.", "solution": "def op_odds_rev_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_rev_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_odds_rev_sortabs([]) == []\nassert op_odds_rev_sortabs([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_rev_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_odds_rev_sortabs([3, 1, 2]) == [1, 3]\nassert op_odds_rev_sortabs([10]) == []\nassert op_odds_rev_sortabs([2, 4, 6]) == []\nassert op_odds_rev_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniq_rev_div3", "entry_point": "op_uniq_rev_div3", "primitives": ["uniq", "rev", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then reverse the order, then keep multiples of three.", "solution": "def op_uniq_rev_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_rev_div3([1, 2, 3, 4]) == [3]\nassert op_uniq_rev_div3([]) == []\nassert op_uniq_rev_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_rev_div3([5, 5, 5]) == []\nassert op_uniq_rev_div3([3, 1, 2]) == [3]\nassert op_uniq_rev_div3([10]) == []\nassert op_uniq_rev_div3([2, 4, 6]) == [6]\nassert op_uniq_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_square_div3_first3", "entry_point": "op_square_div3_first3", "primitives": ["square", "div3", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep multiples of three, then keep only the first three.", "solution": "def op_square_div3_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_square_div3_first3([1, 2, 3, 4]) == [9]\nassert op_square_div3_first3([]) == []\nassert op_square_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_square_div3_first3([5, 5, 5]) == []\nassert op_square_div3_first3([3, 1, 2]) == [9]\nassert op_square_div3_first3([10]) == []\nassert op_square_div3_first3([2, 4, 6]) == [36]\nassert op_square_div3_first3([-7, 12, -7]) == [144]"}
{"id": "op_ages_last3_rev", "entry_point": "op_ages_last3_rev", "primitives": ["ages", "last3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then reverse the order.", "solution": "def op_ages_last3_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_last3_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_last3_rev([]) == []\nassert op_ages_last3_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_last3_rev([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_square_trimends_pos", "entry_point": "op_square_trimends_pos", "primitives": ["square", "trimends", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first and last elements, then keep the positive numbers.", "solution": "def op_square_trimends_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_trimends_pos([1, 2, 3, 4]) == [4, 9]\nassert op_square_trimends_pos([]) == []\nassert op_square_trimends_pos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_trimends_pos([5, 5, 5]) == [25]\nassert op_square_trimends_pos([3, 1, 2]) == [1]\nassert op_square_trimends_pos([10]) == []\nassert op_square_trimends_pos([2, 4, 6]) == [16]\nassert op_square_trimends_pos([-7, 12, -7]) == [144]"}
{"id": "op_uniq_first3_beforezero", "entry_point": "op_uniq_first3_beforezero", "primitives": ["uniq", "first3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the first three, then keep everything before the first zero.", "solution": "def op_uniq_first3_beforezero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_uniq_first3_beforezero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_uniq_first3_beforezero([]) == []\nassert op_uniq_first3_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_uniq_first3_beforezero([5, 5, 5]) == [5]\nassert op_uniq_first3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_first3_beforezero([10]) == [10]\nassert op_uniq_first3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_first3_beforezero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_square_neg_dec", "entry_point": "op_square_neg_dec", "primitives": ["square", "neg", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the negative numbers, then subtract one from each.", "solution": "def op_square_neg_dec(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_square_neg_dec([1, 2, 3, 4]) == []\nassert op_square_neg_dec([]) == []\nassert op_square_neg_dec([-2, -1, 0, 1, 2]) == []\nassert op_square_neg_dec([5, 5, 5]) == []\nassert op_square_neg_dec([3, 1, 2]) == []\nassert op_square_neg_dec([10]) == []\nassert op_square_neg_dec([2, 4, 6]) == []\nassert op_square_neg_dec([-7, 12, -7]) == []"}
{"id": "op_sorta_beforezero_dropwhileneg", "entry_point": "op_sorta_beforezero_dropwhileneg", "primitives": ["sorta", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_sorta_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sorta_beforezero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_beforezero_dropwhileneg([]) == []\nassert op_sorta_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_sorta_beforezero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_beforezero_dropwhileneg([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_beforezero_dropwhileneg([10]) == [10]\nassert op_sorta_beforezero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_beforezero_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_odds_gt5_dropfirst", "entry_point": "op_odds_gt5_dropfirst", "primitives": ["odds", "gt5", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep values greater than five, then drop the first element.", "solution": "def op_odds_gt5_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    r = r[1:]\n    return r", "tests": "assert op_odds_gt5_dropfirst([1, 2, 3, 4]) == []\nassert op_odds_gt5_dropfirst([]) == []\nassert op_odds_gt5_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_odds_gt5_dropfirst([5, 5, 5]) == []\nassert op_odds_gt5_dropfirst([3, 1, 2]) == []\nassert op_odds_gt5_dropfirst([10]) == []\nassert op_odds_gt5_dropfirst([2, 4, 6]) == []\nassert op_odds_gt5_dropfirst([-7, 12, -7]) == []"}
{"id": "op_trimends_odds_sortabs", "entry_point": "op_trimends_odds_sortabs", "primitives": ["trimends", "odds", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the odd numbers, then sort by absolute value.", "solution": "def op_trimends_odds_sortabs(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_trimends_odds_sortabs([1, 2, 3, 4]) == [3]\nassert op_trimends_odds_sortabs([]) == []\nassert op_trimends_odds_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_odds_sortabs([5, 5, 5]) == [5]\nassert op_trimends_odds_sortabs([3, 1, 2]) == [1]\nassert op_trimends_odds_sortabs([10]) == []\nassert op_trimends_odds_sortabs([2, 4, 6]) == []\nassert op_trimends_odds_sortabs([-7, 12, -7]) == []"}
{"id": "op_neg_odds_last3", "entry_point": "op_neg_odds_last3", "primitives": ["neg", "odds", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then keep only the last three.", "solution": "def op_neg_odds_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_neg_odds_last3([1, 2, 3, 4]) == []\nassert op_neg_odds_last3([]) == []\nassert op_neg_odds_last3([-2, -1, 0, 1, 2]) == [-1]\nassert op_neg_odds_last3([5, 5, 5]) == []\nassert op_neg_odds_last3([3, 1, 2]) == []\nassert op_neg_odds_last3([10]) == []\nassert op_neg_odds_last3([2, 4, 6]) == []\nassert op_neg_odds_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_trimends_add10_double", "entry_point": "op_trimends_add10_double", "primitives": ["trimends", "add10", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then double each.", "solution": "def op_trimends_add10_double(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_trimends_add10_double([1, 2, 3, 4]) == [24, 26]\nassert op_trimends_add10_double([]) == []\nassert op_trimends_add10_double([-2, -1, 0, 1, 2]) == [18, 20, 22]\nassert op_trimends_add10_double([5, 5, 5]) == [30]\nassert op_trimends_add10_double([3, 1, 2]) == [22]\nassert op_trimends_add10_double([10]) == []\nassert op_trimends_add10_double([2, 4, 6]) == [28]\nassert op_trimends_add10_double([-7, 12, -7]) == [44]"}
{"id": "op_rev_clamp10_dropwhileneg", "entry_point": "op_rev_clamp10_dropwhileneg", "primitives": ["rev", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then cap each value at 10, then drop the leading negative values.", "solution": "def op_rev_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_rev_clamp10_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_clamp10_dropwhileneg([]) == []\nassert op_rev_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_clamp10_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_rev_clamp10_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_rev_clamp10_dropwhileneg([10]) == [10]\nassert op_rev_clamp10_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_rev_clamp10_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_dropfirst_uniq_dropwhileneg", "entry_point": "op_dropfirst_uniq_dropwhileneg", "primitives": ["dropfirst", "uniq", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_dropfirst_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_uniq_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_uniq_dropwhileneg([]) == []\nassert op_dropfirst_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_uniq_dropwhileneg([5, 5, 5]) == [5]\nassert op_dropfirst_uniq_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_dropfirst_uniq_dropwhileneg([10]) == []\nassert op_dropfirst_uniq_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_dropfirst_uniq_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_uniq_sorta_negate", "entry_point": "op_uniq_sorta_negate", "primitives": ["uniq", "sorta", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then negate each.", "solution": "def op_uniq_sorta_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_sorta_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_sorta_negate([]) == []\nassert op_uniq_sorta_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_uniq_sorta_negate([5, 5, 5]) == [-5]\nassert op_uniq_sorta_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_uniq_sorta_negate([10]) == [-10]\nassert op_uniq_sorta_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_sorta_negate([-7, 12, -7]) == [7, -12]"}
{"id": "op_square_sortabs_uniq", "entry_point": "op_square_sortabs_uniq", "primitives": ["square", "sortabs", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_square_sortabs_uniq(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_square_sortabs_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sortabs_uniq([]) == []\nassert op_square_sortabs_uniq([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_square_sortabs_uniq([5, 5, 5]) == [25]\nassert op_square_sortabs_uniq([3, 1, 2]) == [1, 4, 9]\nassert op_square_sortabs_uniq([10]) == [100]\nassert op_square_sortabs_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_square_sortabs_uniq([-7, 12, -7]) == [49, 144]"}
{"id": "op_dropfirst_absval_add10", "entry_point": "op_dropfirst_absval_add10", "primitives": ["dropfirst", "absval", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then add ten to each.", "solution": "def op_dropfirst_absval_add10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropfirst_absval_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_dropfirst_absval_add10([]) == []\nassert op_dropfirst_absval_add10([-2, -1, 0, 1, 2]) == [11, 10, 11, 12]\nassert op_dropfirst_absval_add10([5, 5, 5]) == [15, 15]\nassert op_dropfirst_absval_add10([3, 1, 2]) == [11, 12]\nassert op_dropfirst_absval_add10([10]) == []\nassert op_dropfirst_absval_add10([2, 4, 6]) == [14, 16]\nassert op_dropfirst_absval_add10([-7, 12, -7]) == [22, 17]"}
{"id": "op_absval_dropwhileneg_sum", "entry_point": "op_absval_dropwhileneg_sum", "primitives": ["absval", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then return their sum.", "solution": "def op_absval_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_absval_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_absval_dropwhileneg_sum([]) == 0\nassert op_absval_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 6\nassert op_absval_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_absval_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_absval_dropwhileneg_sum([10]) == 10\nassert op_absval_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_absval_dropwhileneg_sum([-7, 12, -7]) == 26"}
{"id": "op_dropfirst_trimends_allpos", "entry_point": "op_dropfirst_trimends_allpos", "primitives": ["dropfirst", "trimends", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_dropfirst_trimends_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_trimends_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_trimends_allpos([]) == True\nassert op_dropfirst_trimends_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_trimends_allpos([5, 5, 5]) == True\nassert op_dropfirst_trimends_allpos([3, 1, 2]) == True\nassert op_dropfirst_trimends_allpos([10]) == True\nassert op_dropfirst_trimends_allpos([2, 4, 6]) == True\nassert op_dropfirst_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_pos_sortabs_anyeven", "entry_point": "op_pos_sortabs_anyeven", "primitives": ["pos", "sortabs", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then return whether any value is even.", "solution": "def op_pos_sortabs_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_sortabs_anyeven([1, 2, 3, 4]) == True\nassert op_pos_sortabs_anyeven([]) == False\nassert op_pos_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_pos_sortabs_anyeven([5, 5, 5]) == False\nassert op_pos_sortabs_anyeven([3, 1, 2]) == True\nassert op_pos_sortabs_anyeven([10]) == True\nassert op_pos_sortabs_anyeven([2, 4, 6]) == True\nassert op_pos_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_square_padto3_last3", "entry_point": "op_square_padto3_last3", "primitives": ["square", "padto3", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_square_padto3_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_square_padto3_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_padto3_last3([]) == [0, 0, 0]\nassert op_square_padto3_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_square_padto3_last3([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3_last3([3, 1, 2]) == [9, 1, 4]\nassert op_square_padto3_last3([10]) == [100, 0, 0]\nassert op_square_padto3_last3([2, 4, 6]) == [4, 16, 36]\nassert op_square_padto3_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_inc_dec_negate", "entry_point": "op_inc_dec_negate", "primitives": ["inc", "dec", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then negate each.", "solution": "def op_inc_dec_negate(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_inc_dec_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_inc_dec_negate([]) == []\nassert op_inc_dec_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_inc_dec_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_inc_dec_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_inc_dec_negate([10]) == [-10]\nassert op_inc_dec_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_inc_dec_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_rev_gt5_inc", "entry_point": "op_rev_gt5_inc", "primitives": ["rev", "gt5", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five, then add one to each.", "solution": "def op_rev_gt5_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_gt5_inc([1, 2, 3, 4]) == []\nassert op_rev_gt5_inc([]) == []\nassert op_rev_gt5_inc([-2, -1, 0, 1, 2]) == []\nassert op_rev_gt5_inc([5, 5, 5]) == []\nassert op_rev_gt5_inc([3, 1, 2]) == []\nassert op_rev_gt5_inc([10]) == [11]\nassert op_rev_gt5_inc([2, 4, 6]) == [7]\nassert op_rev_gt5_inc([-7, 12, -7]) == [13]"}
{"id": "op_neg_sortd_evens", "entry_point": "op_neg_sortd_evens", "primitives": ["neg", "sortd", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending, then keep the even numbers.", "solution": "def op_neg_sortd_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_sortd_evens([1, 2, 3, 4]) == []\nassert op_neg_sortd_evens([]) == []\nassert op_neg_sortd_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_sortd_evens([5, 5, 5]) == []\nassert op_neg_sortd_evens([3, 1, 2]) == []\nassert op_neg_sortd_evens([10]) == []\nassert op_neg_sortd_evens([2, 4, 6]) == []\nassert op_neg_sortd_evens([-7, 12, -7]) == []"}
{"id": "op_padto3_double_max", "entry_point": "op_padto3_double_max", "primitives": ["padto3", "double", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then return the maximum (0 if empty).", "solution": "def op_padto3_double_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_padto3_double_max([1, 2, 3, 4]) == 8\nassert op_padto3_double_max([]) == 0\nassert op_padto3_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_padto3_double_max([5, 5, 5]) == 10\nassert op_padto3_double_max([3, 1, 2]) == 6\nassert op_padto3_double_max([10]) == 20\nassert op_padto3_double_max([2, 4, 6]) == 12\nassert op_padto3_double_max([-7, 12, -7]) == 24"}
{"id": "op_dropfirst_padto3_takewhilepos", "entry_point": "op_dropfirst_padto3_takewhilepos", "primitives": ["dropfirst", "padto3", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_dropfirst_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_padto3_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_padto3_takewhilepos([]) == []\nassert op_dropfirst_padto3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_padto3_takewhilepos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_padto3_takewhilepos([3, 1, 2]) == [1, 2]\nassert op_dropfirst_padto3_takewhilepos([10]) == []\nassert op_dropfirst_padto3_takewhilepos([2, 4, 6]) == [4, 6]\nassert op_dropfirst_padto3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_square_takewhilepos_uniq", "entry_point": "op_square_takewhilepos_uniq", "primitives": ["square", "takewhilepos", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then drop duplicates keeping first occurrence.", "solution": "def op_square_takewhilepos_uniq(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_square_takewhilepos_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos_uniq([]) == []\nassert op_square_takewhilepos_uniq([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_takewhilepos_uniq([5, 5, 5]) == [25]\nassert op_square_takewhilepos_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_square_takewhilepos_uniq([10]) == [100]\nassert op_square_takewhilepos_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_uniq([-7, 12, -7]) == [49, 144]"}
{"id": "op_first3_odds_evens", "entry_point": "op_first3_odds_evens", "primitives": ["first3", "odds", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then keep the even numbers.", "solution": "def op_first3_odds_evens(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_first3_odds_evens([1, 2, 3, 4]) == []\nassert op_first3_odds_evens([]) == []\nassert op_first3_odds_evens([-2, -1, 0, 1, 2]) == []\nassert op_first3_odds_evens([5, 5, 5]) == []\nassert op_first3_odds_evens([3, 1, 2]) == []\nassert op_first3_odds_evens([10]) == []\nassert op_first3_odds_evens([2, 4, 6]) == []\nassert op_first3_odds_evens([-7, 12, -7]) == []"}
{"id": "op_first3_rev_dec", "entry_point": "op_first3_rev_dec", "primitives": ["first3", "rev", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then subtract one from each.", "solution": "def op_first3_rev_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_rev_dec([1, 2, 3, 4]) == [2, 1, 0]\nassert op_first3_rev_dec([]) == []\nassert op_first3_rev_dec([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_first3_rev_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_rev_dec([3, 1, 2]) == [1, 0, 2]\nassert op_first3_rev_dec([10]) == [9]\nassert op_first3_rev_dec([2, 4, 6]) == [5, 3, 1]\nassert op_first3_rev_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_trimends_sortabs_max", "entry_point": "op_trimends_sortabs_max", "primitives": ["trimends", "sortabs", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_trimends_sortabs_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_trimends_sortabs_max([1, 2, 3, 4]) == 3\nassert op_trimends_sortabs_max([]) == 0\nassert op_trimends_sortabs_max([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_sortabs_max([5, 5, 5]) == 5\nassert op_trimends_sortabs_max([3, 1, 2]) == 1\nassert op_trimends_sortabs_max([10]) == 0\nassert op_trimends_sortabs_max([2, 4, 6]) == 4\nassert op_trimends_sortabs_max([-7, 12, -7]) == 12"}
{"id": "op_rev_beforezero_takewhilepos", "entry_point": "op_rev_beforezero_takewhilepos", "primitives": ["rev", "beforezero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_rev_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_beforezero_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_takewhilepos([]) == []\nassert op_rev_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_takewhilepos([10]) == [10]\nassert op_rev_beforezero_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_rev_sortabs_neg", "entry_point": "op_rev_sortabs_neg", "primitives": ["rev", "sortabs", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort by absolute value, then keep the negative numbers.", "solution": "def op_rev_sortabs_neg(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_rev_sortabs_neg([1, 2, 3, 4]) == []\nassert op_rev_sortabs_neg([]) == []\nassert op_rev_sortabs_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_rev_sortabs_neg([5, 5, 5]) == []\nassert op_rev_sortabs_neg([3, 1, 2]) == []\nassert op_rev_sortabs_neg([10]) == []\nassert op_rev_sortabs_neg([2, 4, 6]) == []\nassert op_rev_sortabs_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_padto3_min", "entry_point": "op_last3_padto3_min", "primitives": ["last3", "padto3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_last3_padto3_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_last3_padto3_min([1, 2, 3, 4]) == 2\nassert op_last3_padto3_min([]) == 0\nassert op_last3_padto3_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_padto3_min([5, 5, 5]) == 5\nassert op_last3_padto3_min([3, 1, 2]) == 1\nassert op_last3_padto3_min([10]) == 0\nassert op_last3_padto3_min([2, 4, 6]) == 2\nassert op_last3_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_inc_negate_alldistinct", "entry_point": "op_inc_negate_alldistinct", "primitives": ["inc", "negate", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then negate each, then return whether all values are distinct.", "solution": "def op_inc_negate_alldistinct(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_inc_negate_alldistinct([1, 2, 3, 4]) == True\nassert op_inc_negate_alldistinct([]) == True\nassert op_inc_negate_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_inc_negate_alldistinct([5, 5, 5]) == False\nassert op_inc_negate_alldistinct([3, 1, 2]) == True\nassert op_inc_negate_alldistinct([10]) == True\nassert op_inc_negate_alldistinct([2, 4, 6]) == True\nassert op_inc_negate_alldistinct([-7, 12, -7]) == False"}
{"id": "op_uniq_beforezero_rev", "entry_point": "op_uniq_beforezero_rev", "primitives": ["uniq", "beforezero", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then reverse the order.", "solution": "def op_uniq_beforezero_rev(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_uniq_beforezero_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_beforezero_rev([]) == []\nassert op_uniq_beforezero_rev([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_uniq_beforezero_rev([5, 5, 5]) == [5]\nassert op_uniq_beforezero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_uniq_beforezero_rev([10]) == [10]\nassert op_uniq_beforezero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_beforezero_rev([-7, 12, -7]) == [12, -7]"}
{"id": "op_odds_sortabs_dropfirst", "entry_point": "op_odds_sortabs_dropfirst", "primitives": ["odds", "sortabs", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then drop the first element.", "solution": "def op_odds_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_odds_sortabs_dropfirst([1, 2, 3, 4]) == [3]\nassert op_odds_sortabs_dropfirst([]) == []\nassert op_odds_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_sortabs_dropfirst([5, 5, 5]) == [5, 5]\nassert op_odds_sortabs_dropfirst([3, 1, 2]) == [3]\nassert op_odds_sortabs_dropfirst([10]) == []\nassert op_odds_sortabs_dropfirst([2, 4, 6]) == []\nassert op_odds_sortabs_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_dropwhileneg_clamp10_issorted", "entry_point": "op_dropwhileneg_clamp10_issorted", "primitives": ["dropwhileneg", "clamp10", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then return whether the list is sorted ascending.", "solution": "def op_dropwhileneg_clamp10_issorted(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    return r == sorted(r)", "tests": "assert op_dropwhileneg_clamp10_issorted([1, 2, 3, 4]) == True\nassert op_dropwhileneg_clamp10_issorted([]) == True\nassert op_dropwhileneg_clamp10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_clamp10_issorted([5, 5, 5]) == True\nassert op_dropwhileneg_clamp10_issorted([3, 1, 2]) == False\nassert op_dropwhileneg_clamp10_issorted([10]) == True\nassert op_dropwhileneg_clamp10_issorted([2, 4, 6]) == True\nassert op_dropwhileneg_clamp10_issorted([-7, 12, -7]) == False"}
{"id": "op_neg_absval_uniq", "entry_point": "op_neg_absval_uniq", "primitives": ["neg", "absval", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_neg_absval_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_neg_absval_uniq([1, 2, 3, 4]) == []\nassert op_neg_absval_uniq([]) == []\nassert op_neg_absval_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_absval_uniq([5, 5, 5]) == []\nassert op_neg_absval_uniq([3, 1, 2]) == []\nassert op_neg_absval_uniq([10]) == []\nassert op_neg_absval_uniq([2, 4, 6]) == []\nassert op_neg_absval_uniq([-7, 12, -7]) == [7]"}
{"id": "op_takewhilepos_beforezero_div3", "entry_point": "op_takewhilepos_beforezero_div3", "primitives": ["takewhilepos", "beforezero", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_takewhilepos_beforezero_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_beforezero_div3([]) == []\nassert op_takewhilepos_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_div3([5, 5, 5]) == []\nassert op_takewhilepos_beforezero_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_beforezero_div3([10]) == []\nassert op_takewhilepos_beforezero_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_beforezero_div3([-7, 12, -7]) == []"}
{"id": "op_rev_padto3_min", "entry_point": "op_rev_padto3_min", "primitives": ["rev", "padto3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_rev_padto3_min(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_rev_padto3_min([1, 2, 3, 4]) == 1\nassert op_rev_padto3_min([]) == 0\nassert op_rev_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_rev_padto3_min([5, 5, 5]) == 5\nassert op_rev_padto3_min([3, 1, 2]) == 1\nassert op_rev_padto3_min([10]) == 0\nassert op_rev_padto3_min([2, 4, 6]) == 2\nassert op_rev_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_odds_uniq_dropzeros", "entry_point": "op_odds_uniq_dropzeros", "primitives": ["odds", "uniq", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_odds_uniq_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_uniq_dropzeros([1, 2, 3, 4]) == [1, 3]\nassert op_odds_uniq_dropzeros([]) == []\nassert op_odds_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_odds_uniq_dropzeros([3, 1, 2]) == [3, 1]\nassert op_odds_uniq_dropzeros([10]) == []\nassert op_odds_uniq_dropzeros([2, 4, 6]) == []\nassert op_odds_uniq_dropzeros([-7, 12, -7]) == [-7]"}
{"id": "op_trimends_sortabs_inc", "entry_point": "op_trimends_sortabs_inc", "primitives": ["trimends", "sortabs", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then add one to each.", "solution": "def op_trimends_sortabs_inc(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_trimends_sortabs_inc([1, 2, 3, 4]) == [3, 4]\nassert op_trimends_sortabs_inc([]) == []\nassert op_trimends_sortabs_inc([-2, -1, 0, 1, 2]) == [1, 0, 2]\nassert op_trimends_sortabs_inc([5, 5, 5]) == [6]\nassert op_trimends_sortabs_inc([3, 1, 2]) == [2]\nassert op_trimends_sortabs_inc([10]) == []\nassert op_trimends_sortabs_inc([2, 4, 6]) == [5]\nassert op_trimends_sortabs_inc([-7, 12, -7]) == [13]"}
{"id": "op_padto3_last3_haszero", "entry_point": "op_padto3_last3_haszero", "primitives": ["padto3", "last3", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then return whether the list contains a zero.", "solution": "def op_padto3_last3_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return 0 in r", "tests": "assert op_padto3_last3_haszero([1, 2, 3, 4]) == False\nassert op_padto3_last3_haszero([]) == True\nassert op_padto3_last3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_last3_haszero([5, 5, 5]) == False\nassert op_padto3_last3_haszero([3, 1, 2]) == False\nassert op_padto3_last3_haszero([10]) == True\nassert op_padto3_last3_haszero([2, 4, 6]) == False\nassert op_padto3_last3_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_dropwhileneg_pos", "entry_point": "op_clamp10_dropwhileneg_pos", "primitives": ["clamp10", "dropwhileneg", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_clamp10_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_dropwhileneg_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropwhileneg_pos([]) == []\nassert op_clamp10_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg_pos([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropwhileneg_pos([10]) == [10]\nassert op_clamp10_dropwhileneg_pos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg_pos([-7, 12, -7]) == [10]"}
{"id": "op_dropzeros_absval_oremptyzero", "entry_point": "op_dropzeros_absval_oremptyzero", "primitives": ["dropzeros", "absval", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_dropzeros_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_absval_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_absval_oremptyzero([]) == [0]\nassert op_dropzeros_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_absval_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_absval_oremptyzero([10]) == [10]\nassert op_dropzeros_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval_oremptyzero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_oremptyzero_uniq_anyeven", "entry_point": "op_oremptyzero_uniq_anyeven", "primitives": ["oremptyzero", "uniq", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence, then return whether any value is even.", "solution": "def op_oremptyzero_uniq_anyeven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_oremptyzero_uniq_anyeven([1, 2, 3, 4]) == True\nassert op_oremptyzero_uniq_anyeven([]) == True\nassert op_oremptyzero_uniq_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_uniq_anyeven([5, 5, 5]) == False\nassert op_oremptyzero_uniq_anyeven([3, 1, 2]) == True\nassert op_oremptyzero_uniq_anyeven([10]) == True\nassert op_oremptyzero_uniq_anyeven([2, 4, 6]) == True\nassert op_oremptyzero_uniq_anyeven([-7, 12, -7]) == True"}
{"id": "op_pos_trimends_beforezero", "entry_point": "op_pos_trimends_beforezero", "primitives": ["pos", "trimends", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_pos_trimends_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_trimends_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_pos_trimends_beforezero([]) == []\nassert op_pos_trimends_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_beforezero([5, 5, 5]) == [5]\nassert op_pos_trimends_beforezero([3, 1, 2]) == [1]\nassert op_pos_trimends_beforezero([10]) == []\nassert op_pos_trimends_beforezero([2, 4, 6]) == [4]\nassert op_pos_trimends_beforezero([-7, 12, -7]) == []"}
{"id": "op_double_sortd_sorta", "entry_point": "op_double_sortd_sorta", "primitives": ["double", "sortd", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending, then sort ascending.", "solution": "def op_double_sortd_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    return r", "tests": "assert op_double_sortd_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_sortd_sorta([]) == []\nassert op_double_sortd_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_double_sortd_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortd_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_double_sortd_sorta([10]) == [20]\nassert op_double_sortd_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_double_sortd_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_evens_neg_square", "entry_point": "op_evens_neg_square", "primitives": ["evens", "neg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers, then square each.", "solution": "def op_evens_neg_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_evens_neg_square([1, 2, 3, 4]) == []\nassert op_evens_neg_square([]) == []\nassert op_evens_neg_square([-2, -1, 0, 1, 2]) == [4]\nassert op_evens_neg_square([5, 5, 5]) == []\nassert op_evens_neg_square([3, 1, 2]) == []\nassert op_evens_neg_square([10]) == []\nassert op_evens_neg_square([2, 4, 6]) == []\nassert op_evens_neg_square([-7, 12, -7]) == []"}
{"id": "op_sortd_dropfirst_prod", "entry_point": "op_sortd_dropfirst_prod", "primitives": ["sortd", "dropfirst", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then return their product.", "solution": "def op_sortd_dropfirst_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return __import__('math').prod(r)", "tests": "assert op_sortd_dropfirst_prod([1, 2, 3, 4]) == 6\nassert op_sortd_dropfirst_prod([]) == 1\nassert op_sortd_dropfirst_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_dropfirst_prod([5, 5, 5]) == 25\nassert op_sortd_dropfirst_prod([3, 1, 2]) == 2\nassert op_sortd_dropfirst_prod([10]) == 1\nassert op_sortd_dropfirst_prod([2, 4, 6]) == 8\nassert op_sortd_dropfirst_prod([-7, 12, -7]) == 49"}
{"id": "op_add10_gt5_prod", "entry_point": "op_add10_gt5_prod", "primitives": ["add10", "gt5", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then return their product.", "solution": "def op_add10_gt5_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return __import__('math').prod(r)", "tests": "assert op_add10_gt5_prod([1, 2, 3, 4]) == 24024\nassert op_add10_gt5_prod([]) == 1\nassert op_add10_gt5_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_gt5_prod([5, 5, 5]) == 3375\nassert op_add10_gt5_prod([3, 1, 2]) == 1716\nassert op_add10_gt5_prod([10]) == 20\nassert op_add10_gt5_prod([2, 4, 6]) == 2688\nassert op_add10_gt5_prod([-7, 12, -7]) == 22"}
{"id": "op_gt5_sorta_dropfirst", "entry_point": "op_gt5_sorta_dropfirst", "primitives": ["gt5", "sorta", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then drop the first element.", "solution": "def op_gt5_sorta_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = r[1:]\n    return r", "tests": "assert op_gt5_sorta_dropfirst([1, 2, 3, 4]) == []\nassert op_gt5_sorta_dropfirst([]) == []\nassert op_gt5_sorta_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_dropfirst([5, 5, 5]) == []\nassert op_gt5_sorta_dropfirst([3, 1, 2]) == []\nassert op_gt5_sorta_dropfirst([10]) == []\nassert op_gt5_sorta_dropfirst([2, 4, 6]) == []\nassert op_gt5_sorta_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sorta_sortd_odds", "entry_point": "op_sorta_sortd_odds", "primitives": ["sorta", "sortd", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then keep the odd numbers.", "solution": "def op_sorta_sortd_odds(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sorta_sortd_odds([1, 2, 3, 4]) == [3, 1]\nassert op_sorta_sortd_odds([]) == []\nassert op_sorta_sortd_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sorta_sortd_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_sortd_odds([3, 1, 2]) == [3, 1]\nassert op_sorta_sortd_odds([10]) == []\nassert op_sorta_sortd_odds([2, 4, 6]) == []\nassert op_sorta_sortd_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_inc_last3_oremptyzero", "entry_point": "op_inc_last3_oremptyzero", "primitives": ["inc", "last3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then if empty, use a single zero.", "solution": "def op_inc_last3_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_last3_oremptyzero([1, 2, 3, 4]) == [3, 4, 5]\nassert op_inc_last3_oremptyzero([]) == [0]\nassert op_inc_last3_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_last3_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_last3_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_inc_last3_oremptyzero([10]) == [11]\nassert op_inc_last3_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_last3_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortabs_takewhilepos_absval", "entry_point": "op_sortabs_takewhilepos_absval", "primitives": ["sortabs", "takewhilepos", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then take the absolute value of each.", "solution": "def op_sortabs_takewhilepos_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_takewhilepos_absval([]) == []\nassert op_sortabs_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_takewhilepos_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_takewhilepos_absval([10]) == [10]\nassert op_sortabs_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_takewhilepos_absval([-7, 12, -7]) == []"}
{"id": "op_rev_div3_alldistinct", "entry_point": "op_rev_div3_alldistinct", "primitives": ["rev", "div3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then return whether all values are distinct.", "solution": "def op_rev_div3_alldistinct(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_rev_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_rev_div3_alldistinct([]) == True\nassert op_rev_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_rev_div3_alldistinct([5, 5, 5]) == True\nassert op_rev_div3_alldistinct([3, 1, 2]) == True\nassert op_rev_div3_alldistinct([10]) == True\nassert op_rev_div3_alldistinct([2, 4, 6]) == True\nassert op_rev_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sorta_takewhilepos_firsteven", "entry_point": "op_sorta_takewhilepos_firsteven", "primitives": ["sorta", "takewhilepos", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_sorta_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_takewhilepos_firsteven([]) == 0\nassert op_sorta_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_sorta_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_sorta_takewhilepos_firsteven([10]) == 10\nassert op_sorta_takewhilepos_firsteven([2, 4, 6]) == 2\nassert op_sorta_takewhilepos_firsteven([-7, 12, -7]) == 0"}
{"id": "op_evens_pos_dropfirst", "entry_point": "op_evens_pos_dropfirst", "primitives": ["evens", "pos", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers, then drop the first element.", "solution": "def op_evens_pos_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_evens_pos_dropfirst([1, 2, 3, 4]) == [4]\nassert op_evens_pos_dropfirst([]) == []\nassert op_evens_pos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_evens_pos_dropfirst([5, 5, 5]) == []\nassert op_evens_pos_dropfirst([3, 1, 2]) == []\nassert op_evens_pos_dropfirst([10]) == []\nassert op_evens_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_evens_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_absval_rev_gt5", "entry_point": "op_absval_rev_gt5", "primitives": ["absval", "rev", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then keep values greater than five.", "solution": "def op_absval_rev_gt5(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_absval_rev_gt5([1, 2, 3, 4]) == []\nassert op_absval_rev_gt5([]) == []\nassert op_absval_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_absval_rev_gt5([5, 5, 5]) == []\nassert op_absval_rev_gt5([3, 1, 2]) == []\nassert op_absval_rev_gt5([10]) == [10]\nassert op_absval_rev_gt5([2, 4, 6]) == [6]\nassert op_absval_rev_gt5([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_pos_square_dropfirst", "entry_point": "op_pos_square_dropfirst", "primitives": ["pos", "square", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then drop the first element.", "solution": "def op_pos_square_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_pos_square_dropfirst([1, 2, 3, 4]) == [4, 9, 16]\nassert op_pos_square_dropfirst([]) == []\nassert op_pos_square_dropfirst([-2, -1, 0, 1, 2]) == [4]\nassert op_pos_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_pos_square_dropfirst([3, 1, 2]) == [1, 4]\nassert op_pos_square_dropfirst([10]) == []\nassert op_pos_square_dropfirst([2, 4, 6]) == [16, 36]\nassert op_pos_square_dropfirst([-7, 12, -7]) == []"}
{"id": "op_negate_double_issorted", "entry_point": "op_negate_double_issorted", "primitives": ["negate", "double", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then return whether the list is sorted ascending.", "solution": "def op_negate_double_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_negate_double_issorted([1, 2, 3, 4]) == False\nassert op_negate_double_issorted([]) == True\nassert op_negate_double_issorted([-2, -1, 0, 1, 2]) == False\nassert op_negate_double_issorted([5, 5, 5]) == True\nassert op_negate_double_issorted([3, 1, 2]) == False\nassert op_negate_double_issorted([10]) == True\nassert op_negate_double_issorted([2, 4, 6]) == False\nassert op_negate_double_issorted([-7, 12, -7]) == False"}
{"id": "op_dec_square_anyeven", "entry_point": "op_dec_square_anyeven", "primitives": ["dec", "square", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then return whether any value is even.", "solution": "def op_dec_square_anyeven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dec_square_anyeven([1, 2, 3, 4]) == True\nassert op_dec_square_anyeven([]) == False\nassert op_dec_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dec_square_anyeven([5, 5, 5]) == True\nassert op_dec_square_anyeven([3, 1, 2]) == True\nassert op_dec_square_anyeven([10]) == False\nassert op_dec_square_anyeven([2, 4, 6]) == False\nassert op_dec_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_square_sortabs_anyeven", "entry_point": "op_square_sortabs_anyeven", "primitives": ["square", "sortabs", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then return whether any value is even.", "solution": "def op_square_sortabs_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_sortabs_anyeven([1, 2, 3, 4]) == True\nassert op_square_sortabs_anyeven([]) == False\nassert op_square_sortabs_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_sortabs_anyeven([5, 5, 5]) == False\nassert op_square_sortabs_anyeven([3, 1, 2]) == True\nassert op_square_sortabs_anyeven([10]) == True\nassert op_square_sortabs_anyeven([2, 4, 6]) == True\nassert op_square_sortabs_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_dropfirst_sortabs", "entry_point": "op_negate_dropfirst_sortabs", "primitives": ["negate", "dropfirst", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then sort by absolute value.", "solution": "def op_negate_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_dropfirst_sortabs([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_dropfirst_sortabs([]) == []\nassert op_negate_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, -2]\nassert op_negate_dropfirst_sortabs([5, 5, 5]) == [-5, -5]\nassert op_negate_dropfirst_sortabs([3, 1, 2]) == [-1, -2]\nassert op_negate_dropfirst_sortabs([10]) == []\nassert op_negate_dropfirst_sortabs([2, 4, 6]) == [-4, -6]\nassert op_negate_dropfirst_sortabs([-7, 12, -7]) == [7, -12]"}
{"id": "op_neg_rev_negate", "entry_point": "op_neg_rev_negate", "primitives": ["neg", "rev", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then negate each.", "solution": "def op_neg_rev_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_rev_negate([1, 2, 3, 4]) == []\nassert op_neg_rev_negate([]) == []\nassert op_neg_rev_negate([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_neg_rev_negate([5, 5, 5]) == []\nassert op_neg_rev_negate([3, 1, 2]) == []\nassert op_neg_rev_negate([10]) == []\nassert op_neg_rev_negate([2, 4, 6]) == []\nassert op_neg_rev_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_absval_add10_alldistinct", "entry_point": "op_absval_add10_alldistinct", "primitives": ["absval", "add10", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then return whether all values are distinct.", "solution": "def op_absval_add10_alldistinct(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_absval_add10_alldistinct([1, 2, 3, 4]) == True\nassert op_absval_add10_alldistinct([]) == True\nassert op_absval_add10_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_absval_add10_alldistinct([5, 5, 5]) == False\nassert op_absval_add10_alldistinct([3, 1, 2]) == True\nassert op_absval_add10_alldistinct([10]) == True\nassert op_absval_add10_alldistinct([2, 4, 6]) == True\nassert op_absval_add10_alldistinct([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_inc_anyeven", "entry_point": "op_oremptyzero_inc_anyeven", "primitives": ["oremptyzero", "inc", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each, then return whether any value is even.", "solution": "def op_oremptyzero_inc_anyeven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_oremptyzero_inc_anyeven([1, 2, 3, 4]) == True\nassert op_oremptyzero_inc_anyeven([]) == False\nassert op_oremptyzero_inc_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_inc_anyeven([5, 5, 5]) == True\nassert op_oremptyzero_inc_anyeven([3, 1, 2]) == True\nassert op_oremptyzero_inc_anyeven([10]) == False\nassert op_oremptyzero_inc_anyeven([2, 4, 6]) == False\nassert op_oremptyzero_inc_anyeven([-7, 12, -7]) == True"}
{"id": "op_neg_dropzeros_dropwhileneg", "entry_point": "op_neg_dropzeros_dropwhileneg", "primitives": ["neg", "dropzeros", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then drop the leading negative values.", "solution": "def op_neg_dropzeros_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_dropzeros_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_dropzeros_dropwhileneg([]) == []\nassert op_neg_dropzeros_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropzeros_dropwhileneg([5, 5, 5]) == []\nassert op_neg_dropzeros_dropwhileneg([3, 1, 2]) == []\nassert op_neg_dropzeros_dropwhileneg([10]) == []\nassert op_neg_dropzeros_dropwhileneg([2, 4, 6]) == []\nassert op_neg_dropzeros_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_clamp10_sortabs_add10", "entry_point": "op_clamp10_sortabs_add10", "primitives": ["clamp10", "sortabs", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then add ten to each.", "solution": "def op_clamp10_sortabs_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_sortabs_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_sortabs_add10([]) == []\nassert op_clamp10_sortabs_add10([-2, -1, 0, 1, 2]) == [10, 9, 11, 8, 12]\nassert op_clamp10_sortabs_add10([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_sortabs_add10([3, 1, 2]) == [11, 12, 13]\nassert op_clamp10_sortabs_add10([10]) == [20]\nassert op_clamp10_sortabs_add10([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_sortabs_add10([-7, 12, -7]) == [3, 3, 20]"}
{"id": "op_uniq_neg_dropwhileneg", "entry_point": "op_uniq_neg_dropwhileneg", "primitives": ["uniq", "neg", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the negative numbers, then drop the leading negative values.", "solution": "def op_uniq_neg_dropwhileneg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_uniq_neg_dropwhileneg([1, 2, 3, 4]) == []\nassert op_uniq_neg_dropwhileneg([]) == []\nassert op_uniq_neg_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_uniq_neg_dropwhileneg([5, 5, 5]) == []\nassert op_uniq_neg_dropwhileneg([3, 1, 2]) == []\nassert op_uniq_neg_dropwhileneg([10]) == []\nassert op_uniq_neg_dropwhileneg([2, 4, 6]) == []\nassert op_uniq_neg_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_dropfirst_beforezero_gt5", "entry_point": "op_dropfirst_beforezero_gt5", "primitives": ["dropfirst", "beforezero", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_dropfirst_beforezero_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_dropfirst_beforezero_gt5([]) == []\nassert op_dropfirst_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_beforezero_gt5([5, 5, 5]) == []\nassert op_dropfirst_beforezero_gt5([3, 1, 2]) == []\nassert op_dropfirst_beforezero_gt5([10]) == []\nassert op_dropfirst_beforezero_gt5([2, 4, 6]) == [6]\nassert op_dropfirst_beforezero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_beforezero_dropzeros", "entry_point": "op_dropfirst_beforezero_dropzeros", "primitives": ["dropfirst", "beforezero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then drop the zeros.", "solution": "def op_dropfirst_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_beforezero_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_beforezero_dropzeros([]) == []\nassert op_dropfirst_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropfirst_beforezero_dropzeros([5, 5, 5]) == [5, 5]\nassert op_dropfirst_beforezero_dropzeros([3, 1, 2]) == [1, 2]\nassert op_dropfirst_beforezero_dropzeros([10]) == []\nassert op_dropfirst_beforezero_dropzeros([2, 4, 6]) == [4, 6]\nassert op_dropfirst_beforezero_dropzeros([-7, 12, -7]) == [12, -7]"}
{"id": "op_first3_negate_issorted", "entry_point": "op_first3_negate_issorted", "primitives": ["first3", "negate", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then negate each, then return whether the list is sorted ascending.", "solution": "def op_first3_negate_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [-x for x in r]\n    return r == sorted(r)", "tests": "assert op_first3_negate_issorted([1, 2, 3, 4]) == False\nassert op_first3_negate_issorted([]) == True\nassert op_first3_negate_issorted([-2, -1, 0, 1, 2]) == False\nassert op_first3_negate_issorted([5, 5, 5]) == True\nassert op_first3_negate_issorted([3, 1, 2]) == False\nassert op_first3_negate_issorted([10]) == True\nassert op_first3_negate_issorted([2, 4, 6]) == False\nassert op_first3_negate_issorted([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_sortabs_dropfirst", "entry_point": "op_dropwhileneg_sortabs_dropfirst", "primitives": ["dropwhileneg", "sortabs", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then drop the first element.", "solution": "def op_dropwhileneg_sortabs_dropfirst(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    r = r[1:]\n    return r", "tests": "assert op_dropwhileneg_sortabs_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_sortabs_dropfirst([]) == []\nassert op_dropwhileneg_sortabs_dropfirst([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_sortabs_dropfirst([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_sortabs_dropfirst([3, 1, 2]) == [2, 3]\nassert op_dropwhileneg_sortabs_dropfirst([10]) == []\nassert op_dropwhileneg_sortabs_dropfirst([2, 4, 6]) == [4, 6]\nassert op_dropwhileneg_sortabs_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_last3_square", "entry_point": "op_dropzeros_last3_square", "primitives": ["dropzeros", "last3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then square each.", "solution": "def op_dropzeros_last3_square(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropzeros_last3_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropzeros_last3_square([]) == []\nassert op_dropzeros_last3_square([-2, -1, 0, 1, 2]) == [1, 1, 4]\nassert op_dropzeros_last3_square([5, 5, 5]) == [25, 25, 25]\nassert op_dropzeros_last3_square([3, 1, 2]) == [9, 1, 4]\nassert op_dropzeros_last3_square([10]) == [100]\nassert op_dropzeros_last3_square([2, 4, 6]) == [4, 16, 36]\nassert op_dropzeros_last3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_sortabs_dec_prod", "entry_point": "op_sortabs_dec_prod", "primitives": ["sortabs", "dec", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then return their product.", "solution": "def op_sortabs_dec_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_dec_prod([1, 2, 3, 4]) == 0\nassert op_sortabs_dec_prod([]) == 1\nassert op_sortabs_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_dec_prod([5, 5, 5]) == 64\nassert op_sortabs_dec_prod([3, 1, 2]) == 0\nassert op_sortabs_dec_prod([10]) == 9\nassert op_sortabs_dec_prod([2, 4, 6]) == 15\nassert op_sortabs_dec_prod([-7, 12, -7]) == 704"}
{"id": "op_rev_dropwhileneg_sortabs", "entry_point": "op_rev_dropwhileneg_sortabs", "primitives": ["rev", "dropwhileneg", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then sort by absolute value.", "solution": "def op_rev_dropwhileneg_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_dropwhileneg_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_dropwhileneg_sortabs([]) == []\nassert op_rev_dropwhileneg_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_rev_dropwhileneg_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropwhileneg_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_dropwhileneg_sortabs([10]) == [10]\nassert op_rev_dropwhileneg_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_dropwhileneg_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropshort_sortalpha_maxlen", "entry_point": "op_dropshort_sortalpha_maxlen", "primitives": ["dropshort", "sortalpha", "maxlen"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then sort alphabetically, then return the length of the longest string (0 if none).", "solution": "def op_dropshort_sortalpha_maxlen(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r)\n    return max((len(s) for s in r), default=0)", "tests": "assert op_dropshort_sortalpha_maxlen(['Hello', 'world']) == 5\nassert op_dropshort_sortalpha_maxlen([]) == 0\nassert op_dropshort_sortalpha_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_dropshort_sortalpha_maxlen(['one', 'one', 'Two']) == 3\nassert op_dropshort_sortalpha_maxlen(['x']) == 0\nassert op_dropshort_sortalpha_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_dec_gt5_takewhilepos", "entry_point": "op_dec_gt5_takewhilepos", "primitives": ["dec", "gt5", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep values greater than five, then take values while they are positive.", "solution": "def op_dec_gt5_takewhilepos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dec_gt5_takewhilepos([1, 2, 3, 4]) == []\nassert op_dec_gt5_takewhilepos([]) == []\nassert op_dec_gt5_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dec_gt5_takewhilepos([5, 5, 5]) == []\nassert op_dec_gt5_takewhilepos([3, 1, 2]) == []\nassert op_dec_gt5_takewhilepos([10]) == [9]\nassert op_dec_gt5_takewhilepos([2, 4, 6]) == []\nassert op_dec_gt5_takewhilepos([-7, 12, -7]) == [11]"}
{"id": "op_lower_strip_dropshort", "entry_point": "op_lower_strip_dropshort", "primitives": ["lower", "strip", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then trim whitespace from each, then drop strings shorter than three characters.", "solution": "def op_lower_strip_dropshort(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s.strip() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_lower_strip_dropshort(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_strip_dropshort([]) == []\nassert op_lower_strip_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_lower_strip_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_strip_dropshort(['x']) == []\nassert op_lower_strip_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_trimends_uniq_sum", "entry_point": "op_trimends_uniq_sum", "primitives": ["trimends", "uniq", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_trimends_uniq_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_trimends_uniq_sum([1, 2, 3, 4]) == 5\nassert op_trimends_uniq_sum([]) == 0\nassert op_trimends_uniq_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_uniq_sum([5, 5, 5]) == 5\nassert op_trimends_uniq_sum([3, 1, 2]) == 1\nassert op_trimends_uniq_sum([10]) == 0\nassert op_trimends_uniq_sum([2, 4, 6]) == 4\nassert op_trimends_uniq_sum([-7, 12, -7]) == 12"}
{"id": "op_negate_sortd_add10", "entry_point": "op_negate_sortd_add10", "primitives": ["negate", "sortd", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending, then add ten to each.", "solution": "def op_negate_sortd_add10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_negate_sortd_add10([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_sortd_add10([]) == []\nassert op_negate_sortd_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_negate_sortd_add10([5, 5, 5]) == [5, 5, 5]\nassert op_negate_sortd_add10([3, 1, 2]) == [9, 8, 7]\nassert op_negate_sortd_add10([10]) == [0]\nassert op_negate_sortd_add10([2, 4, 6]) == [8, 6, 4]\nassert op_negate_sortd_add10([-7, 12, -7]) == [17, 17, -2]"}
{"id": "op_dropwhileneg_div3_first3", "entry_point": "op_dropwhileneg_div3_first3", "primitives": ["dropwhileneg", "div3", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then keep only the first three.", "solution": "def op_dropwhileneg_div3_first3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_dropwhileneg_div3_first3([1, 2, 3, 4]) == [3]\nassert op_dropwhileneg_div3_first3([]) == []\nassert op_dropwhileneg_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_div3_first3([5, 5, 5]) == []\nassert op_dropwhileneg_div3_first3([3, 1, 2]) == [3]\nassert op_dropwhileneg_div3_first3([10]) == []\nassert op_dropwhileneg_div3_first3([2, 4, 6]) == [6]\nassert op_dropwhileneg_div3_first3([-7, 12, -7]) == [12]"}
{"id": "op_add10_first3_len", "entry_point": "op_add10_first3_len", "primitives": ["add10", "first3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then return how many remain.", "solution": "def op_add10_first3_len(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return len(r)", "tests": "assert op_add10_first3_len([1, 2, 3, 4]) == 3\nassert op_add10_first3_len([]) == 0\nassert op_add10_first3_len([-2, -1, 0, 1, 2]) == 3\nassert op_add10_first3_len([5, 5, 5]) == 3\nassert op_add10_first3_len([3, 1, 2]) == 3\nassert op_add10_first3_len([10]) == 1\nassert op_add10_first3_len([2, 4, 6]) == 3\nassert op_add10_first3_len([-7, 12, -7]) == 3"}
{"id": "op_absval_pos_trimends", "entry_point": "op_absval_pos_trimends", "primitives": ["absval", "pos", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_absval_pos_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_pos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_absval_pos_trimends([]) == []\nassert op_absval_pos_trimends([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_pos_trimends([5, 5, 5]) == [5]\nassert op_absval_pos_trimends([3, 1, 2]) == [1]\nassert op_absval_pos_trimends([10]) == []\nassert op_absval_pos_trimends([2, 4, 6]) == [4]\nassert op_absval_pos_trimends([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_dropzeros_dec", "entry_point": "op_beforezero_dropzeros_dec", "primitives": ["beforezero", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then subtract one from each.", "solution": "def op_beforezero_dropzeros_dec(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_beforezero_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_beforezero_dropzeros_dec([]) == []\nassert op_beforezero_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_beforezero_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dropzeros_dec([3, 1, 2]) == [2, 0, 1]\nassert op_beforezero_dropzeros_dec([10]) == [9]\nassert op_beforezero_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_dropzeros_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_odds_clamp10_double", "entry_point": "op_odds_clamp10_double", "primitives": ["odds", "clamp10", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cap each value at 10, then double each.", "solution": "def op_odds_clamp10_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_clamp10_double([1, 2, 3, 4]) == [2, 6]\nassert op_odds_clamp10_double([]) == []\nassert op_odds_clamp10_double([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_odds_clamp10_double([5, 5, 5]) == [10, 10, 10]\nassert op_odds_clamp10_double([3, 1, 2]) == [6, 2]\nassert op_odds_clamp10_double([10]) == []\nassert op_odds_clamp10_double([2, 4, 6]) == []\nassert op_odds_clamp10_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_gt5_negate_evens", "entry_point": "op_gt5_negate_evens", "primitives": ["gt5", "negate", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then keep the even numbers.", "solution": "def op_gt5_negate_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_gt5_negate_evens([1, 2, 3, 4]) == []\nassert op_gt5_negate_evens([]) == []\nassert op_gt5_negate_evens([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_evens([5, 5, 5]) == []\nassert op_gt5_negate_evens([3, 1, 2]) == []\nassert op_gt5_negate_evens([10]) == [-10]\nassert op_gt5_negate_evens([2, 4, 6]) == [-6]\nassert op_gt5_negate_evens([-7, 12, -7]) == [-12]"}
{"id": "op_inc_takewhilepos_sum", "entry_point": "op_inc_takewhilepos_sum", "primitives": ["inc", "takewhilepos", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive, then return their sum.", "solution": "def op_inc_takewhilepos_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(r)", "tests": "assert op_inc_takewhilepos_sum([1, 2, 3, 4]) == 14\nassert op_inc_takewhilepos_sum([]) == 0\nassert op_inc_takewhilepos_sum([-2, -1, 0, 1, 2]) == 0\nassert op_inc_takewhilepos_sum([5, 5, 5]) == 18\nassert op_inc_takewhilepos_sum([3, 1, 2]) == 9\nassert op_inc_takewhilepos_sum([10]) == 11\nassert op_inc_takewhilepos_sum([2, 4, 6]) == 15\nassert op_inc_takewhilepos_sum([-7, 12, -7]) == 0"}
{"id": "op_odds_add10_len", "entry_point": "op_odds_add10_len", "primitives": ["odds", "add10", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then return how many remain.", "solution": "def op_odds_add10_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_odds_add10_len([1, 2, 3, 4]) == 2\nassert op_odds_add10_len([]) == 0\nassert op_odds_add10_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_add10_len([5, 5, 5]) == 3\nassert op_odds_add10_len([3, 1, 2]) == 2\nassert op_odds_add10_len([10]) == 0\nassert op_odds_add10_len([2, 4, 6]) == 0\nassert op_odds_add10_len([-7, 12, -7]) == 2"}
{"id": "op_dropzeros_beforezero_first3", "entry_point": "op_dropzeros_beforezero_first3", "primitives": ["dropzeros", "beforezero", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep everything before the first zero, then keep only the first three.", "solution": "def op_dropzeros_beforezero_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return r", "tests": "assert op_dropzeros_beforezero_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_beforezero_first3([]) == []\nassert op_dropzeros_beforezero_first3([-2, -1, 0, 1, 2]) == [-2, -1, 1]\nassert op_dropzeros_beforezero_first3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_beforezero_first3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_beforezero_first3([10]) == [10]\nassert op_dropzeros_beforezero_first3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_beforezero_first3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_div3_rev_prod", "entry_point": "op_div3_rev_prod", "primitives": ["div3", "rev", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then return their product.", "solution": "def op_div3_rev_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return __import__('math').prod(r)", "tests": "assert op_div3_rev_prod([1, 2, 3, 4]) == 3\nassert op_div3_rev_prod([]) == 1\nassert op_div3_rev_prod([-2, -1, 0, 1, 2]) == 0\nassert op_div3_rev_prod([5, 5, 5]) == 1\nassert op_div3_rev_prod([3, 1, 2]) == 3\nassert op_div3_rev_prod([10]) == 1\nassert op_div3_rev_prod([2, 4, 6]) == 6\nassert op_div3_rev_prod([-7, 12, -7]) == 12"}
{"id": "op_first3_div3_dec", "entry_point": "op_first3_div3_dec", "primitives": ["first3", "div3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep multiples of three, then subtract one from each.", "solution": "def op_first3_div3_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_div3_dec([1, 2, 3, 4]) == [2]\nassert op_first3_div3_dec([]) == []\nassert op_first3_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_div3_dec([5, 5, 5]) == []\nassert op_first3_div3_dec([3, 1, 2]) == [2]\nassert op_first3_div3_dec([10]) == []\nassert op_first3_div3_dec([2, 4, 6]) == [5]\nassert op_first3_div3_dec([-7, 12, -7]) == [11]"}
{"id": "op_dec_uniq_haszero", "entry_point": "op_dec_uniq_haszero", "primitives": ["dec", "uniq", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_dec_uniq_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_dec_uniq_haszero([1, 2, 3, 4]) == True\nassert op_dec_uniq_haszero([]) == False\nassert op_dec_uniq_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dec_uniq_haszero([5, 5, 5]) == False\nassert op_dec_uniq_haszero([3, 1, 2]) == True\nassert op_dec_uniq_haszero([10]) == False\nassert op_dec_uniq_haszero([2, 4, 6]) == False\nassert op_dec_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_inc_sortabs_padto3", "entry_point": "op_inc_sortabs_padto3", "primitives": ["inc", "sortabs", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_inc_sortabs_padto3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_inc_sortabs_padto3([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sortabs_padto3([]) == [0, 0, 0]\nassert op_inc_sortabs_padto3([-2, -1, 0, 1, 2]) == [0, -1, 1, 2, 3]\nassert op_inc_sortabs_padto3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortabs_padto3([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sortabs_padto3([10]) == [11, 0, 0]\nassert op_inc_sortabs_padto3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sortabs_padto3([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_rev_dropwhileneg_odds", "entry_point": "op_rev_dropwhileneg_odds", "primitives": ["rev", "dropwhileneg", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then keep the odd numbers.", "solution": "def op_rev_dropwhileneg_odds(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_rev_dropwhileneg_odds([1, 2, 3, 4]) == [3, 1]\nassert op_rev_dropwhileneg_odds([]) == []\nassert op_rev_dropwhileneg_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_rev_dropwhileneg_odds([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropwhileneg_odds([3, 1, 2]) == [1, 3]\nassert op_rev_dropwhileneg_odds([10]) == []\nassert op_rev_dropwhileneg_odds([2, 4, 6]) == []\nassert op_rev_dropwhileneg_odds([-7, 12, -7]) == [-7]"}
{"id": "op_neg_odds_div3", "entry_point": "op_neg_odds_div3", "primitives": ["neg", "odds", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then keep multiples of three.", "solution": "def op_neg_odds_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_neg_odds_div3([1, 2, 3, 4]) == []\nassert op_neg_odds_div3([]) == []\nassert op_neg_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_neg_odds_div3([5, 5, 5]) == []\nassert op_neg_odds_div3([3, 1, 2]) == []\nassert op_neg_odds_div3([10]) == []\nassert op_neg_odds_div3([2, 4, 6]) == []\nassert op_neg_odds_div3([-7, 12, -7]) == []"}
{"id": "op_negate_neg_allpos", "entry_point": "op_negate_neg_allpos", "primitives": ["negate", "neg", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the negative numbers, then return whether all values are positive.", "solution": "def op_negate_neg_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return all(x > 0 for x in r)", "tests": "assert op_negate_neg_allpos([1, 2, 3, 4]) == False\nassert op_negate_neg_allpos([]) == True\nassert op_negate_neg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_neg_allpos([5, 5, 5]) == False\nassert op_negate_neg_allpos([3, 1, 2]) == False\nassert op_negate_neg_allpos([10]) == False\nassert op_negate_neg_allpos([2, 4, 6]) == False\nassert op_negate_neg_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_evens_pos", "entry_point": "op_div3_evens_pos", "primitives": ["div3", "evens", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then keep the positive numbers.", "solution": "def op_div3_evens_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_div3_evens_pos([1, 2, 3, 4]) == []\nassert op_div3_evens_pos([]) == []\nassert op_div3_evens_pos([-2, -1, 0, 1, 2]) == []\nassert op_div3_evens_pos([5, 5, 5]) == []\nassert op_div3_evens_pos([3, 1, 2]) == []\nassert op_div3_evens_pos([10]) == []\nassert op_div3_evens_pos([2, 4, 6]) == [6]\nassert op_div3_evens_pos([-7, 12, -7]) == [12]"}
{"id": "op_double_evens_beforezero", "entry_point": "op_double_evens_beforezero", "primitives": ["double", "evens", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_double_evens_beforezero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_double_evens_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_evens_beforezero([]) == []\nassert op_double_evens_beforezero([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_evens_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_double_evens_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_double_evens_beforezero([10]) == [20]\nassert op_double_evens_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_double_evens_beforezero([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_sortabs_div3_alldistinct", "entry_point": "op_sortabs_div3_alldistinct", "primitives": ["sortabs", "div3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep multiples of three, then return whether all values are distinct.", "solution": "def op_sortabs_div3_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortabs_div3_alldistinct([1, 2, 3, 4]) == True\nassert op_sortabs_div3_alldistinct([]) == True\nassert op_sortabs_div3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_div3_alldistinct([5, 5, 5]) == True\nassert op_sortabs_div3_alldistinct([3, 1, 2]) == True\nassert op_sortabs_div3_alldistinct([10]) == True\nassert op_sortabs_div3_alldistinct([2, 4, 6]) == True\nassert op_sortabs_div3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_negate_dec_dropwhileneg", "entry_point": "op_negate_dec_dropwhileneg", "primitives": ["negate", "dec", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then drop the leading negative values.", "solution": "def op_negate_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_negate_dec_dropwhileneg([1, 2, 3, 4]) == []\nassert op_negate_dec_dropwhileneg([]) == []\nassert op_negate_dec_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_negate_dec_dropwhileneg([5, 5, 5]) == []\nassert op_negate_dec_dropwhileneg([3, 1, 2]) == []\nassert op_negate_dec_dropwhileneg([10]) == []\nassert op_negate_dec_dropwhileneg([2, 4, 6]) == []\nassert op_negate_dec_dropwhileneg([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_oremptyzero_sorta_firsteven", "entry_point": "op_oremptyzero_sorta_firsteven", "primitives": ["oremptyzero", "sorta", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then return the first even value (0 if none).", "solution": "def op_oremptyzero_sorta_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_sorta_firsteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_sorta_firsteven([]) == 0\nassert op_oremptyzero_sorta_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_sorta_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_sorta_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_sorta_firsteven([10]) == 10\nassert op_oremptyzero_sorta_firsteven([2, 4, 6]) == 2\nassert op_oremptyzero_sorta_firsteven([-7, 12, -7]) == 12"}
{"id": "op_last3_rev_odds", "entry_point": "op_last3_rev_odds", "primitives": ["last3", "rev", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then keep the odd numbers.", "solution": "def op_last3_rev_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_rev_odds([1, 2, 3, 4]) == [3]\nassert op_last3_rev_odds([]) == []\nassert op_last3_rev_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_last3_rev_odds([5, 5, 5]) == [5, 5, 5]\nassert op_last3_rev_odds([3, 1, 2]) == [1, 3]\nassert op_last3_rev_odds([10]) == []\nassert op_last3_rev_odds([2, 4, 6]) == []\nassert op_last3_rev_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_double_pos_allpos", "entry_point": "op_double_pos_allpos", "primitives": ["double", "pos", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then return whether all values are positive.", "solution": "def op_double_pos_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return all(x > 0 for x in r)", "tests": "assert op_double_pos_allpos([1, 2, 3, 4]) == True\nassert op_double_pos_allpos([]) == True\nassert op_double_pos_allpos([-2, -1, 0, 1, 2]) == True\nassert op_double_pos_allpos([5, 5, 5]) == True\nassert op_double_pos_allpos([3, 1, 2]) == True\nassert op_double_pos_allpos([10]) == True\nassert op_double_pos_allpos([2, 4, 6]) == True\nassert op_double_pos_allpos([-7, 12, -7]) == True"}
{"id": "op_padto3_oremptyzero_clamp10", "entry_point": "op_padto3_oremptyzero_clamp10", "primitives": ["padto3", "oremptyzero", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then cap each value at 10.", "solution": "def op_padto3_oremptyzero_clamp10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_padto3_oremptyzero_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_oremptyzero_clamp10([]) == [0, 0, 0]\nassert op_padto3_oremptyzero_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_oremptyzero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_oremptyzero_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_oremptyzero_clamp10([10]) == [10, 0, 0]\nassert op_padto3_oremptyzero_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_oremptyzero_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_takewhilepos_dec_neg", "entry_point": "op_takewhilepos_dec_neg", "primitives": ["takewhilepos", "dec", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then keep the negative numbers.", "solution": "def op_takewhilepos_dec_neg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_takewhilepos_dec_neg([1, 2, 3, 4]) == []\nassert op_takewhilepos_dec_neg([]) == []\nassert op_takewhilepos_dec_neg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec_neg([5, 5, 5]) == []\nassert op_takewhilepos_dec_neg([3, 1, 2]) == []\nassert op_takewhilepos_dec_neg([10]) == []\nassert op_takewhilepos_dec_neg([2, 4, 6]) == []\nassert op_takewhilepos_dec_neg([-7, 12, -7]) == []"}
{"id": "op_last3_neg_trimends", "entry_point": "op_last3_neg_trimends", "primitives": ["last3", "neg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_last3_neg_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_neg_trimends([1, 2, 3, 4]) == []\nassert op_last3_neg_trimends([]) == []\nassert op_last3_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_last3_neg_trimends([5, 5, 5]) == []\nassert op_last3_neg_trimends([3, 1, 2]) == []\nassert op_last3_neg_trimends([10]) == []\nassert op_last3_neg_trimends([2, 4, 6]) == []\nassert op_last3_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_last3_dec_clamp10", "entry_point": "op_last3_dec_clamp10", "primitives": ["last3", "dec", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then cap each value at 10.", "solution": "def op_last3_dec_clamp10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_last3_dec_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_last3_dec_clamp10([]) == []\nassert op_last3_dec_clamp10([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_last3_dec_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_last3_dec_clamp10([3, 1, 2]) == [2, 0, 1]\nassert op_last3_dec_clamp10([10]) == [9]\nassert op_last3_dec_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_last3_dec_clamp10([-7, 12, -7]) == [-8, 10, -8]"}
{"id": "op_gt5_last3_rev", "entry_point": "op_gt5_last3_rev", "primitives": ["gt5", "last3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three, then reverse the order.", "solution": "def op_gt5_last3_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_gt5_last3_rev([1, 2, 3, 4]) == []\nassert op_gt5_last3_rev([]) == []\nassert op_gt5_last3_rev([-2, -1, 0, 1, 2]) == []\nassert op_gt5_last3_rev([5, 5, 5]) == []\nassert op_gt5_last3_rev([3, 1, 2]) == []\nassert op_gt5_last3_rev([10]) == [10]\nassert op_gt5_last3_rev([2, 4, 6]) == [6]\nassert op_gt5_last3_rev([-7, 12, -7]) == [12]"}
{"id": "op_square_absval_double", "entry_point": "op_square_absval_double", "primitives": ["square", "absval", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each, then double each.", "solution": "def op_square_absval_double(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_square_absval_double([1, 2, 3, 4]) == [2, 8, 18, 32]\nassert op_square_absval_double([]) == []\nassert op_square_absval_double([-2, -1, 0, 1, 2]) == [8, 2, 0, 2, 8]\nassert op_square_absval_double([5, 5, 5]) == [50, 50, 50]\nassert op_square_absval_double([3, 1, 2]) == [18, 2, 8]\nassert op_square_absval_double([10]) == [200]\nassert op_square_absval_double([2, 4, 6]) == [8, 32, 72]\nassert op_square_absval_double([-7, 12, -7]) == [98, 288, 98]"}
{"id": "op_trimends_negate_dec", "entry_point": "op_trimends_negate_dec", "primitives": ["trimends", "negate", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then subtract one from each.", "solution": "def op_trimends_negate_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_negate_dec([1, 2, 3, 4]) == [-3, -4]\nassert op_trimends_negate_dec([]) == []\nassert op_trimends_negate_dec([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_trimends_negate_dec([5, 5, 5]) == [-6]\nassert op_trimends_negate_dec([3, 1, 2]) == [-2]\nassert op_trimends_negate_dec([10]) == []\nassert op_trimends_negate_dec([2, 4, 6]) == [-5]\nassert op_trimends_negate_dec([-7, 12, -7]) == [-13]"}
{"id": "op_dropzeros_sortd_firsteven", "entry_point": "op_dropzeros_sortd_firsteven", "primitives": ["dropzeros", "sortd", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending, then return the first even value (0 if none).", "solution": "def op_dropzeros_sortd_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_sortd_firsteven([1, 2, 3, 4]) == 4\nassert op_dropzeros_sortd_firsteven([]) == 0\nassert op_dropzeros_sortd_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_sortd_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_sortd_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_sortd_firsteven([10]) == 10\nassert op_dropzeros_sortd_firsteven([2, 4, 6]) == 6\nassert op_dropzeros_sortd_firsteven([-7, 12, -7]) == 12"}
{"id": "op_neg_uniq_negate", "entry_point": "op_neg_uniq_negate", "primitives": ["neg", "uniq", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_neg_uniq_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_uniq_negate([1, 2, 3, 4]) == []\nassert op_neg_uniq_negate([]) == []\nassert op_neg_uniq_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_uniq_negate([5, 5, 5]) == []\nassert op_neg_uniq_negate([3, 1, 2]) == []\nassert op_neg_uniq_negate([10]) == []\nassert op_neg_uniq_negate([2, 4, 6]) == []\nassert op_neg_uniq_negate([-7, 12, -7]) == [7]"}
{"id": "op_double_add10_trimends", "entry_point": "op_double_add10_trimends", "primitives": ["double", "add10", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then drop the first and last elements.", "solution": "def op_double_add10_trimends(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_double_add10_trimends([1, 2, 3, 4]) == [14, 16]\nassert op_double_add10_trimends([]) == []\nassert op_double_add10_trimends([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_double_add10_trimends([5, 5, 5]) == [20]\nassert op_double_add10_trimends([3, 1, 2]) == [12]\nassert op_double_add10_trimends([10]) == []\nassert op_double_add10_trimends([2, 4, 6]) == [18]\nassert op_double_add10_trimends([-7, 12, -7]) == [34]"}
{"id": "op_div3_sorta_sum", "entry_point": "op_div3_sorta_sum", "primitives": ["div3", "sorta", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending, then return their sum.", "solution": "def op_div3_sorta_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_div3_sorta_sum([1, 2, 3, 4]) == 3\nassert op_div3_sorta_sum([]) == 0\nassert op_div3_sorta_sum([-2, -1, 0, 1, 2]) == 0\nassert op_div3_sorta_sum([5, 5, 5]) == 0\nassert op_div3_sorta_sum([3, 1, 2]) == 3\nassert op_div3_sorta_sum([10]) == 0\nassert op_div3_sorta_sum([2, 4, 6]) == 6\nassert op_div3_sorta_sum([-7, 12, -7]) == 12"}
{"id": "op_first3_sortd_rev", "entry_point": "op_first3_sortd_rev", "primitives": ["first3", "sortd", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then reverse the order.", "solution": "def op_first3_sortd_rev(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    r = list(reversed(r))\n    return r", "tests": "assert op_first3_sortd_rev([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_sortd_rev([]) == []\nassert op_first3_sortd_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_sortd_rev([5, 5, 5]) == [5, 5, 5]\nassert op_first3_sortd_rev([3, 1, 2]) == [1, 2, 3]\nassert op_first3_sortd_rev([10]) == [10]\nassert op_first3_sortd_rev([2, 4, 6]) == [2, 4, 6]\nassert op_first3_sortd_rev([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dec_first3_dropwhileneg", "entry_point": "op_dec_first3_dropwhileneg", "primitives": ["dec", "first3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then drop the leading negative values.", "solution": "def op_dec_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dec_first3_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2]\nassert op_dec_first3_dropwhileneg([]) == []\nassert op_dec_first3_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_dec_first3_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_dec_first3_dropwhileneg([10]) == [9]\nassert op_dec_first3_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3_dropwhileneg([-7, 12, -7]) == [11, -8]"}
{"id": "op_neg_clamp10_pos", "entry_point": "op_neg_clamp10_pos", "primitives": ["neg", "clamp10", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then keep the positive numbers.", "solution": "def op_neg_clamp10_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_neg_clamp10_pos([1, 2, 3, 4]) == []\nassert op_neg_clamp10_pos([]) == []\nassert op_neg_clamp10_pos([-2, -1, 0, 1, 2]) == []\nassert op_neg_clamp10_pos([5, 5, 5]) == []\nassert op_neg_clamp10_pos([3, 1, 2]) == []\nassert op_neg_clamp10_pos([10]) == []\nassert op_neg_clamp10_pos([2, 4, 6]) == []\nassert op_neg_clamp10_pos([-7, 12, -7]) == []"}
{"id": "op_negate_odds_gt5", "entry_point": "op_negate_odds_gt5", "primitives": ["negate", "odds", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then keep values greater than five.", "solution": "def op_negate_odds_gt5(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_negate_odds_gt5([1, 2, 3, 4]) == []\nassert op_negate_odds_gt5([]) == []\nassert op_negate_odds_gt5([-2, -1, 0, 1, 2]) == []\nassert op_negate_odds_gt5([5, 5, 5]) == []\nassert op_negate_odds_gt5([3, 1, 2]) == []\nassert op_negate_odds_gt5([10]) == []\nassert op_negate_odds_gt5([2, 4, 6]) == []\nassert op_negate_odds_gt5([-7, 12, -7]) == [7, 7]"}
{"id": "op_last3_padto3_sorta", "entry_point": "op_last3_padto3_sorta", "primitives": ["last3", "padto3", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then sort ascending.", "solution": "def op_last3_padto3_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    return r", "tests": "assert op_last3_padto3_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_padto3_sorta([]) == [0, 0, 0]\nassert op_last3_padto3_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_padto3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_padto3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_padto3_sorta([10]) == [0, 0, 10]\nassert op_last3_padto3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_padto3_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_dropwhileneg_counteven", "entry_point": "op_sortabs_dropwhileneg_counteven", "primitives": ["sortabs", "dropwhileneg", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then return how many values are even.", "solution": "def op_sortabs_dropwhileneg_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortabs_dropwhileneg_counteven([1, 2, 3, 4]) == 2\nassert op_sortabs_dropwhileneg_counteven([]) == 0\nassert op_sortabs_dropwhileneg_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sortabs_dropwhileneg_counteven([5, 5, 5]) == 0\nassert op_sortabs_dropwhileneg_counteven([3, 1, 2]) == 1\nassert op_sortabs_dropwhileneg_counteven([10]) == 1\nassert op_sortabs_dropwhileneg_counteven([2, 4, 6]) == 3\nassert op_sortabs_dropwhileneg_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropwhileneg_negate_padto3", "entry_point": "op_dropwhileneg_negate_padto3", "primitives": ["dropwhileneg", "negate", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then pad with zeros to at least three elements.", "solution": "def op_dropwhileneg_negate_padto3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropwhileneg_negate_padto3([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropwhileneg_negate_padto3([]) == [0, 0, 0]\nassert op_dropwhileneg_negate_padto3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropwhileneg_negate_padto3([5, 5, 5]) == [-5, -5, -5]\nassert op_dropwhileneg_negate_padto3([3, 1, 2]) == [-3, -1, -2]\nassert op_dropwhileneg_negate_padto3([10]) == [-10, 0, 0]\nassert op_dropwhileneg_negate_padto3([2, 4, 6]) == [-2, -4, -6]\nassert op_dropwhileneg_negate_padto3([-7, 12, -7]) == [-12, 7, 0]"}
{"id": "op_uniq_inc_sortd", "entry_point": "op_uniq_inc_sortd", "primitives": ["uniq", "inc", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then sort descending.", "solution": "def op_uniq_inc_sortd(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_uniq_inc_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_uniq_inc_sortd([]) == []\nassert op_uniq_inc_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_uniq_inc_sortd([5, 5, 5]) == [6]\nassert op_uniq_inc_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_uniq_inc_sortd([10]) == [11]\nassert op_uniq_inc_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_uniq_inc_sortd([-7, 12, -7]) == [13, -6]"}
{"id": "op_takewhilepos_trimends_max", "entry_point": "op_takewhilepos_trimends_max", "primitives": ["takewhilepos", "trimends", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_trimends_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_trimends_max([1, 2, 3, 4]) == 3\nassert op_takewhilepos_trimends_max([]) == 0\nassert op_takewhilepos_trimends_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_trimends_max([5, 5, 5]) == 5\nassert op_takewhilepos_trimends_max([3, 1, 2]) == 1\nassert op_takewhilepos_trimends_max([10]) == 0\nassert op_takewhilepos_trimends_max([2, 4, 6]) == 4\nassert op_takewhilepos_trimends_max([-7, 12, -7]) == 0"}
{"id": "op_pos_trimends_square", "entry_point": "op_pos_trimends_square", "primitives": ["pos", "trimends", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then square each.", "solution": "def op_pos_trimends_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_trimends_square([1, 2, 3, 4]) == [4, 9]\nassert op_pos_trimends_square([]) == []\nassert op_pos_trimends_square([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_square([5, 5, 5]) == [25]\nassert op_pos_trimends_square([3, 1, 2]) == [1]\nassert op_pos_trimends_square([10]) == []\nassert op_pos_trimends_square([2, 4, 6]) == [16]\nassert op_pos_trimends_square([-7, 12, -7]) == []"}
{"id": "op_padto3_dec_max", "entry_point": "op_padto3_dec_max", "primitives": ["padto3", "dec", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then return the maximum (0 if empty).", "solution": "def op_padto3_dec_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_padto3_dec_max([1, 2, 3, 4]) == 3\nassert op_padto3_dec_max([]) == -1\nassert op_padto3_dec_max([-2, -1, 0, 1, 2]) == 1\nassert op_padto3_dec_max([5, 5, 5]) == 4\nassert op_padto3_dec_max([3, 1, 2]) == 2\nassert op_padto3_dec_max([10]) == 9\nassert op_padto3_dec_max([2, 4, 6]) == 5\nassert op_padto3_dec_max([-7, 12, -7]) == 11"}
{"id": "op_takewhilepos_gt5_sorta", "entry_point": "op_takewhilepos_gt5_sorta", "primitives": ["takewhilepos", "gt5", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then sort ascending.", "solution": "def op_takewhilepos_gt5_sorta(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_takewhilepos_gt5_sorta([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_sorta([]) == []\nassert op_takewhilepos_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_sorta([5, 5, 5]) == []\nassert op_takewhilepos_gt5_sorta([3, 1, 2]) == []\nassert op_takewhilepos_gt5_sorta([10]) == [10]\nassert op_takewhilepos_gt5_sorta([2, 4, 6]) == [6]\nassert op_takewhilepos_gt5_sorta([-7, 12, -7]) == []"}
{"id": "op_add10_square_beforezero", "entry_point": "op_add10_square_beforezero", "primitives": ["add10", "square", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then keep everything before the first zero.", "solution": "def op_add10_square_beforezero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_add10_square_beforezero([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_square_beforezero([]) == []\nassert op_add10_square_beforezero([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_square_beforezero([5, 5, 5]) == [225, 225, 225]\nassert op_add10_square_beforezero([3, 1, 2]) == [169, 121, 144]\nassert op_add10_square_beforezero([10]) == [400]\nassert op_add10_square_beforezero([2, 4, 6]) == [144, 196, 256]\nassert op_add10_square_beforezero([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_neg_trimends_inc", "entry_point": "op_neg_trimends_inc", "primitives": ["neg", "trimends", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first and last elements, then add one to each.", "solution": "def op_neg_trimends_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_neg_trimends_inc([1, 2, 3, 4]) == []\nassert op_neg_trimends_inc([]) == []\nassert op_neg_trimends_inc([-2, -1, 0, 1, 2]) == []\nassert op_neg_trimends_inc([5, 5, 5]) == []\nassert op_neg_trimends_inc([3, 1, 2]) == []\nassert op_neg_trimends_inc([10]) == []\nassert op_neg_trimends_inc([2, 4, 6]) == []\nassert op_neg_trimends_inc([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_dec_padto3", "entry_point": "op_takewhilepos_dec_padto3", "primitives": ["takewhilepos", "dec", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_takewhilepos_dec_padto3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_takewhilepos_dec_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_takewhilepos_dec_padto3([]) == [0, 0, 0]\nassert op_takewhilepos_dec_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_dec_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_dec_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_takewhilepos_dec_padto3([10]) == [9, 0, 0]\nassert op_takewhilepos_dec_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_takewhilepos_dec_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_double_rev_firsteven", "entry_point": "op_double_rev_firsteven", "primitives": ["double", "rev", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then return the first even value (0 if none).", "solution": "def op_double_rev_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_rev_firsteven([1, 2, 3, 4]) == 8\nassert op_double_rev_firsteven([]) == 0\nassert op_double_rev_firsteven([-2, -1, 0, 1, 2]) == 4\nassert op_double_rev_firsteven([5, 5, 5]) == 10\nassert op_double_rev_firsteven([3, 1, 2]) == 4\nassert op_double_rev_firsteven([10]) == 20\nassert op_double_rev_firsteven([2, 4, 6]) == 12\nassert op_double_rev_firsteven([-7, 12, -7]) == -14"}
{"id": "op_uniqs_sortalpha_lens", "entry_point": "op_uniqs_sortalpha_lens", "primitives": ["uniqs", "sortalpha", "lens"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically, then return the total number of characters.", "solution": "def op_uniqs_sortalpha_lens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return sum(len(s) for s in r)", "tests": "assert op_uniqs_sortalpha_lens(['Hello', 'world']) == 10\nassert op_uniqs_sortalpha_lens([]) == 0\nassert op_uniqs_sortalpha_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_uniqs_sortalpha_lens(['one', 'one', 'Two']) == 6\nassert op_uniqs_sortalpha_lens(['x']) == 1\nassert op_uniqs_sortalpha_lens(['abc', 'de', '']) == 5"}
{"id": "op_dec_negate_div3", "entry_point": "op_dec_negate_div3", "primitives": ["dec", "negate", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then keep multiples of three.", "solution": "def op_dec_negate_div3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dec_negate_div3([1, 2, 3, 4]) == [0, -3]\nassert op_dec_negate_div3([]) == []\nassert op_dec_negate_div3([-2, -1, 0, 1, 2]) == [3, 0]\nassert op_dec_negate_div3([5, 5, 5]) == []\nassert op_dec_negate_div3([3, 1, 2]) == [0]\nassert op_dec_negate_div3([10]) == [-9]\nassert op_dec_negate_div3([2, 4, 6]) == [-3]\nassert op_dec_negate_div3([-7, 12, -7]) == []"}
{"id": "op_dropzeros_last3_rev", "entry_point": "op_dropzeros_last3_rev", "primitives": ["dropzeros", "last3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the last three, then reverse the order.", "solution": "def op_dropzeros_last3_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropzeros_last3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropzeros_last3_rev([]) == []\nassert op_dropzeros_last3_rev([-2, -1, 0, 1, 2]) == [2, 1, -1]\nassert op_dropzeros_last3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_last3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_dropzeros_last3_rev([10]) == [10]\nassert op_dropzeros_last3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_dropzeros_last3_rev([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_absval_neg_square", "entry_point": "op_absval_neg_square", "primitives": ["absval", "neg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the negative numbers, then square each.", "solution": "def op_absval_neg_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_neg_square([1, 2, 3, 4]) == []\nassert op_absval_neg_square([]) == []\nassert op_absval_neg_square([-2, -1, 0, 1, 2]) == []\nassert op_absval_neg_square([5, 5, 5]) == []\nassert op_absval_neg_square([3, 1, 2]) == []\nassert op_absval_neg_square([10]) == []\nassert op_absval_neg_square([2, 4, 6]) == []\nassert op_absval_neg_square([-7, 12, -7]) == []"}
{"id": "op_sorta_rev_min", "entry_point": "op_sorta_rev_min", "primitives": ["sorta", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_sorta_rev_min(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_sorta_rev_min([1, 2, 3, 4]) == 1\nassert op_sorta_rev_min([]) == 0\nassert op_sorta_rev_min([-2, -1, 0, 1, 2]) == -2\nassert op_sorta_rev_min([5, 5, 5]) == 5\nassert op_sorta_rev_min([3, 1, 2]) == 1\nassert op_sorta_rev_min([10]) == 10\nassert op_sorta_rev_min([2, 4, 6]) == 2\nassert op_sorta_rev_min([-7, 12, -7]) == -7"}
{"id": "op_sorta_first3_anyeven", "entry_point": "op_sorta_first3_anyeven", "primitives": ["sorta", "first3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then return whether any value is even.", "solution": "def op_sorta_first3_anyeven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sorta_first3_anyeven([1, 2, 3, 4]) == True\nassert op_sorta_first3_anyeven([]) == False\nassert op_sorta_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sorta_first3_anyeven([5, 5, 5]) == False\nassert op_sorta_first3_anyeven([3, 1, 2]) == True\nassert op_sorta_first3_anyeven([10]) == True\nassert op_sorta_first3_anyeven([2, 4, 6]) == True\nassert op_sorta_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_dec_clamp10", "entry_point": "op_evens_dec_clamp10", "primitives": ["evens", "dec", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then subtract one from each, then cap each value at 10.", "solution": "def op_evens_dec_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_evens_dec_clamp10([1, 2, 3, 4]) == [1, 3]\nassert op_evens_dec_clamp10([]) == []\nassert op_evens_dec_clamp10([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_evens_dec_clamp10([5, 5, 5]) == []\nassert op_evens_dec_clamp10([3, 1, 2]) == [1]\nassert op_evens_dec_clamp10([10]) == [9]\nassert op_evens_dec_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_evens_dec_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_ages_dropzeros_beforezero", "entry_point": "op_ages_dropzeros_beforezero", "primitives": ["ages", "dropzeros", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros, then keep everything before the first zero.", "solution": "def op_ages_dropzeros_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_dropzeros_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropzeros_beforezero([]) == []\nassert op_ages_dropzeros_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropzeros_beforezero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_add10_pos_sortabs", "entry_point": "op_add10_pos_sortabs", "primitives": ["add10", "pos", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then sort by absolute value.", "solution": "def op_add10_pos_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_pos_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_pos_sortabs([]) == []\nassert op_add10_pos_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_pos_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_pos_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_add10_pos_sortabs([10]) == [20]\nassert op_add10_pos_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_add10_pos_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_absval_pos_counteven", "entry_point": "op_absval_pos_counteven", "primitives": ["absval", "pos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then return how many values are even.", "solution": "def op_absval_pos_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_pos_counteven([1, 2, 3, 4]) == 2\nassert op_absval_pos_counteven([]) == 0\nassert op_absval_pos_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_pos_counteven([5, 5, 5]) == 0\nassert op_absval_pos_counteven([3, 1, 2]) == 1\nassert op_absval_pos_counteven([10]) == 1\nassert op_absval_pos_counteven([2, 4, 6]) == 3\nassert op_absval_pos_counteven([-7, 12, -7]) == 1"}
{"id": "op_inc_div3_square", "entry_point": "op_inc_div3_square", "primitives": ["inc", "div3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then square each.", "solution": "def op_inc_div3_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_div3_square([1, 2, 3, 4]) == [9]\nassert op_inc_div3_square([]) == []\nassert op_inc_div3_square([-2, -1, 0, 1, 2]) == [0, 9]\nassert op_inc_div3_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_div3_square([3, 1, 2]) == [9]\nassert op_inc_div3_square([10]) == []\nassert op_inc_div3_square([2, 4, 6]) == [9]\nassert op_inc_div3_square([-7, 12, -7]) == [36, 36]"}
{"id": "op_absval_trimends_rev", "entry_point": "op_absval_trimends_rev", "primitives": ["absval", "trimends", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then reverse the order.", "solution": "def op_absval_trimends_rev(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_absval_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_absval_trimends_rev([]) == []\nassert op_absval_trimends_rev([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_absval_trimends_rev([5, 5, 5]) == [5]\nassert op_absval_trimends_rev([3, 1, 2]) == [1]\nassert op_absval_trimends_rev([10]) == []\nassert op_absval_trimends_rev([2, 4, 6]) == [4]\nassert op_absval_trimends_rev([-7, 12, -7]) == [12]"}
{"id": "op_sorta_negate_absval", "entry_point": "op_sorta_negate_absval", "primitives": ["sorta", "negate", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then take the absolute value of each.", "solution": "def op_sorta_negate_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_negate_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_negate_absval([]) == []\nassert op_sorta_negate_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_negate_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_negate_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_negate_absval([10]) == [10]\nassert op_sorta_negate_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_negate_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_div3_sortabs_allpos", "entry_point": "op_div3_sortabs_allpos", "primitives": ["div3", "sortabs", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value, then return whether all values are positive.", "solution": "def op_div3_sortabs_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_div3_sortabs_allpos([1, 2, 3, 4]) == True\nassert op_div3_sortabs_allpos([]) == True\nassert op_div3_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_div3_sortabs_allpos([5, 5, 5]) == True\nassert op_div3_sortabs_allpos([3, 1, 2]) == True\nassert op_div3_sortabs_allpos([10]) == True\nassert op_div3_sortabs_allpos([2, 4, 6]) == True\nassert op_div3_sortabs_allpos([-7, 12, -7]) == True"}
{"id": "op_padto3_dropwhileneg_clamp10", "entry_point": "op_padto3_dropwhileneg_clamp10", "primitives": ["padto3", "dropwhileneg", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then cap each value at 10.", "solution": "def op_padto3_dropwhileneg_clamp10(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_padto3_dropwhileneg_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_dropwhileneg_clamp10([]) == [0, 0, 0]\nassert op_padto3_dropwhileneg_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_dropwhileneg_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_dropwhileneg_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_dropwhileneg_clamp10([10]) == [10, 0, 0]\nassert op_padto3_dropwhileneg_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_dropwhileneg_clamp10([-7, 12, -7]) == [10, -7]"}
{"id": "op_dropfirst_rev_uniq", "entry_point": "op_dropfirst_rev_uniq", "primitives": ["dropfirst", "rev", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then reverse the order, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_rev_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_rev_uniq([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_rev_uniq([]) == []\nassert op_dropfirst_rev_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_rev_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_rev_uniq([3, 1, 2]) == [2, 1]\nassert op_dropfirst_rev_uniq([10]) == []\nassert op_dropfirst_rev_uniq([2, 4, 6]) == [6, 4]\nassert op_dropfirst_rev_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_trimends_evens_square", "entry_point": "op_trimends_evens_square", "primitives": ["trimends", "evens", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then square each.", "solution": "def op_trimends_evens_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_evens_square([1, 2, 3, 4]) == [4]\nassert op_trimends_evens_square([]) == []\nassert op_trimends_evens_square([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_evens_square([5, 5, 5]) == []\nassert op_trimends_evens_square([3, 1, 2]) == []\nassert op_trimends_evens_square([10]) == []\nassert op_trimends_evens_square([2, 4, 6]) == [16]\nassert op_trimends_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_trimends_oremptyzero_alldistinct", "entry_point": "op_trimends_oremptyzero_alldistinct", "primitives": ["trimends", "oremptyzero", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then return whether all values are distinct.", "solution": "def op_trimends_oremptyzero_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    return len(r) == len(set(r))", "tests": "assert op_trimends_oremptyzero_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_oremptyzero_alldistinct([]) == True\nassert op_trimends_oremptyzero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_oremptyzero_alldistinct([5, 5, 5]) == True\nassert op_trimends_oremptyzero_alldistinct([3, 1, 2]) == True\nassert op_trimends_oremptyzero_alldistinct([10]) == True\nassert op_trimends_oremptyzero_alldistinct([2, 4, 6]) == True\nassert op_trimends_oremptyzero_alldistinct([-7, 12, -7]) == True"}
{"id": "op_ages_dec_sortabs", "entry_point": "op_ages_dec_sortabs", "primitives": ["ages", "dec", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then sort by absolute value.", "solution": "def op_ages_dec_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_dec_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [11, 35]\nassert op_ages_dec_sortabs([]) == []\nassert op_ages_dec_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [16, 17, 64]\nassert op_ages_dec_sortabs([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_double_dropwhileneg_issorted", "entry_point": "op_double_dropwhileneg_issorted", "primitives": ["double", "dropwhileneg", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_double_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_double_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_double_dropwhileneg_issorted([]) == True\nassert op_double_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_double_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_double_dropwhileneg_issorted([10]) == True\nassert op_double_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_double_dropwhileneg_issorted([-7, 12, -7]) == False"}
{"id": "op_neg_evens_sortd", "entry_point": "op_neg_evens_sortd", "primitives": ["neg", "evens", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the even numbers, then sort descending.", "solution": "def op_neg_evens_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_neg_evens_sortd([1, 2, 3, 4]) == []\nassert op_neg_evens_sortd([]) == []\nassert op_neg_evens_sortd([-2, -1, 0, 1, 2]) == [-2]\nassert op_neg_evens_sortd([5, 5, 5]) == []\nassert op_neg_evens_sortd([3, 1, 2]) == []\nassert op_neg_evens_sortd([10]) == []\nassert op_neg_evens_sortd([2, 4, 6]) == []\nassert op_neg_evens_sortd([-7, 12, -7]) == []"}
{"id": "op_div3_pos_haszero", "entry_point": "op_div3_pos_haszero", "primitives": ["div3", "pos", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_div3_pos_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_div3_pos_haszero([1, 2, 3, 4]) == False\nassert op_div3_pos_haszero([]) == False\nassert op_div3_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_div3_pos_haszero([5, 5, 5]) == False\nassert op_div3_pos_haszero([3, 1, 2]) == False\nassert op_div3_pos_haszero([10]) == False\nassert op_div3_pos_haszero([2, 4, 6]) == False\nassert op_div3_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_clamp10_neg", "entry_point": "op_trimends_clamp10_neg", "primitives": ["trimends", "clamp10", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cap each value at 10, then keep the negative numbers.", "solution": "def op_trimends_clamp10_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_clamp10_neg([1, 2, 3, 4]) == []\nassert op_trimends_clamp10_neg([]) == []\nassert op_trimends_clamp10_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_clamp10_neg([5, 5, 5]) == []\nassert op_trimends_clamp10_neg([3, 1, 2]) == []\nassert op_trimends_clamp10_neg([10]) == []\nassert op_trimends_clamp10_neg([2, 4, 6]) == []\nassert op_trimends_clamp10_neg([-7, 12, -7]) == []"}
{"id": "op_firstchar_dropshort_strip", "entry_point": "op_firstchar_dropshort_strip", "primitives": ["firstchar", "dropshort", "strip"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then drop strings shorter than three characters, then trim whitespace from each.", "solution": "def op_firstchar_dropshort_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_dropshort_strip(['Hello', 'world']) == []\nassert op_firstchar_dropshort_strip([]) == []\nassert op_firstchar_dropshort_strip(['  a ', '', 'BC', 'bc']) == []\nassert op_firstchar_dropshort_strip(['one', 'one', 'Two']) == []\nassert op_firstchar_dropshort_strip(['x']) == []\nassert op_firstchar_dropshort_strip(['abc', 'de', '']) == []"}
{"id": "op_evens_first3_absval", "entry_point": "op_evens_first3_absval", "primitives": ["evens", "first3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three, then take the absolute value of each.", "solution": "def op_evens_first3_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_evens_first3_absval([1, 2, 3, 4]) == [2, 4]\nassert op_evens_first3_absval([]) == []\nassert op_evens_first3_absval([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_evens_first3_absval([5, 5, 5]) == []\nassert op_evens_first3_absval([3, 1, 2]) == [2]\nassert op_evens_first3_absval([10]) == [10]\nassert op_evens_first3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_evens_first3_absval([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_padto3_absval", "entry_point": "op_clamp10_padto3_absval", "primitives": ["clamp10", "padto3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_clamp10_padto3_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_padto3_absval([]) == [0, 0, 0]\nassert op_clamp10_padto3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3_absval([10]) == [10, 0, 0]\nassert op_clamp10_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3_absval([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_evens_padto3_prod", "entry_point": "op_evens_padto3_prod", "primitives": ["evens", "padto3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements, then return their product.", "solution": "def op_evens_padto3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_evens_padto3_prod([1, 2, 3, 4]) == 0\nassert op_evens_padto3_prod([]) == 0\nassert op_evens_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_padto3_prod([5, 5, 5]) == 0\nassert op_evens_padto3_prod([3, 1, 2]) == 0\nassert op_evens_padto3_prod([10]) == 0\nassert op_evens_padto3_prod([2, 4, 6]) == 48\nassert op_evens_padto3_prod([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_first3_counteven", "entry_point": "op_dropfirst_first3_counteven", "primitives": ["dropfirst", "first3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then return how many values are even.", "solution": "def op_dropfirst_first3_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_first3_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_first3_counteven([]) == 0\nassert op_dropfirst_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_dropfirst_first3_counteven([5, 5, 5]) == 0\nassert op_dropfirst_first3_counteven([3, 1, 2]) == 1\nassert op_dropfirst_first3_counteven([10]) == 0\nassert op_dropfirst_first3_counteven([2, 4, 6]) == 2\nassert op_dropfirst_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_last3_trimends_evens", "entry_point": "op_last3_trimends_evens", "primitives": ["last3", "trimends", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then keep the even numbers.", "solution": "def op_last3_trimends_evens(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_last3_trimends_evens([1, 2, 3, 4]) == []\nassert op_last3_trimends_evens([]) == []\nassert op_last3_trimends_evens([-2, -1, 0, 1, 2]) == []\nassert op_last3_trimends_evens([5, 5, 5]) == []\nassert op_last3_trimends_evens([3, 1, 2]) == []\nassert op_last3_trimends_evens([10]) == []\nassert op_last3_trimends_evens([2, 4, 6]) == [4]\nassert op_last3_trimends_evens([-7, 12, -7]) == [12]"}
{"id": "op_div3_sortd_negate", "entry_point": "op_div3_sortd_negate", "primitives": ["div3", "sortd", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort descending, then negate each.", "solution": "def op_div3_sortd_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r", "tests": "assert op_div3_sortd_negate([1, 2, 3, 4]) == [-3]\nassert op_div3_sortd_negate([]) == []\nassert op_div3_sortd_negate([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_sortd_negate([5, 5, 5]) == []\nassert op_div3_sortd_negate([3, 1, 2]) == [-3]\nassert op_div3_sortd_negate([10]) == []\nassert op_div3_sortd_negate([2, 4, 6]) == [-6]\nassert op_div3_sortd_negate([-7, 12, -7]) == [-12]"}
{"id": "op_gt5_padto3_negate", "entry_point": "op_gt5_padto3_negate", "primitives": ["gt5", "padto3", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then negate each.", "solution": "def op_gt5_padto3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_padto3_negate([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_padto3_negate([]) == [0, 0, 0]\nassert op_gt5_padto3_negate([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_negate([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_padto3_negate([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_negate([10]) == [-10, 0, 0]\nassert op_gt5_padto3_negate([2, 4, 6]) == [-6, 0, 0]\nassert op_gt5_padto3_negate([-7, 12, -7]) == [-12, 0, 0]"}
{"id": "op_square_evens_anyeven", "entry_point": "op_square_evens_anyeven", "primitives": ["square", "evens", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then return whether any value is even.", "solution": "def op_square_evens_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_evens_anyeven([1, 2, 3, 4]) == True\nassert op_square_evens_anyeven([]) == False\nassert op_square_evens_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_evens_anyeven([5, 5, 5]) == False\nassert op_square_evens_anyeven([3, 1, 2]) == True\nassert op_square_evens_anyeven([10]) == True\nassert op_square_evens_anyeven([2, 4, 6]) == True\nassert op_square_evens_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_square_len", "entry_point": "op_negate_square_len", "primitives": ["negate", "square", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then return how many remain.", "solution": "def op_negate_square_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_negate_square_len([1, 2, 3, 4]) == 4\nassert op_negate_square_len([]) == 0\nassert op_negate_square_len([-2, -1, 0, 1, 2]) == 5\nassert op_negate_square_len([5, 5, 5]) == 3\nassert op_negate_square_len([3, 1, 2]) == 3\nassert op_negate_square_len([10]) == 1\nassert op_negate_square_len([2, 4, 6]) == 3\nassert op_negate_square_len([-7, 12, -7]) == 3"}
{"id": "op_add10_padto3_prod", "entry_point": "op_add10_padto3_prod", "primitives": ["add10", "padto3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then pad with zeros to at least three elements, then return their product.", "solution": "def op_add10_padto3_prod(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_add10_padto3_prod([1, 2, 3, 4]) == 24024\nassert op_add10_padto3_prod([]) == 0\nassert op_add10_padto3_prod([-2, -1, 0, 1, 2]) == 95040\nassert op_add10_padto3_prod([5, 5, 5]) == 3375\nassert op_add10_padto3_prod([3, 1, 2]) == 1716\nassert op_add10_padto3_prod([10]) == 0\nassert op_add10_padto3_prod([2, 4, 6]) == 2688\nassert op_add10_padto3_prod([-7, 12, -7]) == 198"}
{"id": "op_first3_neg_anyeven", "entry_point": "op_first3_neg_anyeven", "primitives": ["first3", "neg", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers, then return whether any value is even.", "solution": "def op_first3_neg_anyeven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_first3_neg_anyeven([1, 2, 3, 4]) == False\nassert op_first3_neg_anyeven([]) == False\nassert op_first3_neg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_first3_neg_anyeven([5, 5, 5]) == False\nassert op_first3_neg_anyeven([3, 1, 2]) == False\nassert op_first3_neg_anyeven([10]) == False\nassert op_first3_neg_anyeven([2, 4, 6]) == False\nassert op_first3_neg_anyeven([-7, 12, -7]) == False"}
{"id": "op_double_dropfirst_sortabs", "entry_point": "op_double_dropfirst_sortabs", "primitives": ["double", "dropfirst", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then sort by absolute value.", "solution": "def op_double_dropfirst_sortabs(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_double_dropfirst_sortabs([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst_sortabs([]) == []\nassert op_double_dropfirst_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2, 4]\nassert op_double_dropfirst_sortabs([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst_sortabs([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst_sortabs([10]) == []\nassert op_double_dropfirst_sortabs([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst_sortabs([-7, 12, -7]) == [-14, 24]"}
{"id": "op_sortd_gt5_sorta", "entry_point": "op_sortd_gt5_sorta", "primitives": ["sortd", "gt5", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five, then sort ascending.", "solution": "def op_sortd_gt5_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_gt5_sorta([1, 2, 3, 4]) == []\nassert op_sortd_gt5_sorta([]) == []\nassert op_sortd_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_sortd_gt5_sorta([5, 5, 5]) == []\nassert op_sortd_gt5_sorta([3, 1, 2]) == []\nassert op_sortd_gt5_sorta([10]) == [10]\nassert op_sortd_gt5_sorta([2, 4, 6]) == [6]\nassert op_sortd_gt5_sorta([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_dropfirst_div3", "entry_point": "op_takewhilepos_dropfirst_div3", "primitives": ["takewhilepos", "dropfirst", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element, then keep multiples of three.", "solution": "def op_takewhilepos_dropfirst_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_dropfirst_div3([]) == []\nassert op_takewhilepos_dropfirst_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropfirst_div3([5, 5, 5]) == []\nassert op_takewhilepos_dropfirst_div3([3, 1, 2]) == []\nassert op_takewhilepos_dropfirst_div3([10]) == []\nassert op_takewhilepos_dropfirst_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_dropfirst_div3([-7, 12, -7]) == []"}
{"id": "op_sortabs_dec_padto3", "entry_point": "op_sortabs_dec_padto3", "primitives": ["sortabs", "dec", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_sortabs_dec_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_dec_padto3([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortabs_dec_padto3([]) == [0, 0, 0]\nassert op_sortabs_dec_padto3([-2, -1, 0, 1, 2]) == [-1, -2, 0, -3, 1]\nassert op_sortabs_dec_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_dec_padto3([3, 1, 2]) == [0, 1, 2]\nassert op_sortabs_dec_padto3([10]) == [9, 0, 0]\nassert op_sortabs_dec_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_sortabs_dec_padto3([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_dropfirst_clamp10_sortd", "entry_point": "op_dropfirst_clamp10_sortd", "primitives": ["dropfirst", "clamp10", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then sort descending.", "solution": "def op_dropfirst_clamp10_sortd(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropfirst_clamp10_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_clamp10_sortd([]) == []\nassert op_dropfirst_clamp10_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_clamp10_sortd([5, 5, 5]) == [5, 5]\nassert op_dropfirst_clamp10_sortd([3, 1, 2]) == [2, 1]\nassert op_dropfirst_clamp10_sortd([10]) == []\nassert op_dropfirst_clamp10_sortd([2, 4, 6]) == [6, 4]\nassert op_dropfirst_clamp10_sortd([-7, 12, -7]) == [10, -7]"}
{"id": "op_sortlen_strip_longest", "entry_point": "op_sortlen_strip_longest", "primitives": ["sortlen", "strip", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then trim whitespace from each, then return the longest string (empty if none).", "solution": "def op_sortlen_strip_longest(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_sortlen_strip_longest(['Hello', 'world']) == 'Hello'\nassert op_sortlen_strip_longest([]) == ''\nassert op_sortlen_strip_longest(['  a ', '', 'BC', 'bc']) == 'BC'\nassert op_sortlen_strip_longest(['one', 'one', 'Two']) == 'one'\nassert op_sortlen_strip_longest(['x']) == 'x'\nassert op_sortlen_strip_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_absval_padto3_sortabs", "entry_point": "op_absval_padto3_sortabs", "primitives": ["absval", "padto3", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_absval_padto3_sortabs(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_absval_padto3_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_padto3_sortabs([]) == [0, 0, 0]\nassert op_absval_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_absval_padto3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_absval_padto3_sortabs([10]) == [0, 0, 10]\nassert op_absval_padto3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_absval_padto3_sortabs([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_dropfirst_dropwhileneg_sum", "entry_point": "op_dropfirst_dropwhileneg_sum", "primitives": ["dropfirst", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then return their sum.", "solution": "def op_dropfirst_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_dropfirst_dropwhileneg_sum([1, 2, 3, 4]) == 9\nassert op_dropfirst_dropwhileneg_sum([]) == 0\nassert op_dropfirst_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 3\nassert op_dropfirst_dropwhileneg_sum([5, 5, 5]) == 10\nassert op_dropfirst_dropwhileneg_sum([3, 1, 2]) == 3\nassert op_dropfirst_dropwhileneg_sum([10]) == 0\nassert op_dropfirst_dropwhileneg_sum([2, 4, 6]) == 10\nassert op_dropfirst_dropwhileneg_sum([-7, 12, -7]) == 5"}
{"id": "op_last3_negate_add10", "entry_point": "op_last3_negate_add10", "primitives": ["last3", "negate", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then add ten to each.", "solution": "def op_last3_negate_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_negate_add10([1, 2, 3, 4]) == [8, 7, 6]\nassert op_last3_negate_add10([]) == []\nassert op_last3_negate_add10([-2, -1, 0, 1, 2]) == [10, 9, 8]\nassert op_last3_negate_add10([5, 5, 5]) == [5, 5, 5]\nassert op_last3_negate_add10([3, 1, 2]) == [7, 9, 8]\nassert op_last3_negate_add10([10]) == [0]\nassert op_last3_negate_add10([2, 4, 6]) == [8, 6, 4]\nassert op_last3_negate_add10([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_ages_sortabs_evens", "entry_point": "op_ages_sortabs_evens", "primitives": ["ages", "sortabs", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort by absolute value, then keep the even numbers.", "solution": "def op_ages_sortabs_evens(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_ages_sortabs_evens([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_sortabs_evens([]) == []\nassert op_ages_sortabs_evens([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_sortabs_evens([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_inc_neg_square", "entry_point": "op_inc_neg_square", "primitives": ["inc", "neg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then square each.", "solution": "def op_inc_neg_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_neg_square([1, 2, 3, 4]) == []\nassert op_inc_neg_square([]) == []\nassert op_inc_neg_square([-2, -1, 0, 1, 2]) == [1]\nassert op_inc_neg_square([5, 5, 5]) == []\nassert op_inc_neg_square([3, 1, 2]) == []\nassert op_inc_neg_square([10]) == []\nassert op_inc_neg_square([2, 4, 6]) == []\nassert op_inc_neg_square([-7, 12, -7]) == [36, 36]"}
{"id": "op_lower_firstchar_maxlen", "entry_point": "op_lower_firstchar_maxlen", "primitives": ["lower", "firstchar", "maxlen"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then keep the first character of each (dropping empties), then return the length of the longest string (0 if none).", "solution": "def op_lower_firstchar_maxlen(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[0] for s in r if s]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_lower_firstchar_maxlen(['Hello', 'world']) == 1\nassert op_lower_firstchar_maxlen([]) == 0\nassert op_lower_firstchar_maxlen(['  a ', '', 'BC', 'bc']) == 1\nassert op_lower_firstchar_maxlen(['one', 'one', 'Two']) == 1\nassert op_lower_firstchar_maxlen(['x']) == 1\nassert op_lower_firstchar_maxlen(['abc', 'de', '']) == 1"}
{"id": "op_first3_rev_gt5", "entry_point": "op_first3_rev_gt5", "primitives": ["first3", "rev", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then keep values greater than five.", "solution": "def op_first3_rev_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_rev_gt5([1, 2, 3, 4]) == []\nassert op_first3_rev_gt5([]) == []\nassert op_first3_rev_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_rev_gt5([5, 5, 5]) == []\nassert op_first3_rev_gt5([3, 1, 2]) == []\nassert op_first3_rev_gt5([10]) == [10]\nassert op_first3_rev_gt5([2, 4, 6]) == [6]\nassert op_first3_rev_gt5([-7, 12, -7]) == [12]"}
{"id": "op_absval_double_beforezero", "entry_point": "op_absval_double_beforezero", "primitives": ["absval", "double", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then double each, then keep everything before the first zero.", "solution": "def op_absval_double_beforezero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_absval_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_absval_double_beforezero([]) == []\nassert op_absval_double_beforezero([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_absval_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_absval_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_absval_double_beforezero([10]) == [20]\nassert op_absval_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_absval_double_beforezero([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_sortabs_first3_counteven", "entry_point": "op_sortabs_first3_counteven", "primitives": ["sortabs", "first3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then return how many values are even.", "solution": "def op_sortabs_first3_counteven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortabs_first3_counteven([1, 2, 3, 4]) == 1\nassert op_sortabs_first3_counteven([]) == 0\nassert op_sortabs_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_sortabs_first3_counteven([5, 5, 5]) == 0\nassert op_sortabs_first3_counteven([3, 1, 2]) == 1\nassert op_sortabs_first3_counteven([10]) == 1\nassert op_sortabs_first3_counteven([2, 4, 6]) == 3\nassert op_sortabs_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_dropzeros_alldistinct", "entry_point": "op_sortd_dropzeros_alldistinct", "primitives": ["sortd", "dropzeros", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then return whether all values are distinct.", "solution": "def op_sortd_dropzeros_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_dropzeros_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_dropzeros_alldistinct([]) == True\nassert op_sortd_dropzeros_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_dropzeros_alldistinct([5, 5, 5]) == False\nassert op_sortd_dropzeros_alldistinct([3, 1, 2]) == True\nassert op_sortd_dropzeros_alldistinct([10]) == True\nassert op_sortd_dropzeros_alldistinct([2, 4, 6]) == True\nassert op_sortd_dropzeros_alldistinct([-7, 12, -7]) == False"}
{"id": "op_evens_last3_neg", "entry_point": "op_evens_last3_neg", "primitives": ["evens", "last3", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then keep the negative numbers.", "solution": "def op_evens_last3_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_last3_neg([1, 2, 3, 4]) == []\nassert op_evens_last3_neg([]) == []\nassert op_evens_last3_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_evens_last3_neg([5, 5, 5]) == []\nassert op_evens_last3_neg([3, 1, 2]) == []\nassert op_evens_last3_neg([10]) == []\nassert op_evens_last3_neg([2, 4, 6]) == []\nassert op_evens_last3_neg([-7, 12, -7]) == []"}
{"id": "op_padto3_evens_neg", "entry_point": "op_padto3_evens_neg", "primitives": ["padto3", "evens", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then keep the negative numbers.", "solution": "def op_padto3_evens_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_evens_neg([1, 2, 3, 4]) == []\nassert op_padto3_evens_neg([]) == []\nassert op_padto3_evens_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_padto3_evens_neg([5, 5, 5]) == []\nassert op_padto3_evens_neg([3, 1, 2]) == []\nassert op_padto3_evens_neg([10]) == []\nassert op_padto3_evens_neg([2, 4, 6]) == []\nassert op_padto3_evens_neg([-7, 12, -7]) == []"}
{"id": "op_evens_dropwhileneg_oremptyzero", "entry_point": "op_evens_dropwhileneg_oremptyzero", "primitives": ["evens", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_evens_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_dropwhileneg_oremptyzero([]) == [0]\nassert op_evens_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropwhileneg_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_dropwhileneg_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_dropwhileneg_oremptyzero([10]) == [10]\nassert op_evens_dropwhileneg_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_dropwhileneg_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_last3_takewhilepos_div3", "entry_point": "op_last3_takewhilepos_div3", "primitives": ["last3", "takewhilepos", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then keep multiples of three.", "solution": "def op_last3_takewhilepos_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_takewhilepos_div3([1, 2, 3, 4]) == [3]\nassert op_last3_takewhilepos_div3([]) == []\nassert op_last3_takewhilepos_div3([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos_div3([5, 5, 5]) == []\nassert op_last3_takewhilepos_div3([3, 1, 2]) == [3]\nassert op_last3_takewhilepos_div3([10]) == []\nassert op_last3_takewhilepos_div3([2, 4, 6]) == [6]\nassert op_last3_takewhilepos_div3([-7, 12, -7]) == []"}
{"id": "op_sorta_inc_sortd", "entry_point": "op_sorta_inc_sortd", "primitives": ["sorta", "inc", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then sort descending.", "solution": "def op_sorta_inc_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_inc_sortd([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sorta_inc_sortd([]) == []\nassert op_sorta_inc_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sorta_inc_sortd([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_sortd([3, 1, 2]) == [4, 3, 2]\nassert op_sorta_inc_sortd([10]) == [11]\nassert op_sorta_inc_sortd([2, 4, 6]) == [7, 5, 3]\nassert op_sorta_inc_sortd([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_div3_beforezero_max", "entry_point": "op_div3_beforezero_max", "primitives": ["div3", "beforezero", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_div3_beforezero_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_div3_beforezero_max([1, 2, 3, 4]) == 3\nassert op_div3_beforezero_max([]) == 0\nassert op_div3_beforezero_max([-2, -1, 0, 1, 2]) == 0\nassert op_div3_beforezero_max([5, 5, 5]) == 0\nassert op_div3_beforezero_max([3, 1, 2]) == 3\nassert op_div3_beforezero_max([10]) == 0\nassert op_div3_beforezero_max([2, 4, 6]) == 6\nassert op_div3_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_trimends_absval_firsteven", "entry_point": "op_trimends_absval_firsteven", "primitives": ["trimends", "absval", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_trimends_absval_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_absval_firsteven([1, 2, 3, 4]) == 2\nassert op_trimends_absval_firsteven([]) == 0\nassert op_trimends_absval_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_absval_firsteven([5, 5, 5]) == 0\nassert op_trimends_absval_firsteven([3, 1, 2]) == 0\nassert op_trimends_absval_firsteven([10]) == 0\nassert op_trimends_absval_firsteven([2, 4, 6]) == 4\nassert op_trimends_absval_firsteven([-7, 12, -7]) == 12"}
{"id": "op_add10_inc_issorted", "entry_point": "op_add10_inc_issorted", "primitives": ["add10", "inc", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then add one to each, then return whether the list is sorted ascending.", "solution": "def op_add10_inc_issorted(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_add10_inc_issorted([1, 2, 3, 4]) == True\nassert op_add10_inc_issorted([]) == True\nassert op_add10_inc_issorted([-2, -1, 0, 1, 2]) == True\nassert op_add10_inc_issorted([5, 5, 5]) == True\nassert op_add10_inc_issorted([3, 1, 2]) == False\nassert op_add10_inc_issorted([10]) == True\nassert op_add10_inc_issorted([2, 4, 6]) == True\nassert op_add10_inc_issorted([-7, 12, -7]) == False"}
{"id": "op_odds_sortabs_negate", "entry_point": "op_odds_sortabs_negate", "primitives": ["odds", "sortabs", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then negate each.", "solution": "def op_odds_sortabs_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_sortabs_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_sortabs_negate([]) == []\nassert op_odds_sortabs_negate([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_sortabs_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_sortabs_negate([3, 1, 2]) == [-1, -3]\nassert op_odds_sortabs_negate([10]) == []\nassert op_odds_sortabs_negate([2, 4, 6]) == []\nassert op_odds_sortabs_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_beforezero_inc_pos", "entry_point": "op_beforezero_inc_pos", "primitives": ["beforezero", "inc", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then keep the positive numbers.", "solution": "def op_beforezero_inc_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_inc_pos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_beforezero_inc_pos([]) == []\nassert op_beforezero_inc_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_inc_pos([5, 5, 5]) == [6, 6, 6]\nassert op_beforezero_inc_pos([3, 1, 2]) == [4, 2, 3]\nassert op_beforezero_inc_pos([10]) == [11]\nassert op_beforezero_inc_pos([2, 4, 6]) == [3, 5, 7]\nassert op_beforezero_inc_pos([-7, 12, -7]) == [13]"}
{"id": "op_oremptyzero_odds_haszero", "entry_point": "op_oremptyzero_odds_haszero", "primitives": ["oremptyzero", "odds", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then return whether the list contains a zero.", "solution": "def op_oremptyzero_odds_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return 0 in r", "tests": "assert op_oremptyzero_odds_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_odds_haszero([]) == False\nassert op_oremptyzero_odds_haszero([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_odds_haszero([5, 5, 5]) == False\nassert op_oremptyzero_odds_haszero([3, 1, 2]) == False\nassert op_oremptyzero_odds_haszero([10]) == False\nassert op_oremptyzero_odds_haszero([2, 4, 6]) == False\nassert op_oremptyzero_odds_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_gt5_first3", "entry_point": "op_clamp10_gt5_first3", "primitives": ["clamp10", "gt5", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five, then keep only the first three.", "solution": "def op_clamp10_gt5_first3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_clamp10_gt5_first3([1, 2, 3, 4]) == []\nassert op_clamp10_gt5_first3([]) == []\nassert op_clamp10_gt5_first3([-2, -1, 0, 1, 2]) == []\nassert op_clamp10_gt5_first3([5, 5, 5]) == []\nassert op_clamp10_gt5_first3([3, 1, 2]) == []\nassert op_clamp10_gt5_first3([10]) == [10]\nassert op_clamp10_gt5_first3([2, 4, 6]) == [6]\nassert op_clamp10_gt5_first3([-7, 12, -7]) == [10]"}
{"id": "op_odds_gt5_dropzeros", "entry_point": "op_odds_gt5_dropzeros", "primitives": ["odds", "gt5", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep values greater than five, then drop the zeros.", "solution": "def op_odds_gt5_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_odds_gt5_dropzeros([]) == []\nassert op_odds_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_odds_gt5_dropzeros([5, 5, 5]) == []\nassert op_odds_gt5_dropzeros([3, 1, 2]) == []\nassert op_odds_gt5_dropzeros([10]) == []\nassert op_odds_gt5_dropzeros([2, 4, 6]) == []\nassert op_odds_gt5_dropzeros([-7, 12, -7]) == []"}
{"id": "op_ages_pos_absval", "entry_point": "op_ages_pos_absval", "primitives": ["ages", "pos", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the positive numbers, then take the absolute value of each.", "solution": "def op_ages_pos_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x > 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_pos_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_pos_absval([]) == []\nassert op_ages_pos_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_pos_absval([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_uniq_dropfirst_prod", "entry_point": "op_uniq_dropfirst_prod", "primitives": ["uniq", "dropfirst", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then return their product.", "solution": "def op_uniq_dropfirst_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return __import__('math').prod(r)", "tests": "assert op_uniq_dropfirst_prod([1, 2, 3, 4]) == 24\nassert op_uniq_dropfirst_prod([]) == 1\nassert op_uniq_dropfirst_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_dropfirst_prod([5, 5, 5]) == 1\nassert op_uniq_dropfirst_prod([3, 1, 2]) == 2\nassert op_uniq_dropfirst_prod([10]) == 1\nassert op_uniq_dropfirst_prod([2, 4, 6]) == 24\nassert op_uniq_dropfirst_prod([-7, 12, -7]) == 12"}
{"id": "op_negate_trimends_div3", "entry_point": "op_negate_trimends_div3", "primitives": ["negate", "trimends", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first and last elements, then keep multiples of three.", "solution": "def op_negate_trimends_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_trimends_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_trimends_div3([]) == []\nassert op_negate_trimends_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_trimends_div3([5, 5, 5]) == []\nassert op_negate_trimends_div3([3, 1, 2]) == []\nassert op_negate_trimends_div3([10]) == []\nassert op_negate_trimends_div3([2, 4, 6]) == []\nassert op_negate_trimends_div3([-7, 12, -7]) == [-12]"}
{"id": "op_sorta_dropwhileneg_beforezero", "entry_point": "op_sorta_dropwhileneg_beforezero", "primitives": ["sorta", "dropwhileneg", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then keep everything before the first zero.", "solution": "def op_sorta_dropwhileneg_beforezero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sorta_dropwhileneg_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_dropwhileneg_beforezero([]) == []\nassert op_sorta_dropwhileneg_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_sorta_dropwhileneg_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropwhileneg_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropwhileneg_beforezero([10]) == [10]\nassert op_sorta_dropwhileneg_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropwhileneg_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_dec_allpos", "entry_point": "op_dropfirst_dec_allpos", "primitives": ["dropfirst", "dec", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then return whether all values are positive.", "solution": "def op_dropfirst_dec_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_dec_allpos([1, 2, 3, 4]) == True\nassert op_dropfirst_dec_allpos([]) == True\nassert op_dropfirst_dec_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_dec_allpos([5, 5, 5]) == True\nassert op_dropfirst_dec_allpos([3, 1, 2]) == False\nassert op_dropfirst_dec_allpos([10]) == True\nassert op_dropfirst_dec_allpos([2, 4, 6]) == True\nassert op_dropfirst_dec_allpos([-7, 12, -7]) == False"}
{"id": "op_add10_first3_trimends", "entry_point": "op_add10_first3_trimends", "primitives": ["add10", "first3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then drop the first and last elements.", "solution": "def op_add10_first3_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_first3_trimends([1, 2, 3, 4]) == [12]\nassert op_add10_first3_trimends([]) == []\nassert op_add10_first3_trimends([-2, -1, 0, 1, 2]) == [9]\nassert op_add10_first3_trimends([5, 5, 5]) == [15]\nassert op_add10_first3_trimends([3, 1, 2]) == [11]\nassert op_add10_first3_trimends([10]) == []\nassert op_add10_first3_trimends([2, 4, 6]) == [14]\nassert op_add10_first3_trimends([-7, 12, -7]) == [22]"}
{"id": "op_double_beforezero_counteven", "entry_point": "op_double_beforezero_counteven", "primitives": ["double", "beforezero", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero, then return how many values are even.", "solution": "def op_double_beforezero_counteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_double_beforezero_counteven([1, 2, 3, 4]) == 4\nassert op_double_beforezero_counteven([]) == 0\nassert op_double_beforezero_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_double_beforezero_counteven([5, 5, 5]) == 3\nassert op_double_beforezero_counteven([3, 1, 2]) == 3\nassert op_double_beforezero_counteven([10]) == 1\nassert op_double_beforezero_counteven([2, 4, 6]) == 3\nassert op_double_beforezero_counteven([-7, 12, -7]) == 3"}
{"id": "op_gt5_uniq_haszero", "entry_point": "op_gt5_uniq_haszero", "primitives": ["gt5", "uniq", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop duplicates keeping first occurrence, then return whether the list contains a zero.", "solution": "def op_gt5_uniq_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return 0 in r", "tests": "assert op_gt5_uniq_haszero([1, 2, 3, 4]) == False\nassert op_gt5_uniq_haszero([]) == False\nassert op_gt5_uniq_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_uniq_haszero([5, 5, 5]) == False\nassert op_gt5_uniq_haszero([3, 1, 2]) == False\nassert op_gt5_uniq_haszero([10]) == False\nassert op_gt5_uniq_haszero([2, 4, 6]) == False\nassert op_gt5_uniq_haszero([-7, 12, -7]) == False"}
{"id": "op_sortabs_first3_sortd", "entry_point": "op_sortabs_first3_sortd", "primitives": ["sortabs", "first3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then sort descending.", "solution": "def op_sortabs_first3_sortd(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sortabs_first3_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortabs_first3_sortd([]) == []\nassert op_sortabs_first3_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortabs_first3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_first3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_first3_sortd([10]) == [10]\nassert op_sortabs_first3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_first3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_negate_trimends_firsteven", "entry_point": "op_negate_trimends_firsteven", "primitives": ["negate", "trimends", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_negate_trimends_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_trimends_firsteven([1, 2, 3, 4]) == -2\nassert op_negate_trimends_firsteven([]) == 0\nassert op_negate_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_negate_trimends_firsteven([5, 5, 5]) == 0\nassert op_negate_trimends_firsteven([3, 1, 2]) == 0\nassert op_negate_trimends_firsteven([10]) == 0\nassert op_negate_trimends_firsteven([2, 4, 6]) == -4\nassert op_negate_trimends_firsteven([-7, 12, -7]) == -12"}
{"id": "op_absval_add10_div3", "entry_point": "op_absval_add10_div3", "primitives": ["absval", "add10", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then keep multiples of three.", "solution": "def op_absval_add10_div3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_absval_add10_div3([1, 2, 3, 4]) == [12]\nassert op_absval_add10_div3([]) == []\nassert op_absval_add10_div3([-2, -1, 0, 1, 2]) == [12, 12]\nassert op_absval_add10_div3([5, 5, 5]) == [15, 15, 15]\nassert op_absval_add10_div3([3, 1, 2]) == [12]\nassert op_absval_add10_div3([10]) == []\nassert op_absval_add10_div3([2, 4, 6]) == [12]\nassert op_absval_add10_div3([-7, 12, -7]) == []"}
{"id": "op_add10_clamp10_dropzeros", "entry_point": "op_add10_clamp10_dropzeros", "primitives": ["add10", "clamp10", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then cap each value at 10, then drop the zeros.", "solution": "def op_add10_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_add10_clamp10_dropzeros([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_add10_clamp10_dropzeros([]) == []\nassert op_add10_clamp10_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10, 10, 10]\nassert op_add10_clamp10_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_add10_clamp10_dropzeros([3, 1, 2]) == [10, 10, 10]\nassert op_add10_clamp10_dropzeros([10]) == [10]\nassert op_add10_clamp10_dropzeros([2, 4, 6]) == [10, 10, 10]\nassert op_add10_clamp10_dropzeros([-7, 12, -7]) == [3, 10, 3]"}
{"id": "op_trimends_square_firsteven", "entry_point": "op_trimends_square_firsteven", "primitives": ["trimends", "square", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then return the first even value (0 if none).", "solution": "def op_trimends_square_firsteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_trimends_square_firsteven([1, 2, 3, 4]) == 4\nassert op_trimends_square_firsteven([]) == 0\nassert op_trimends_square_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_square_firsteven([5, 5, 5]) == 0\nassert op_trimends_square_firsteven([3, 1, 2]) == 0\nassert op_trimends_square_firsteven([10]) == 0\nassert op_trimends_square_firsteven([2, 4, 6]) == 16\nassert op_trimends_square_firsteven([-7, 12, -7]) == 144"}
{"id": "op_dropshort_prefixup_lower", "entry_point": "op_dropshort_prefixup_lower", "primitives": ["dropshort", "prefixup", "lower"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then prefix each with a hash, then lowercase each string.", "solution": "def op_dropshort_prefixup_lower(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_dropshort_prefixup_lower(['Hello', 'world']) == ['#hello', '#world']\nassert op_dropshort_prefixup_lower([]) == []\nassert op_dropshort_prefixup_lower(['  a ', '', 'BC', 'bc']) == ['#  a ']\nassert op_dropshort_prefixup_lower(['one', 'one', 'Two']) == ['#one', '#one', '#two']\nassert op_dropshort_prefixup_lower(['x']) == []\nassert op_dropshort_prefixup_lower(['abc', 'de', '']) == ['#abc']"}
{"id": "op_evens_dropfirst_dropwhileneg", "entry_point": "op_evens_dropfirst_dropwhileneg", "primitives": ["evens", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first element, then drop the leading negative values.", "solution": "def op_evens_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_evens_dropfirst_dropwhileneg([1, 2, 3, 4]) == [4]\nassert op_evens_dropfirst_dropwhileneg([]) == []\nassert op_evens_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropfirst_dropwhileneg([5, 5, 5]) == []\nassert op_evens_dropfirst_dropwhileneg([3, 1, 2]) == []\nassert op_evens_dropfirst_dropwhileneg([10]) == []\nassert op_evens_dropfirst_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_evens_dropfirst_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_add10_sortabs_evens", "entry_point": "op_add10_sortabs_evens", "primitives": ["add10", "sortabs", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then keep the even numbers.", "solution": "def op_add10_sortabs_evens(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_add10_sortabs_evens([1, 2, 3, 4]) == [12, 14]\nassert op_add10_sortabs_evens([]) == []\nassert op_add10_sortabs_evens([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_sortabs_evens([5, 5, 5]) == []\nassert op_add10_sortabs_evens([3, 1, 2]) == [12]\nassert op_add10_sortabs_evens([10]) == [20]\nassert op_add10_sortabs_evens([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sortabs_evens([-7, 12, -7]) == [22]"}
{"id": "op_oremptyzero_takewhilepos_dropzeros", "entry_point": "op_oremptyzero_takewhilepos_dropzeros", "primitives": ["oremptyzero", "takewhilepos", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then take values while they are positive, then drop the zeros.", "solution": "def op_oremptyzero_takewhilepos_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_takewhilepos_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_takewhilepos_dropzeros([]) == []\nassert op_oremptyzero_takewhilepos_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_takewhilepos_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_takewhilepos_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_takewhilepos_dropzeros([10]) == [10]\nassert op_oremptyzero_takewhilepos_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_takewhilepos_dropzeros([-7, 12, -7]) == []"}
{"id": "op_sortabs_dec_gt5", "entry_point": "op_sortabs_dec_gt5", "primitives": ["sortabs", "dec", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then keep values greater than five.", "solution": "def op_sortabs_dec_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_dec_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_dec_gt5([]) == []\nassert op_sortabs_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_dec_gt5([5, 5, 5]) == []\nassert op_sortabs_dec_gt5([3, 1, 2]) == []\nassert op_sortabs_dec_gt5([10]) == [9]\nassert op_sortabs_dec_gt5([2, 4, 6]) == []\nassert op_sortabs_dec_gt5([-7, 12, -7]) == [11]"}
{"id": "op_double_oremptyzero_firsteven", "entry_point": "op_double_oremptyzero_firsteven", "primitives": ["double", "oremptyzero", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then return the first even value (0 if none).", "solution": "def op_double_oremptyzero_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_oremptyzero_firsteven([1, 2, 3, 4]) == 2\nassert op_double_oremptyzero_firsteven([]) == 0\nassert op_double_oremptyzero_firsteven([-2, -1, 0, 1, 2]) == -4\nassert op_double_oremptyzero_firsteven([5, 5, 5]) == 10\nassert op_double_oremptyzero_firsteven([3, 1, 2]) == 6\nassert op_double_oremptyzero_firsteven([10]) == 20\nassert op_double_oremptyzero_firsteven([2, 4, 6]) == 4\nassert op_double_oremptyzero_firsteven([-7, 12, -7]) == -14"}
{"id": "op_sortlen_uniqs_upper", "entry_point": "op_sortlen_uniqs_upper", "primitives": ["sortlen", "uniqs", "upper"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop duplicate strings keeping the first, then uppercase each string.", "solution": "def op_sortlen_uniqs_upper(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = list(dict.fromkeys(r))\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_sortlen_uniqs_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortlen_uniqs_upper([]) == []\nassert op_sortlen_uniqs_upper(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'BC', '  A ']\nassert op_sortlen_uniqs_upper(['one', 'one', 'Two']) == ['ONE', 'TWO']\nassert op_sortlen_uniqs_upper(['x']) == ['X']\nassert op_sortlen_uniqs_upper(['abc', 'de', '']) == ['', 'DE', 'ABC']"}
{"id": "op_last3_absval_min", "entry_point": "op_last3_absval_min", "primitives": ["last3", "absval", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then return the minimum (0 if empty).", "solution": "def op_last3_absval_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return min(r) if r else 0", "tests": "assert op_last3_absval_min([1, 2, 3, 4]) == 2\nassert op_last3_absval_min([]) == 0\nassert op_last3_absval_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_absval_min([5, 5, 5]) == 5\nassert op_last3_absval_min([3, 1, 2]) == 1\nassert op_last3_absval_min([10]) == 10\nassert op_last3_absval_min([2, 4, 6]) == 2\nassert op_last3_absval_min([-7, 12, -7]) == 7"}
{"id": "op_absval_padto3_rev", "entry_point": "op_absval_padto3_rev", "primitives": ["absval", "padto3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_absval_padto3_rev(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_absval_padto3_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_padto3_rev([]) == [0, 0, 0]\nassert op_absval_padto3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_absval_padto3_rev([5, 5, 5]) == [5, 5, 5]\nassert op_absval_padto3_rev([3, 1, 2]) == [2, 1, 3]\nassert op_absval_padto3_rev([10]) == [0, 0, 10]\nassert op_absval_padto3_rev([2, 4, 6]) == [6, 4, 2]\nassert op_absval_padto3_rev([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_gt5_absval_max", "entry_point": "op_gt5_absval_max", "primitives": ["gt5", "absval", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_gt5_absval_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_gt5_absval_max([1, 2, 3, 4]) == 0\nassert op_gt5_absval_max([]) == 0\nassert op_gt5_absval_max([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_absval_max([5, 5, 5]) == 0\nassert op_gt5_absval_max([3, 1, 2]) == 0\nassert op_gt5_absval_max([10]) == 10\nassert op_gt5_absval_max([2, 4, 6]) == 6\nassert op_gt5_absval_max([-7, 12, -7]) == 12"}
{"id": "op_gt5_inc_sum", "entry_point": "op_gt5_inc_sum", "primitives": ["gt5", "inc", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then return their sum.", "solution": "def op_gt5_inc_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_gt5_inc_sum([1, 2, 3, 4]) == 0\nassert op_gt5_inc_sum([]) == 0\nassert op_gt5_inc_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_inc_sum([5, 5, 5]) == 0\nassert op_gt5_inc_sum([3, 1, 2]) == 0\nassert op_gt5_inc_sum([10]) == 11\nassert op_gt5_inc_sum([2, 4, 6]) == 7\nassert op_gt5_inc_sum([-7, 12, -7]) == 13"}
{"id": "op_oremptyzero_neg_first3", "entry_point": "op_oremptyzero_neg_first3", "primitives": ["oremptyzero", "neg", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then keep only the first three.", "solution": "def op_oremptyzero_neg_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_neg_first3([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg_first3([]) == []\nassert op_oremptyzero_neg_first3([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_neg_first3([5, 5, 5]) == []\nassert op_oremptyzero_neg_first3([3, 1, 2]) == []\nassert op_oremptyzero_neg_first3([10]) == []\nassert op_oremptyzero_neg_first3([2, 4, 6]) == []\nassert op_oremptyzero_neg_first3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_first3_padto3_dec", "entry_point": "op_first3_padto3_dec", "primitives": ["first3", "padto3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then subtract one from each.", "solution": "def op_first3_padto3_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_padto3_dec([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_padto3_dec([]) == [-1, -1, -1]\nassert op_first3_padto3_dec([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_first3_padto3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_padto3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_first3_padto3_dec([10]) == [9, -1, -1]\nassert op_first3_padto3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_first3_padto3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_negate_padto3_sortd", "entry_point": "op_negate_padto3_sortd", "primitives": ["negate", "padto3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_negate_padto3_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_padto3_sortd([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_negate_padto3_sortd([]) == [0, 0, 0]\nassert op_negate_padto3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_negate_padto3_sortd([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_padto3_sortd([3, 1, 2]) == [-1, -2, -3]\nassert op_negate_padto3_sortd([10]) == [0, 0, -10]\nassert op_negate_padto3_sortd([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_padto3_sortd([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_dropfirst_negate_allpos", "entry_point": "op_dropfirst_negate_allpos", "primitives": ["dropfirst", "negate", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then return whether all values are positive.", "solution": "def op_dropfirst_negate_allpos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dropfirst_negate_allpos([1, 2, 3, 4]) == False\nassert op_dropfirst_negate_allpos([]) == True\nassert op_dropfirst_negate_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_negate_allpos([5, 5, 5]) == False\nassert op_dropfirst_negate_allpos([3, 1, 2]) == False\nassert op_dropfirst_negate_allpos([10]) == True\nassert op_dropfirst_negate_allpos([2, 4, 6]) == False\nassert op_dropfirst_negate_allpos([-7, 12, -7]) == False"}
{"id": "op_first3_last3_alldistinct", "entry_point": "op_first3_last3_alldistinct", "primitives": ["first3", "last3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then return whether all values are distinct.", "solution": "def op_first3_last3_alldistinct(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    return len(r) == len(set(r))", "tests": "assert op_first3_last3_alldistinct([1, 2, 3, 4]) == True\nassert op_first3_last3_alldistinct([]) == True\nassert op_first3_last3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_first3_last3_alldistinct([5, 5, 5]) == False\nassert op_first3_last3_alldistinct([3, 1, 2]) == True\nassert op_first3_last3_alldistinct([10]) == True\nassert op_first3_last3_alldistinct([2, 4, 6]) == True\nassert op_first3_last3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_rev_first3_oremptyzero", "entry_point": "op_rev_first3_oremptyzero", "primitives": ["rev", "first3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then if empty, use a single zero.", "solution": "def op_rev_first3_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_first3_oremptyzero([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_oremptyzero([]) == [0]\nassert op_rev_first3_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3_oremptyzero([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3_oremptyzero([10]) == [10]\nassert op_rev_first3_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_absval_sortabs_trimends", "entry_point": "op_absval_sortabs_trimends", "primitives": ["absval", "sortabs", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then drop the first and last elements.", "solution": "def op_absval_sortabs_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_sortabs_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_absval_sortabs_trimends([]) == []\nassert op_absval_sortabs_trimends([-2, -1, 0, 1, 2]) == [1, 1, 2]\nassert op_absval_sortabs_trimends([5, 5, 5]) == [5]\nassert op_absval_sortabs_trimends([3, 1, 2]) == [2]\nassert op_absval_sortabs_trimends([10]) == []\nassert op_absval_sortabs_trimends([2, 4, 6]) == [4]\nassert op_absval_sortabs_trimends([-7, 12, -7]) == [7]"}
{"id": "op_ages_dropwhileneg_add10", "entry_point": "op_ages_dropwhileneg_add10", "primitives": ["ages", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the leading negative values, then add ten to each.", "solution": "def op_ages_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_dropwhileneg_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_dropwhileneg_add10([]) == []\nassert op_ages_dropwhileneg_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_dropwhileneg_add10([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_gt5_sortd_issorted", "entry_point": "op_gt5_sortd_issorted", "primitives": ["gt5", "sortd", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_gt5_sortd_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_gt5_sortd_issorted([1, 2, 3, 4]) == True\nassert op_gt5_sortd_issorted([]) == True\nassert op_gt5_sortd_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_sortd_issorted([5, 5, 5]) == True\nassert op_gt5_sortd_issorted([3, 1, 2]) == True\nassert op_gt5_sortd_issorted([10]) == True\nassert op_gt5_sortd_issorted([2, 4, 6]) == True\nassert op_gt5_sortd_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_sortd_absval", "entry_point": "op_uniq_sortd_absval", "primitives": ["uniq", "sortd", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then take the absolute value of each.", "solution": "def op_uniq_sortd_absval(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_uniq_sortd_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_sortd_absval([]) == []\nassert op_uniq_sortd_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_uniq_sortd_absval([5, 5, 5]) == [5]\nassert op_uniq_sortd_absval([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_sortd_absval([10]) == [10]\nassert op_uniq_sortd_absval([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_sortd_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_rev_first3_dropzeros", "entry_point": "op_rev_first3_dropzeros", "primitives": ["rev", "first3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then drop the zeros.", "solution": "def op_rev_first3_dropzeros(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_rev_first3_dropzeros([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_dropzeros([]) == []\nassert op_rev_first3_dropzeros([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_first3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3_dropzeros([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3_dropzeros([10]) == [10]\nassert op_rev_first3_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_uniq_gt5_double", "entry_point": "op_uniq_gt5_double", "primitives": ["uniq", "gt5", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then double each.", "solution": "def op_uniq_gt5_double(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_uniq_gt5_double([1, 2, 3, 4]) == []\nassert op_uniq_gt5_double([]) == []\nassert op_uniq_gt5_double([-2, -1, 0, 1, 2]) == []\nassert op_uniq_gt5_double([5, 5, 5]) == []\nassert op_uniq_gt5_double([3, 1, 2]) == []\nassert op_uniq_gt5_double([10]) == [20]\nassert op_uniq_gt5_double([2, 4, 6]) == [12]\nassert op_uniq_gt5_double([-7, 12, -7]) == [24]"}
{"id": "op_clamp10_negate_square", "entry_point": "op_clamp10_negate_square", "primitives": ["clamp10", "negate", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then square each.", "solution": "def op_clamp10_negate_square(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_clamp10_negate_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_clamp10_negate_square([]) == []\nassert op_clamp10_negate_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_clamp10_negate_square([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_negate_square([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_negate_square([10]) == [100]\nassert op_clamp10_negate_square([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_negate_square([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_beforezero_uniq_len", "entry_point": "op_beforezero_uniq_len", "primitives": ["beforezero", "uniq", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_beforezero_uniq_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_beforezero_uniq_len([1, 2, 3, 4]) == 4\nassert op_beforezero_uniq_len([]) == 0\nassert op_beforezero_uniq_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_uniq_len([5, 5, 5]) == 1\nassert op_beforezero_uniq_len([3, 1, 2]) == 3\nassert op_beforezero_uniq_len([10]) == 1\nassert op_beforezero_uniq_len([2, 4, 6]) == 3\nassert op_beforezero_uniq_len([-7, 12, -7]) == 2"}
{"id": "op_dropzeros_add10_haszero", "entry_point": "op_dropzeros_add10_haszero", "primitives": ["dropzeros", "add10", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then return whether the list contains a zero.", "solution": "def op_dropzeros_add10_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return 0 in r", "tests": "assert op_dropzeros_add10_haszero([1, 2, 3, 4]) == False\nassert op_dropzeros_add10_haszero([]) == False\nassert op_dropzeros_add10_haszero([-2, -1, 0, 1, 2]) == False\nassert op_dropzeros_add10_haszero([5, 5, 5]) == False\nassert op_dropzeros_add10_haszero([3, 1, 2]) == False\nassert op_dropzeros_add10_haszero([10]) == False\nassert op_dropzeros_add10_haszero([2, 4, 6]) == False\nassert op_dropzeros_add10_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_square_anyeven", "entry_point": "op_clamp10_square_anyeven", "primitives": ["clamp10", "square", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then return whether any value is even.", "solution": "def op_clamp10_square_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_square_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_square_anyeven([]) == False\nassert op_clamp10_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_square_anyeven([5, 5, 5]) == False\nassert op_clamp10_square_anyeven([3, 1, 2]) == True\nassert op_clamp10_square_anyeven([10]) == True\nassert op_clamp10_square_anyeven([2, 4, 6]) == True\nassert op_clamp10_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_sorta_last3_add10", "entry_point": "op_sorta_last3_add10", "primitives": ["sorta", "last3", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the last three, then add ten to each.", "solution": "def op_sorta_last3_add10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sorta_last3_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_sorta_last3_add10([]) == []\nassert op_sorta_last3_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_sorta_last3_add10([5, 5, 5]) == [15, 15, 15]\nassert op_sorta_last3_add10([3, 1, 2]) == [11, 12, 13]\nassert op_sorta_last3_add10([10]) == [20]\nassert op_sorta_last3_add10([2, 4, 6]) == [12, 14, 16]\nassert op_sorta_last3_add10([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_sorta_first3_sum", "entry_point": "op_sorta_first3_sum", "primitives": ["sorta", "first3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then return their sum.", "solution": "def op_sorta_first3_sum(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    return sum(r)", "tests": "assert op_sorta_first3_sum([1, 2, 3, 4]) == 6\nassert op_sorta_first3_sum([]) == 0\nassert op_sorta_first3_sum([-2, -1, 0, 1, 2]) == -3\nassert op_sorta_first3_sum([5, 5, 5]) == 15\nassert op_sorta_first3_sum([3, 1, 2]) == 6\nassert op_sorta_first3_sum([10]) == 10\nassert op_sorta_first3_sum([2, 4, 6]) == 12\nassert op_sorta_first3_sum([-7, 12, -7]) == -2"}
{"id": "op_pos_rev_div3", "entry_point": "op_pos_rev_div3", "primitives": ["pos", "rev", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then reverse the order, then keep multiples of three.", "solution": "def op_pos_rev_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_pos_rev_div3([1, 2, 3, 4]) == [3]\nassert op_pos_rev_div3([]) == []\nassert op_pos_rev_div3([-2, -1, 0, 1, 2]) == []\nassert op_pos_rev_div3([5, 5, 5]) == []\nassert op_pos_rev_div3([3, 1, 2]) == [3]\nassert op_pos_rev_div3([10]) == []\nassert op_pos_rev_div3([2, 4, 6]) == [6]\nassert op_pos_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_first3_beforezero_sorta", "entry_point": "op_first3_beforezero_sorta", "primitives": ["first3", "beforezero", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep everything before the first zero, then sort ascending.", "solution": "def op_first3_beforezero_sorta(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return r", "tests": "assert op_first3_beforezero_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_beforezero_sorta([]) == []\nassert op_first3_beforezero_sorta([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_beforezero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_first3_beforezero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_first3_beforezero_sorta([10]) == [10]\nassert op_first3_beforezero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_first3_beforezero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_trimends_div3_sum", "entry_point": "op_trimends_div3_sum", "primitives": ["trimends", "div3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep multiples of three, then return their sum.", "solution": "def op_trimends_div3_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return sum(r)", "tests": "assert op_trimends_div3_sum([1, 2, 3, 4]) == 3\nassert op_trimends_div3_sum([]) == 0\nassert op_trimends_div3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_div3_sum([5, 5, 5]) == 0\nassert op_trimends_div3_sum([3, 1, 2]) == 0\nassert op_trimends_div3_sum([10]) == 0\nassert op_trimends_div3_sum([2, 4, 6]) == 0\nassert op_trimends_div3_sum([-7, 12, -7]) == 12"}
{"id": "op_div3_dropfirst_rev", "entry_point": "op_div3_dropfirst_rev", "primitives": ["div3", "dropfirst", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then reverse the order.", "solution": "def op_div3_dropfirst_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_div3_dropfirst_rev([1, 2, 3, 4]) == []\nassert op_div3_dropfirst_rev([]) == []\nassert op_div3_dropfirst_rev([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst_rev([5, 5, 5]) == []\nassert op_div3_dropfirst_rev([3, 1, 2]) == []\nassert op_div3_dropfirst_rev([10]) == []\nassert op_div3_dropfirst_rev([2, 4, 6]) == []\nassert op_div3_dropfirst_rev([-7, 12, -7]) == []"}
{"id": "op_absval_sortabs_sorta", "entry_point": "op_absval_sortabs_sorta", "primitives": ["absval", "sortabs", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort by absolute value, then sort ascending.", "solution": "def op_absval_sortabs_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    return r", "tests": "assert op_absval_sortabs_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_sortabs_sorta([]) == []\nassert op_absval_sortabs_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_absval_sortabs_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_absval_sortabs_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_absval_sortabs_sorta([10]) == [10]\nassert op_absval_sortabs_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_absval_sortabs_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_sortd_dropfirst_dropwhileneg", "entry_point": "op_sortd_dropfirst_dropwhileneg", "primitives": ["sortd", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then drop the leading negative values.", "solution": "def op_sortd_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_dropfirst_dropwhileneg([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dropfirst_dropwhileneg([]) == []\nassert op_sortd_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_sortd_dropfirst_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_sortd_dropfirst_dropwhileneg([3, 1, 2]) == [2, 1]\nassert op_sortd_dropfirst_dropwhileneg([10]) == []\nassert op_sortd_dropfirst_dropwhileneg([2, 4, 6]) == [4, 2]\nassert op_sortd_dropfirst_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_inc_rev_evens", "entry_point": "op_inc_rev_evens", "primitives": ["inc", "rev", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then reverse the order, then keep the even numbers.", "solution": "def op_inc_rev_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_rev_evens([1, 2, 3, 4]) == [4, 2]\nassert op_inc_rev_evens([]) == []\nassert op_inc_rev_evens([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_inc_rev_evens([5, 5, 5]) == [6, 6, 6]\nassert op_inc_rev_evens([3, 1, 2]) == [2, 4]\nassert op_inc_rev_evens([10]) == []\nassert op_inc_rev_evens([2, 4, 6]) == []\nassert op_inc_rev_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_add10_last3_issorted", "entry_point": "op_add10_last3_issorted", "primitives": ["add10", "last3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_add10_last3_issorted(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_add10_last3_issorted([1, 2, 3, 4]) == True\nassert op_add10_last3_issorted([]) == True\nassert op_add10_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_add10_last3_issorted([5, 5, 5]) == True\nassert op_add10_last3_issorted([3, 1, 2]) == False\nassert op_add10_last3_issorted([10]) == True\nassert op_add10_last3_issorted([2, 4, 6]) == True\nassert op_add10_last3_issorted([-7, 12, -7]) == False"}
{"id": "op_padto3_add10_dropzeros", "entry_point": "op_padto3_add10_dropzeros", "primitives": ["padto3", "add10", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add ten to each, then drop the zeros.", "solution": "def op_padto3_add10_dropzeros(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_padto3_add10_dropzeros([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_padto3_add10_dropzeros([]) == [10, 10, 10]\nassert op_padto3_add10_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_padto3_add10_dropzeros([5, 5, 5]) == [15, 15, 15]\nassert op_padto3_add10_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_padto3_add10_dropzeros([10]) == [20, 10, 10]\nassert op_padto3_add10_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_padto3_add10_dropzeros([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_sorta_neg_double", "entry_point": "op_sorta_neg_double", "primitives": ["sorta", "neg", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers, then double each.", "solution": "def op_sorta_neg_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_neg_double([1, 2, 3, 4]) == []\nassert op_sorta_neg_double([]) == []\nassert op_sorta_neg_double([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_sorta_neg_double([5, 5, 5]) == []\nassert op_sorta_neg_double([3, 1, 2]) == []\nassert op_sorta_neg_double([10]) == []\nassert op_sorta_neg_double([2, 4, 6]) == []\nassert op_sorta_neg_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_rev_odds_firsteven", "entry_point": "op_rev_odds_firsteven", "primitives": ["rev", "odds", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_rev_odds_firsteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_rev_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_rev_odds_firsteven([]) == 0\nassert op_rev_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_rev_odds_firsteven([5, 5, 5]) == 0\nassert op_rev_odds_firsteven([3, 1, 2]) == 0\nassert op_rev_odds_firsteven([10]) == 0\nassert op_rev_odds_firsteven([2, 4, 6]) == 0\nassert op_rev_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropzeros_add10_issorted", "entry_point": "op_dropzeros_add10_issorted", "primitives": ["dropzeros", "add10", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_add10_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_dropzeros_add10_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_add10_issorted([]) == True\nassert op_dropzeros_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_add10_issorted([5, 5, 5]) == True\nassert op_dropzeros_add10_issorted([3, 1, 2]) == False\nassert op_dropzeros_add10_issorted([10]) == True\nassert op_dropzeros_add10_issorted([2, 4, 6]) == True\nassert op_dropzeros_add10_issorted([-7, 12, -7]) == False"}
{"id": "op_last3_dropfirst_gt5", "entry_point": "op_last3_dropfirst_gt5", "primitives": ["last3", "dropfirst", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then keep values greater than five.", "solution": "def op_last3_dropfirst_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_dropfirst_gt5([1, 2, 3, 4]) == []\nassert op_last3_dropfirst_gt5([]) == []\nassert op_last3_dropfirst_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_dropfirst_gt5([5, 5, 5]) == []\nassert op_last3_dropfirst_gt5([3, 1, 2]) == []\nassert op_last3_dropfirst_gt5([10]) == []\nassert op_last3_dropfirst_gt5([2, 4, 6]) == [6]\nassert op_last3_dropfirst_gt5([-7, 12, -7]) == [12]"}
{"id": "op_rev_gt5_trimends", "entry_point": "op_rev_gt5_trimends", "primitives": ["rev", "gt5", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five, then drop the first and last elements.", "solution": "def op_rev_gt5_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_gt5_trimends([1, 2, 3, 4]) == []\nassert op_rev_gt5_trimends([]) == []\nassert op_rev_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_rev_gt5_trimends([5, 5, 5]) == []\nassert op_rev_gt5_trimends([3, 1, 2]) == []\nassert op_rev_gt5_trimends([10]) == []\nassert op_rev_gt5_trimends([2, 4, 6]) == []\nassert op_rev_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_names_lower_prefixup", "entry_point": "op_names_lower_prefixup", "primitives": ["names", "lower", "prefixup"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then lowercase each string, then prefix each with a hash.", "solution": "def op_names_lower_prefixup(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.lower() for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_names_lower_prefixup([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['#ada', '#bo']\nassert op_names_lower_prefixup([]) == []\nassert op_names_lower_prefixup([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['#cy', '#dee', '#el']\nassert op_names_lower_prefixup([{'name': 'Fi', 'age': 41}]) == ['#fi']"}
{"id": "op_pos_uniq_double", "entry_point": "op_pos_uniq_double", "primitives": ["pos", "uniq", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then double each.", "solution": "def op_pos_uniq_double(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_pos_uniq_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_uniq_double([]) == []\nassert op_pos_uniq_double([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_uniq_double([5, 5, 5]) == [10]\nassert op_pos_uniq_double([3, 1, 2]) == [6, 2, 4]\nassert op_pos_uniq_double([10]) == [20]\nassert op_pos_uniq_double([2, 4, 6]) == [4, 8, 12]\nassert op_pos_uniq_double([-7, 12, -7]) == [24]"}
{"id": "op_uniq_takewhilepos_oremptyzero", "entry_point": "op_uniq_takewhilepos_oremptyzero", "primitives": ["uniq", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_uniq_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_takewhilepos_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_takewhilepos_oremptyzero([]) == [0]\nassert op_uniq_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_takewhilepos_oremptyzero([5, 5, 5]) == [5]\nassert op_uniq_takewhilepos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_takewhilepos_oremptyzero([10]) == [10]\nassert op_uniq_takewhilepos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_takewhilepos_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_inc_dec_trimends", "entry_point": "op_inc_dec_trimends", "primitives": ["inc", "dec", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then drop the first and last elements.", "solution": "def op_inc_dec_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_dec_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_inc_dec_trimends([]) == []\nassert op_inc_dec_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_dec_trimends([5, 5, 5]) == [5]\nassert op_inc_dec_trimends([3, 1, 2]) == [1]\nassert op_inc_dec_trimends([10]) == []\nassert op_inc_dec_trimends([2, 4, 6]) == [4]\nassert op_inc_dec_trimends([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_takewhilepos_counteven", "entry_point": "op_dropfirst_takewhilepos_counteven", "primitives": ["dropfirst", "takewhilepos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then return how many values are even.", "solution": "def op_dropfirst_takewhilepos_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_takewhilepos_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_takewhilepos_counteven([]) == 0\nassert op_dropfirst_takewhilepos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_takewhilepos_counteven([5, 5, 5]) == 0\nassert op_dropfirst_takewhilepos_counteven([3, 1, 2]) == 1\nassert op_dropfirst_takewhilepos_counteven([10]) == 0\nassert op_dropfirst_takewhilepos_counteven([2, 4, 6]) == 2\nassert op_dropfirst_takewhilepos_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_beforezero_firsteven", "entry_point": "op_dropfirst_beforezero_firsteven", "primitives": ["dropfirst", "beforezero", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_dropfirst_beforezero_firsteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropfirst_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_beforezero_firsteven([]) == 0\nassert op_dropfirst_beforezero_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_beforezero_firsteven([5, 5, 5]) == 0\nassert op_dropfirst_beforezero_firsteven([3, 1, 2]) == 2\nassert op_dropfirst_beforezero_firsteven([10]) == 0\nassert op_dropfirst_beforezero_firsteven([2, 4, 6]) == 4\nassert op_dropfirst_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_first3_prod", "entry_point": "op_dropwhileneg_first3_prod", "primitives": ["dropwhileneg", "first3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then return their product.", "solution": "def op_dropwhileneg_first3_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_first3_prod([1, 2, 3, 4]) == 6\nassert op_dropwhileneg_first3_prod([]) == 1\nassert op_dropwhileneg_first3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_first3_prod([5, 5, 5]) == 125\nassert op_dropwhileneg_first3_prod([3, 1, 2]) == 6\nassert op_dropwhileneg_first3_prod([10]) == 10\nassert op_dropwhileneg_first3_prod([2, 4, 6]) == 48\nassert op_dropwhileneg_first3_prod([-7, 12, -7]) == -84"}
{"id": "op_negate_dropzeros_len", "entry_point": "op_negate_dropzeros_len", "primitives": ["negate", "dropzeros", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then return how many remain.", "solution": "def op_negate_dropzeros_len(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_negate_dropzeros_len([1, 2, 3, 4]) == 4\nassert op_negate_dropzeros_len([]) == 0\nassert op_negate_dropzeros_len([-2, -1, 0, 1, 2]) == 4\nassert op_negate_dropzeros_len([5, 5, 5]) == 3\nassert op_negate_dropzeros_len([3, 1, 2]) == 3\nassert op_negate_dropzeros_len([10]) == 1\nassert op_negate_dropzeros_len([2, 4, 6]) == 3\nassert op_negate_dropzeros_len([-7, 12, -7]) == 3"}
{"id": "op_evens_sorta_pos", "entry_point": "op_evens_sorta_pos", "primitives": ["evens", "sorta", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then keep the positive numbers.", "solution": "def op_evens_sorta_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_evens_sorta_pos([1, 2, 3, 4]) == [2, 4]\nassert op_evens_sorta_pos([]) == []\nassert op_evens_sorta_pos([-2, -1, 0, 1, 2]) == [2]\nassert op_evens_sorta_pos([5, 5, 5]) == []\nassert op_evens_sorta_pos([3, 1, 2]) == [2]\nassert op_evens_sorta_pos([10]) == [10]\nassert op_evens_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_evens_sorta_pos([-7, 12, -7]) == [12]"}
{"id": "op_add10_absval_sortabs", "entry_point": "op_add10_absval_sortabs", "primitives": ["add10", "absval", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then sort by absolute value.", "solution": "def op_add10_absval_sortabs(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_add10_absval_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_absval_sortabs([]) == []\nassert op_add10_absval_sortabs([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_absval_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_add10_absval_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_add10_absval_sortabs([10]) == [20]\nassert op_add10_absval_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_add10_absval_sortabs([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_ages_last3_max", "entry_point": "op_ages_last3_max", "primitives": ["ages", "last3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_ages_last3_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_ages_last3_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_last3_max([]) == 0\nassert op_ages_last3_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_last3_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_uniq_square_sum", "entry_point": "op_uniq_square_sum", "primitives": ["uniq", "square", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then square each, then return their sum.", "solution": "def op_uniq_square_sum(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_uniq_square_sum([1, 2, 3, 4]) == 30\nassert op_uniq_square_sum([]) == 0\nassert op_uniq_square_sum([-2, -1, 0, 1, 2]) == 10\nassert op_uniq_square_sum([5, 5, 5]) == 25\nassert op_uniq_square_sum([3, 1, 2]) == 14\nassert op_uniq_square_sum([10]) == 100\nassert op_uniq_square_sum([2, 4, 6]) == 56\nassert op_uniq_square_sum([-7, 12, -7]) == 193"}
{"id": "op_uniq_negate_anyeven", "entry_point": "op_uniq_negate_anyeven", "primitives": ["uniq", "negate", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then return whether any value is even.", "solution": "def op_uniq_negate_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_negate_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_negate_anyeven([]) == False\nassert op_uniq_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_negate_anyeven([5, 5, 5]) == False\nassert op_uniq_negate_anyeven([3, 1, 2]) == True\nassert op_uniq_negate_anyeven([10]) == True\nassert op_uniq_negate_anyeven([2, 4, 6]) == True\nassert op_uniq_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_inc_firsteven", "entry_point": "op_uniq_inc_firsteven", "primitives": ["uniq", "inc", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then return the first even value (0 if none).", "solution": "def op_uniq_inc_firsteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_uniq_inc_firsteven([1, 2, 3, 4]) == 2\nassert op_uniq_inc_firsteven([]) == 0\nassert op_uniq_inc_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_inc_firsteven([5, 5, 5]) == 6\nassert op_uniq_inc_firsteven([3, 1, 2]) == 4\nassert op_uniq_inc_firsteven([10]) == 0\nassert op_uniq_inc_firsteven([2, 4, 6]) == 0\nassert op_uniq_inc_firsteven([-7, 12, -7]) == -6"}
{"id": "op_neg_beforezero_prod", "entry_point": "op_neg_beforezero_prod", "primitives": ["neg", "beforezero", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then return their product.", "solution": "def op_neg_beforezero_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_neg_beforezero_prod([1, 2, 3, 4]) == 1\nassert op_neg_beforezero_prod([]) == 1\nassert op_neg_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_neg_beforezero_prod([5, 5, 5]) == 1\nassert op_neg_beforezero_prod([3, 1, 2]) == 1\nassert op_neg_beforezero_prod([10]) == 1\nassert op_neg_beforezero_prod([2, 4, 6]) == 1\nassert op_neg_beforezero_prod([-7, 12, -7]) == 49"}
{"id": "op_square_inc_rev", "entry_point": "op_square_inc_rev", "primitives": ["square", "inc", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each, then reverse the order.", "solution": "def op_square_inc_rev(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_square_inc_rev([1, 2, 3, 4]) == [17, 10, 5, 2]\nassert op_square_inc_rev([]) == []\nassert op_square_inc_rev([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_square_inc_rev([5, 5, 5]) == [26, 26, 26]\nassert op_square_inc_rev([3, 1, 2]) == [5, 2, 10]\nassert op_square_inc_rev([10]) == [101]\nassert op_square_inc_rev([2, 4, 6]) == [37, 17, 5]\nassert op_square_inc_rev([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_uniq_double_absval", "entry_point": "op_uniq_double_absval", "primitives": ["uniq", "double", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then double each, then take the absolute value of each.", "solution": "def op_uniq_double_absval(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_uniq_double_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_uniq_double_absval([]) == []\nassert op_uniq_double_absval([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_uniq_double_absval([5, 5, 5]) == [10]\nassert op_uniq_double_absval([3, 1, 2]) == [6, 2, 4]\nassert op_uniq_double_absval([10]) == [20]\nassert op_uniq_double_absval([2, 4, 6]) == [4, 8, 12]\nassert op_uniq_double_absval([-7, 12, -7]) == [14, 24]"}
{"id": "op_inc_sortd_dropwhileneg", "entry_point": "op_inc_sortd_dropwhileneg", "primitives": ["inc", "sortd", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort descending, then drop the leading negative values.", "solution": "def op_inc_sortd_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_inc_sortd_dropwhileneg([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_inc_sortd_dropwhileneg([]) == []\nassert op_inc_sortd_dropwhileneg([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_inc_sortd_dropwhileneg([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sortd_dropwhileneg([3, 1, 2]) == [4, 3, 2]\nassert op_inc_sortd_dropwhileneg([10]) == [11]\nassert op_inc_sortd_dropwhileneg([2, 4, 6]) == [7, 5, 3]\nassert op_inc_sortd_dropwhileneg([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_neg_negate_counteven", "entry_point": "op_neg_negate_counteven", "primitives": ["neg", "negate", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then return how many values are even.", "solution": "def op_neg_negate_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_negate_counteven([1, 2, 3, 4]) == 0\nassert op_neg_negate_counteven([]) == 0\nassert op_neg_negate_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_negate_counteven([5, 5, 5]) == 0\nassert op_neg_negate_counteven([3, 1, 2]) == 0\nassert op_neg_negate_counteven([10]) == 0\nassert op_neg_negate_counteven([2, 4, 6]) == 0\nassert op_neg_negate_counteven([-7, 12, -7]) == 0"}
{"id": "op_square_last3_max", "entry_point": "op_square_last3_max", "primitives": ["square", "last3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_square_last3_max(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_square_last3_max([1, 2, 3, 4]) == 16\nassert op_square_last3_max([]) == 0\nassert op_square_last3_max([-2, -1, 0, 1, 2]) == 4\nassert op_square_last3_max([5, 5, 5]) == 25\nassert op_square_last3_max([3, 1, 2]) == 9\nassert op_square_last3_max([10]) == 100\nassert op_square_last3_max([2, 4, 6]) == 36\nassert op_square_last3_max([-7, 12, -7]) == 144"}
{"id": "op_dropwhileneg_dropzeros_last3", "entry_point": "op_dropwhileneg_dropzeros_last3", "primitives": ["dropwhileneg", "dropzeros", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the zeros, then keep only the last three.", "solution": "def op_dropwhileneg_dropzeros_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_dropzeros_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_dropzeros_last3([]) == []\nassert op_dropwhileneg_dropzeros_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_dropzeros_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_dropzeros_last3([10]) == [10]\nassert op_dropwhileneg_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_dropzeros_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortd_gt5_allpos", "entry_point": "op_sortd_gt5_allpos", "primitives": ["sortd", "gt5", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five, then return whether all values are positive.", "solution": "def op_sortd_gt5_allpos(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_sortd_gt5_allpos([1, 2, 3, 4]) == True\nassert op_sortd_gt5_allpos([]) == True\nassert op_sortd_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_sortd_gt5_allpos([5, 5, 5]) == True\nassert op_sortd_gt5_allpos([3, 1, 2]) == True\nassert op_sortd_gt5_allpos([10]) == True\nassert op_sortd_gt5_allpos([2, 4, 6]) == True\nassert op_sortd_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_first3_uniq_trimends", "entry_point": "op_first3_uniq_trimends", "primitives": ["first3", "uniq", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then drop the first and last elements.", "solution": "def op_first3_uniq_trimends(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_first3_uniq_trimends([1, 2, 3, 4]) == [2]\nassert op_first3_uniq_trimends([]) == []\nassert op_first3_uniq_trimends([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_uniq_trimends([5, 5, 5]) == []\nassert op_first3_uniq_trimends([3, 1, 2]) == [1]\nassert op_first3_uniq_trimends([10]) == []\nassert op_first3_uniq_trimends([2, 4, 6]) == [4]\nassert op_first3_uniq_trimends([-7, 12, -7]) == []"}
{"id": "op_ages_square_add10", "entry_point": "op_ages_square_add10", "primitives": ["ages", "square", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then add ten to each.", "solution": "def op_ages_square_add10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_ages_square_add10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1306, 154]\nassert op_ages_square_add10([]) == []\nassert op_ages_square_add10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [334, 4235, 299]\nassert op_ages_square_add10([{'name': 'Fi', 'age': 41}]) == [1691]"}
{"id": "op_uniq_pos_last3", "entry_point": "op_uniq_pos_last3", "primitives": ["uniq", "pos", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then keep only the last three.", "solution": "def op_uniq_pos_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_pos_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_pos_last3([]) == []\nassert op_uniq_pos_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_pos_last3([5, 5, 5]) == [5]\nassert op_uniq_pos_last3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_pos_last3([10]) == [10]\nassert op_uniq_pos_last3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_pos_last3([-7, 12, -7]) == [12]"}
{"id": "op_first3_add10_sortd", "entry_point": "op_first3_add10_sortd", "primitives": ["first3", "add10", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then sort descending.", "solution": "def op_first3_add10_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_add10_sortd([1, 2, 3, 4]) == [13, 12, 11]\nassert op_first3_add10_sortd([]) == []\nassert op_first3_add10_sortd([-2, -1, 0, 1, 2]) == [10, 9, 8]\nassert op_first3_add10_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_first3_add10_sortd([3, 1, 2]) == [13, 12, 11]\nassert op_first3_add10_sortd([10]) == [20]\nassert op_first3_add10_sortd([2, 4, 6]) == [16, 14, 12]\nassert op_first3_add10_sortd([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_uniq_odds_neg", "entry_point": "op_uniq_odds_neg", "primitives": ["uniq", "odds", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then keep the negative numbers.", "solution": "def op_uniq_odds_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_odds_neg([1, 2, 3, 4]) == []\nassert op_uniq_odds_neg([]) == []\nassert op_uniq_odds_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_uniq_odds_neg([5, 5, 5]) == []\nassert op_uniq_odds_neg([3, 1, 2]) == []\nassert op_uniq_odds_neg([10]) == []\nassert op_uniq_odds_neg([2, 4, 6]) == []\nassert op_uniq_odds_neg([-7, 12, -7]) == [-7]"}
{"id": "op_inc_clamp10_counteven", "entry_point": "op_inc_clamp10_counteven", "primitives": ["inc", "clamp10", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then return how many values are even.", "solution": "def op_inc_clamp10_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_clamp10_counteven([1, 2, 3, 4]) == 2\nassert op_inc_clamp10_counteven([]) == 0\nassert op_inc_clamp10_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_inc_clamp10_counteven([5, 5, 5]) == 3\nassert op_inc_clamp10_counteven([3, 1, 2]) == 2\nassert op_inc_clamp10_counteven([10]) == 1\nassert op_inc_clamp10_counteven([2, 4, 6]) == 0\nassert op_inc_clamp10_counteven([-7, 12, -7]) == 3"}
{"id": "op_gt5_sortd_odds", "entry_point": "op_gt5_sortd_odds", "primitives": ["gt5", "sortd", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort descending, then keep the odd numbers.", "solution": "def op_gt5_sortd_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_sortd_odds([1, 2, 3, 4]) == []\nassert op_gt5_sortd_odds([]) == []\nassert op_gt5_sortd_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortd_odds([5, 5, 5]) == []\nassert op_gt5_sortd_odds([3, 1, 2]) == []\nassert op_gt5_sortd_odds([10]) == []\nassert op_gt5_sortd_odds([2, 4, 6]) == []\nassert op_gt5_sortd_odds([-7, 12, -7]) == []"}
{"id": "op_dec_inc_min", "entry_point": "op_dec_inc_min", "primitives": ["dec", "inc", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then return the minimum (0 if empty).", "solution": "def op_dec_inc_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dec_inc_min([1, 2, 3, 4]) == 1\nassert op_dec_inc_min([]) == 0\nassert op_dec_inc_min([-2, -1, 0, 1, 2]) == -2\nassert op_dec_inc_min([5, 5, 5]) == 5\nassert op_dec_inc_min([3, 1, 2]) == 1\nassert op_dec_inc_min([10]) == 10\nassert op_dec_inc_min([2, 4, 6]) == 2\nassert op_dec_inc_min([-7, 12, -7]) == -7"}
{"id": "op_beforezero_sortabs_max", "entry_point": "op_beforezero_sortabs_max", "primitives": ["beforezero", "sortabs", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_beforezero_sortabs_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_beforezero_sortabs_max([1, 2, 3, 4]) == 4\nassert op_beforezero_sortabs_max([]) == 0\nassert op_beforezero_sortabs_max([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_sortabs_max([5, 5, 5]) == 5\nassert op_beforezero_sortabs_max([3, 1, 2]) == 3\nassert op_beforezero_sortabs_max([10]) == 10\nassert op_beforezero_sortabs_max([2, 4, 6]) == 6\nassert op_beforezero_sortabs_max([-7, 12, -7]) == 12"}
{"id": "op_dec_pos_inc", "entry_point": "op_dec_pos_inc", "primitives": ["dec", "pos", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the positive numbers, then add one to each.", "solution": "def op_dec_pos_inc(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dec_pos_inc([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dec_pos_inc([]) == []\nassert op_dec_pos_inc([-2, -1, 0, 1, 2]) == [2]\nassert op_dec_pos_inc([5, 5, 5]) == [5, 5, 5]\nassert op_dec_pos_inc([3, 1, 2]) == [3, 2]\nassert op_dec_pos_inc([10]) == [10]\nassert op_dec_pos_inc([2, 4, 6]) == [2, 4, 6]\nassert op_dec_pos_inc([-7, 12, -7]) == [12]"}
{"id": "op_div3_odds_issorted", "entry_point": "op_div3_odds_issorted", "primitives": ["div3", "odds", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_div3_odds_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_div3_odds_issorted([1, 2, 3, 4]) == True\nassert op_div3_odds_issorted([]) == True\nassert op_div3_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_div3_odds_issorted([5, 5, 5]) == True\nassert op_div3_odds_issorted([3, 1, 2]) == True\nassert op_div3_odds_issorted([10]) == True\nassert op_div3_odds_issorted([2, 4, 6]) == True\nassert op_div3_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_negate_padto3_rev", "entry_point": "op_negate_padto3_rev", "primitives": ["negate", "padto3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_negate_padto3_rev(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_negate_padto3_rev([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_negate_padto3_rev([]) == [0, 0, 0]\nassert op_negate_padto3_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_negate_padto3_rev([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_padto3_rev([3, 1, 2]) == [-2, -1, -3]\nassert op_negate_padto3_rev([10]) == [0, 0, -10]\nassert op_negate_padto3_rev([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_padto3_rev([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_div3_square_rev", "entry_point": "op_div3_square_rev", "primitives": ["div3", "square", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then reverse the order.", "solution": "def op_div3_square_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_div3_square_rev([1, 2, 3, 4]) == [9]\nassert op_div3_square_rev([]) == []\nassert op_div3_square_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_square_rev([5, 5, 5]) == []\nassert op_div3_square_rev([3, 1, 2]) == [9]\nassert op_div3_square_rev([10]) == []\nassert op_div3_square_rev([2, 4, 6]) == [36]\nassert op_div3_square_rev([-7, 12, -7]) == [144]"}
{"id": "op_clamp10_square_sortd", "entry_point": "op_clamp10_square_sortd", "primitives": ["clamp10", "square", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then sort descending.", "solution": "def op_clamp10_square_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_clamp10_square_sortd([]) == []\nassert op_clamp10_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_clamp10_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_clamp10_square_sortd([10]) == [100]\nassert op_clamp10_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_clamp10_square_sortd([-7, 12, -7]) == [100, 49, 49]"}
{"id": "op_add10_absval_allpos", "entry_point": "op_add10_absval_allpos", "primitives": ["add10", "absval", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_add10_absval_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_absval_allpos([1, 2, 3, 4]) == True\nassert op_add10_absval_allpos([]) == True\nassert op_add10_absval_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_absval_allpos([5, 5, 5]) == True\nassert op_add10_absval_allpos([3, 1, 2]) == True\nassert op_add10_absval_allpos([10]) == True\nassert op_add10_absval_allpos([2, 4, 6]) == True\nassert op_add10_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_padto3_absval", "entry_point": "op_sorta_padto3_absval", "primitives": ["sorta", "padto3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_sorta_padto3_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_padto3_absval([]) == [0, 0, 0]\nassert op_sorta_padto3_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_padto3_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_padto3_absval([10]) == [10, 0, 0]\nassert op_sorta_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_padto3_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_sortd_square_sorta", "entry_point": "op_sortd_square_sorta", "primitives": ["sortd", "square", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then sort ascending.", "solution": "def op_sortd_square_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_square_sorta([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortd_square_sorta([]) == []\nassert op_sortd_square_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sortd_square_sorta([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_sorta([3, 1, 2]) == [1, 4, 9]\nassert op_sortd_square_sorta([10]) == [100]\nassert op_sortd_square_sorta([2, 4, 6]) == [4, 16, 36]\nassert op_sortd_square_sorta([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dropwhileneg_uniq_negate", "entry_point": "op_dropwhileneg_uniq_negate", "primitives": ["dropwhileneg", "uniq", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_dropwhileneg_uniq_negate(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropwhileneg_uniq_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_dropwhileneg_uniq_negate([]) == []\nassert op_dropwhileneg_uniq_negate([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_dropwhileneg_uniq_negate([5, 5, 5]) == [-5]\nassert op_dropwhileneg_uniq_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_dropwhileneg_uniq_negate([10]) == [-10]\nassert op_dropwhileneg_uniq_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_dropwhileneg_uniq_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_add10_uniq_sum", "entry_point": "op_add10_uniq_sum", "primitives": ["add10", "uniq", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_add10_uniq_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_add10_uniq_sum([1, 2, 3, 4]) == 50\nassert op_add10_uniq_sum([]) == 0\nassert op_add10_uniq_sum([-2, -1, 0, 1, 2]) == 50\nassert op_add10_uniq_sum([5, 5, 5]) == 15\nassert op_add10_uniq_sum([3, 1, 2]) == 36\nassert op_add10_uniq_sum([10]) == 20\nassert op_add10_uniq_sum([2, 4, 6]) == 42\nassert op_add10_uniq_sum([-7, 12, -7]) == 25"}
{"id": "op_gt5_add10_clamp10", "entry_point": "op_gt5_add10_clamp10", "primitives": ["gt5", "add10", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then cap each value at 10.", "solution": "def op_gt5_add10_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_add10_clamp10([1, 2, 3, 4]) == []\nassert op_gt5_add10_clamp10([]) == []\nassert op_gt5_add10_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_add10_clamp10([5, 5, 5]) == []\nassert op_gt5_add10_clamp10([3, 1, 2]) == []\nassert op_gt5_add10_clamp10([10]) == [10]\nassert op_gt5_add10_clamp10([2, 4, 6]) == [10]\nassert op_gt5_add10_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_add10_first3_haszero", "entry_point": "op_add10_first3_haszero", "primitives": ["add10", "first3", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then return whether the list contains a zero.", "solution": "def op_add10_first3_haszero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return 0 in r", "tests": "assert op_add10_first3_haszero([1, 2, 3, 4]) == False\nassert op_add10_first3_haszero([]) == False\nassert op_add10_first3_haszero([-2, -1, 0, 1, 2]) == False\nassert op_add10_first3_haszero([5, 5, 5]) == False\nassert op_add10_first3_haszero([3, 1, 2]) == False\nassert op_add10_first3_haszero([10]) == False\nassert op_add10_first3_haszero([2, 4, 6]) == False\nassert op_add10_first3_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_double_len", "entry_point": "op_dropfirst_double_len", "primitives": ["dropfirst", "double", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then double each, then return how many remain.", "solution": "def op_dropfirst_double_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_dropfirst_double_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_double_len([]) == 0\nassert op_dropfirst_double_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_double_len([5, 5, 5]) == 2\nassert op_dropfirst_double_len([3, 1, 2]) == 2\nassert op_dropfirst_double_len([10]) == 0\nassert op_dropfirst_double_len([2, 4, 6]) == 2\nassert op_dropfirst_double_len([-7, 12, -7]) == 2"}
{"id": "op_padto3_first3_haszero", "entry_point": "op_padto3_first3_haszero", "primitives": ["padto3", "first3", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the first three, then return whether the list contains a zero.", "solution": "def op_padto3_first3_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:3]\n    return 0 in r", "tests": "assert op_padto3_first3_haszero([1, 2, 3, 4]) == False\nassert op_padto3_first3_haszero([]) == True\nassert op_padto3_first3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_first3_haszero([5, 5, 5]) == False\nassert op_padto3_first3_haszero([3, 1, 2]) == False\nassert op_padto3_first3_haszero([10]) == True\nassert op_padto3_first3_haszero([2, 4, 6]) == False\nassert op_padto3_first3_haszero([-7, 12, -7]) == False"}
{"id": "op_absval_dropzeros_prod", "entry_point": "op_absval_dropzeros_prod", "primitives": ["absval", "dropzeros", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the zeros, then return their product.", "solution": "def op_absval_dropzeros_prod(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_absval_dropzeros_prod([1, 2, 3, 4]) == 24\nassert op_absval_dropzeros_prod([]) == 1\nassert op_absval_dropzeros_prod([-2, -1, 0, 1, 2]) == 4\nassert op_absval_dropzeros_prod([5, 5, 5]) == 125\nassert op_absval_dropzeros_prod([3, 1, 2]) == 6\nassert op_absval_dropzeros_prod([10]) == 10\nassert op_absval_dropzeros_prod([2, 4, 6]) == 48\nassert op_absval_dropzeros_prod([-7, 12, -7]) == 588"}
{"id": "op_takewhilepos_dec_negate", "entry_point": "op_takewhilepos_dec_negate", "primitives": ["takewhilepos", "dec", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then negate each.", "solution": "def op_takewhilepos_dec_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_dec_negate([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_takewhilepos_dec_negate([]) == []\nassert op_takewhilepos_dec_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec_negate([5, 5, 5]) == [-4, -4, -4]\nassert op_takewhilepos_dec_negate([3, 1, 2]) == [-2, 0, -1]\nassert op_takewhilepos_dec_negate([10]) == [-9]\nassert op_takewhilepos_dec_negate([2, 4, 6]) == [-1, -3, -5]\nassert op_takewhilepos_dec_negate([-7, 12, -7]) == []"}
{"id": "op_last3_sortd_anyeven", "entry_point": "op_last3_sortd_anyeven", "primitives": ["last3", "sortd", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then return whether any value is even.", "solution": "def op_last3_sortd_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_sortd_anyeven([1, 2, 3, 4]) == True\nassert op_last3_sortd_anyeven([]) == False\nassert op_last3_sortd_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_sortd_anyeven([5, 5, 5]) == False\nassert op_last3_sortd_anyeven([3, 1, 2]) == True\nassert op_last3_sortd_anyeven([10]) == True\nassert op_last3_sortd_anyeven([2, 4, 6]) == True\nassert op_last3_sortd_anyeven([-7, 12, -7]) == True"}
{"id": "op_trimends_dropzeros_len", "entry_point": "op_trimends_dropzeros_len", "primitives": ["trimends", "dropzeros", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then return how many remain.", "solution": "def op_trimends_dropzeros_len(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return len(r)", "tests": "assert op_trimends_dropzeros_len([1, 2, 3, 4]) == 2\nassert op_trimends_dropzeros_len([]) == 0\nassert op_trimends_dropzeros_len([-2, -1, 0, 1, 2]) == 2\nassert op_trimends_dropzeros_len([5, 5, 5]) == 1\nassert op_trimends_dropzeros_len([3, 1, 2]) == 1\nassert op_trimends_dropzeros_len([10]) == 0\nassert op_trimends_dropzeros_len([2, 4, 6]) == 1\nassert op_trimends_dropzeros_len([-7, 12, -7]) == 1"}
{"id": "op_takewhilepos_gt5_double", "entry_point": "op_takewhilepos_gt5_double", "primitives": ["takewhilepos", "gt5", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep values greater than five, then double each.", "solution": "def op_takewhilepos_gt5_double(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_gt5_double([1, 2, 3, 4]) == []\nassert op_takewhilepos_gt5_double([]) == []\nassert op_takewhilepos_gt5_double([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_gt5_double([5, 5, 5]) == []\nassert op_takewhilepos_gt5_double([3, 1, 2]) == []\nassert op_takewhilepos_gt5_double([10]) == [20]\nassert op_takewhilepos_gt5_double([2, 4, 6]) == [12]\nassert op_takewhilepos_gt5_double([-7, 12, -7]) == []"}
{"id": "op_sortd_negate_odds", "entry_point": "op_sortd_negate_odds", "primitives": ["sortd", "negate", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then negate each, then keep the odd numbers.", "solution": "def op_sortd_negate_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_negate_odds([1, 2, 3, 4]) == [-3, -1]\nassert op_sortd_negate_odds([]) == []\nassert op_sortd_negate_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_sortd_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_sortd_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_sortd_negate_odds([10]) == []\nassert op_sortd_negate_odds([2, 4, 6]) == []\nassert op_sortd_negate_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_upper_sortalpha_firstchar", "entry_point": "op_upper_sortalpha_firstchar", "primitives": ["upper", "sortalpha", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort alphabetically, then keep the first character of each (dropping empties).", "solution": "def op_upper_sortalpha_firstchar(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_upper_sortalpha_firstchar(['Hello', 'world']) == ['H', 'W']\nassert op_upper_sortalpha_firstchar([]) == []\nassert op_upper_sortalpha_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'B']\nassert op_upper_sortalpha_firstchar(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_upper_sortalpha_firstchar(['x']) == ['X']\nassert op_upper_sortalpha_firstchar(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_inc_div3_last3", "entry_point": "op_inc_div3_last3", "primitives": ["inc", "div3", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then keep only the last three.", "solution": "def op_inc_div3_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_div3_last3([1, 2, 3, 4]) == [3]\nassert op_inc_div3_last3([]) == []\nassert op_inc_div3_last3([-2, -1, 0, 1, 2]) == [0, 3]\nassert op_inc_div3_last3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_div3_last3([3, 1, 2]) == [3]\nassert op_inc_div3_last3([10]) == []\nassert op_inc_div3_last3([2, 4, 6]) == [3]\nassert op_inc_div3_last3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_pos_double_evens", "entry_point": "op_pos_double_evens", "primitives": ["pos", "double", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then keep the even numbers.", "solution": "def op_pos_double_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_pos_double_evens([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_pos_double_evens([]) == []\nassert op_pos_double_evens([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_pos_double_evens([5, 5, 5]) == [10, 10, 10]\nassert op_pos_double_evens([3, 1, 2]) == [6, 2, 4]\nassert op_pos_double_evens([10]) == [20]\nassert op_pos_double_evens([2, 4, 6]) == [4, 8, 12]\nassert op_pos_double_evens([-7, 12, -7]) == [24]"}
{"id": "op_neg_rev_double", "entry_point": "op_neg_rev_double", "primitives": ["neg", "rev", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then double each.", "solution": "def op_neg_rev_double(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_neg_rev_double([1, 2, 3, 4]) == []\nassert op_neg_rev_double([]) == []\nassert op_neg_rev_double([-2, -1, 0, 1, 2]) == [-2, -4]\nassert op_neg_rev_double([5, 5, 5]) == []\nassert op_neg_rev_double([3, 1, 2]) == []\nassert op_neg_rev_double([10]) == []\nassert op_neg_rev_double([2, 4, 6]) == []\nassert op_neg_rev_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_dec_rev_min", "entry_point": "op_dec_rev_min", "primitives": ["dec", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_dec_rev_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_dec_rev_min([1, 2, 3, 4]) == 0\nassert op_dec_rev_min([]) == 0\nassert op_dec_rev_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_rev_min([5, 5, 5]) == 4\nassert op_dec_rev_min([3, 1, 2]) == 0\nassert op_dec_rev_min([10]) == 9\nassert op_dec_rev_min([2, 4, 6]) == 1\nassert op_dec_rev_min([-7, 12, -7]) == -8"}
{"id": "op_inc_pos_trimends", "entry_point": "op_inc_pos_trimends", "primitives": ["inc", "pos", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_inc_pos_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_pos_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_inc_pos_trimends([]) == []\nassert op_inc_pos_trimends([-2, -1, 0, 1, 2]) == [2]\nassert op_inc_pos_trimends([5, 5, 5]) == [6]\nassert op_inc_pos_trimends([3, 1, 2]) == [2]\nassert op_inc_pos_trimends([10]) == []\nassert op_inc_pos_trimends([2, 4, 6]) == [5]\nassert op_inc_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_negate_absval_oremptyzero", "entry_point": "op_negate_absval_oremptyzero", "primitives": ["negate", "absval", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_negate_absval_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_absval_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_negate_absval_oremptyzero([]) == [0]\nassert op_negate_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_negate_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_negate_absval_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_negate_absval_oremptyzero([10]) == [10]\nassert op_negate_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_negate_absval_oremptyzero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_absval_rev_neg", "entry_point": "op_absval_rev_neg", "primitives": ["absval", "rev", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then keep the negative numbers.", "solution": "def op_absval_rev_neg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_absval_rev_neg([1, 2, 3, 4]) == []\nassert op_absval_rev_neg([]) == []\nassert op_absval_rev_neg([-2, -1, 0, 1, 2]) == []\nassert op_absval_rev_neg([5, 5, 5]) == []\nassert op_absval_rev_neg([3, 1, 2]) == []\nassert op_absval_rev_neg([10]) == []\nassert op_absval_rev_neg([2, 4, 6]) == []\nassert op_absval_rev_neg([-7, 12, -7]) == []"}
{"id": "op_neg_last3_gt5", "entry_point": "op_neg_last3_gt5", "primitives": ["neg", "last3", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the last three, then keep values greater than five.", "solution": "def op_neg_last3_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_neg_last3_gt5([1, 2, 3, 4]) == []\nassert op_neg_last3_gt5([]) == []\nassert op_neg_last3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_neg_last3_gt5([5, 5, 5]) == []\nassert op_neg_last3_gt5([3, 1, 2]) == []\nassert op_neg_last3_gt5([10]) == []\nassert op_neg_last3_gt5([2, 4, 6]) == []\nassert op_neg_last3_gt5([-7, 12, -7]) == []"}
{"id": "op_div3_inc_double", "entry_point": "op_div3_inc_double", "primitives": ["div3", "inc", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then double each.", "solution": "def op_div3_inc_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_inc_double([1, 2, 3, 4]) == [8]\nassert op_div3_inc_double([]) == []\nassert op_div3_inc_double([-2, -1, 0, 1, 2]) == [2]\nassert op_div3_inc_double([5, 5, 5]) == []\nassert op_div3_inc_double([3, 1, 2]) == [8]\nassert op_div3_inc_double([10]) == []\nassert op_div3_inc_double([2, 4, 6]) == [14]\nassert op_div3_inc_double([-7, 12, -7]) == [26]"}
{"id": "op_ages_sorta_inc", "entry_point": "op_ages_sorta_inc", "primitives": ["ages", "sorta", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then add one to each.", "solution": "def op_ages_sorta_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_sorta_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [13, 37]\nassert op_ages_sorta_inc([]) == []\nassert op_ages_sorta_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 19, 66]\nassert op_ages_sorta_inc([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_negate_square_clamp10", "entry_point": "op_negate_square_clamp10", "primitives": ["negate", "square", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then cap each value at 10.", "solution": "def op_negate_square_clamp10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_negate_square_clamp10([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_negate_square_clamp10([]) == []\nassert op_negate_square_clamp10([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_square_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_negate_square_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_negate_square_clamp10([10]) == [10]\nassert op_negate_square_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_negate_square_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_trimends_oremptyzero_div3", "entry_point": "op_trimends_oremptyzero_div3", "primitives": ["trimends", "oremptyzero", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then keep multiples of three.", "solution": "def op_trimends_oremptyzero_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_oremptyzero_div3([1, 2, 3, 4]) == [3]\nassert op_trimends_oremptyzero_div3([]) == [0]\nassert op_trimends_oremptyzero_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_oremptyzero_div3([5, 5, 5]) == []\nassert op_trimends_oremptyzero_div3([3, 1, 2]) == []\nassert op_trimends_oremptyzero_div3([10]) == [0]\nassert op_trimends_oremptyzero_div3([2, 4, 6]) == []\nassert op_trimends_oremptyzero_div3([-7, 12, -7]) == [12]"}
{"id": "op_sortd_absval_max", "entry_point": "op_sortd_absval_max", "primitives": ["sortd", "absval", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_sortd_absval_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_sortd_absval_max([1, 2, 3, 4]) == 4\nassert op_sortd_absval_max([]) == 0\nassert op_sortd_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_absval_max([5, 5, 5]) == 5\nassert op_sortd_absval_max([3, 1, 2]) == 3\nassert op_sortd_absval_max([10]) == 10\nassert op_sortd_absval_max([2, 4, 6]) == 6\nassert op_sortd_absval_max([-7, 12, -7]) == 12"}
{"id": "op_inc_first3_pos", "entry_point": "op_inc_first3_pos", "primitives": ["inc", "first3", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then keep the positive numbers.", "solution": "def op_inc_first3_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_first3_pos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_first3_pos([]) == []\nassert op_inc_first3_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_inc_first3_pos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_first3_pos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_first3_pos([10]) == [11]\nassert op_inc_first3_pos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_first3_pos([-7, 12, -7]) == [13]"}
{"id": "op_gt5_neg_evens", "entry_point": "op_gt5_neg_evens", "primitives": ["gt5", "neg", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then keep the even numbers.", "solution": "def op_gt5_neg_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_gt5_neg_evens([1, 2, 3, 4]) == []\nassert op_gt5_neg_evens([]) == []\nassert op_gt5_neg_evens([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg_evens([5, 5, 5]) == []\nassert op_gt5_neg_evens([3, 1, 2]) == []\nassert op_gt5_neg_evens([10]) == []\nassert op_gt5_neg_evens([2, 4, 6]) == []\nassert op_gt5_neg_evens([-7, 12, -7]) == []"}
{"id": "op_dropzeros_absval_dropwhileneg", "entry_point": "op_dropzeros_absval_dropwhileneg", "primitives": ["dropzeros", "absval", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then drop the leading negative values.", "solution": "def op_dropzeros_absval_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_absval_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropzeros_absval_dropwhileneg([]) == []\nassert op_dropzeros_absval_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_dropzeros_absval_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_absval_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_absval_dropwhileneg([10]) == [10]\nassert op_dropzeros_absval_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_absval_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_first3_dropwhileneg", "entry_point": "op_double_first3_dropwhileneg", "primitives": ["double", "first3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the first three, then drop the leading negative values.", "solution": "def op_double_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_first3_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6]\nassert op_double_first3_dropwhileneg([]) == []\nassert op_double_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_double_first3_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_double_first3_dropwhileneg([3, 1, 2]) == [6, 2, 4]\nassert op_double_first3_dropwhileneg([10]) == [20]\nassert op_double_first3_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_double_first3_dropwhileneg([-7, 12, -7]) == [24, -14]"}
{"id": "op_trimends_last3_prod", "entry_point": "op_trimends_last3_prod", "primitives": ["trimends", "last3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then return their product.", "solution": "def op_trimends_last3_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_trimends_last3_prod([1, 2, 3, 4]) == 6\nassert op_trimends_last3_prod([]) == 1\nassert op_trimends_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_last3_prod([5, 5, 5]) == 5\nassert op_trimends_last3_prod([3, 1, 2]) == 1\nassert op_trimends_last3_prod([10]) == 1\nassert op_trimends_last3_prod([2, 4, 6]) == 4\nassert op_trimends_last3_prod([-7, 12, -7]) == 12"}
{"id": "op_last3_trimends_negate", "entry_point": "op_last3_trimends_negate", "primitives": ["last3", "trimends", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then negate each.", "solution": "def op_last3_trimends_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_trimends_negate([1, 2, 3, 4]) == [-3]\nassert op_last3_trimends_negate([]) == []\nassert op_last3_trimends_negate([-2, -1, 0, 1, 2]) == [-1]\nassert op_last3_trimends_negate([5, 5, 5]) == [-5]\nassert op_last3_trimends_negate([3, 1, 2]) == [-1]\nassert op_last3_trimends_negate([10]) == []\nassert op_last3_trimends_negate([2, 4, 6]) == [-4]\nassert op_last3_trimends_negate([-7, 12, -7]) == [-12]"}
{"id": "op_sortd_absval_inc", "entry_point": "op_sortd_absval_inc", "primitives": ["sortd", "absval", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then add one to each.", "solution": "def op_sortd_absval_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_absval_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_absval_inc([]) == []\nassert op_sortd_absval_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 2, 3]\nassert op_sortd_absval_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_absval_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_absval_inc([10]) == [11]\nassert op_sortd_absval_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_absval_inc([-7, 12, -7]) == [13, 8, 8]"}
{"id": "op_dropfirst_absval_uniq", "entry_point": "op_dropfirst_absval_uniq", "primitives": ["dropfirst", "absval", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_absval_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_absval_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_absval_uniq([]) == []\nassert op_dropfirst_absval_uniq([-2, -1, 0, 1, 2]) == [1, 0, 2]\nassert op_dropfirst_absval_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_absval_uniq([3, 1, 2]) == [1, 2]\nassert op_dropfirst_absval_uniq([10]) == []\nassert op_dropfirst_absval_uniq([2, 4, 6]) == [4, 6]\nassert op_dropfirst_absval_uniq([-7, 12, -7]) == [12, 7]"}
{"id": "op_pos_last3_sorta", "entry_point": "op_pos_last3_sorta", "primitives": ["pos", "last3", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the last three, then sort ascending.", "solution": "def op_pos_last3_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    r = sorted(r)\n    return r", "tests": "assert op_pos_last3_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_pos_last3_sorta([]) == []\nassert op_pos_last3_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_last3_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_pos_last3_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_pos_last3_sorta([10]) == [10]\nassert op_pos_last3_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_pos_last3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_add10_div3_dropwhileneg", "entry_point": "op_add10_div3_dropwhileneg", "primitives": ["add10", "div3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep multiples of three, then drop the leading negative values.", "solution": "def op_add10_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_div3_dropwhileneg([1, 2, 3, 4]) == [12]\nassert op_add10_div3_dropwhileneg([]) == []\nassert op_add10_div3_dropwhileneg([-2, -1, 0, 1, 2]) == [9, 12]\nassert op_add10_div3_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_div3_dropwhileneg([3, 1, 2]) == [12]\nassert op_add10_div3_dropwhileneg([10]) == []\nassert op_add10_div3_dropwhileneg([2, 4, 6]) == [12]\nassert op_add10_div3_dropwhileneg([-7, 12, -7]) == [3, 3]"}
{"id": "op_dropfirst_first3_alldistinct", "entry_point": "op_dropfirst_first3_alldistinct", "primitives": ["dropfirst", "first3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then return whether all values are distinct.", "solution": "def op_dropfirst_first3_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_first3_alldistinct([]) == True\nassert op_dropfirst_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_first3_alldistinct([5, 5, 5]) == False\nassert op_dropfirst_first3_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_first3_alldistinct([10]) == True\nassert op_dropfirst_first3_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_first3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sorta_odds_double", "entry_point": "op_sorta_odds_double", "primitives": ["sorta", "odds", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers, then double each.", "solution": "def op_sorta_odds_double(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sorta_odds_double([1, 2, 3, 4]) == [2, 6]\nassert op_sorta_odds_double([]) == []\nassert op_sorta_odds_double([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_sorta_odds_double([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_odds_double([3, 1, 2]) == [2, 6]\nassert op_sorta_odds_double([10]) == []\nassert op_sorta_odds_double([2, 4, 6]) == []\nassert op_sorta_odds_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_dec_first3_dropzeros", "entry_point": "op_dec_first3_dropzeros", "primitives": ["dec", "first3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then drop the zeros.", "solution": "def op_dec_first3_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_first3_dropzeros([1, 2, 3, 4]) == [1, 2]\nassert op_dec_first3_dropzeros([]) == []\nassert op_dec_first3_dropzeros([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_first3_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dec_first3_dropzeros([10]) == [9]\nassert op_dec_first3_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_neg_negate_sorta", "entry_point": "op_neg_negate_sorta", "primitives": ["neg", "negate", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then negate each, then sort ascending.", "solution": "def op_neg_negate_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_neg_negate_sorta([1, 2, 3, 4]) == []\nassert op_neg_negate_sorta([]) == []\nassert op_neg_negate_sorta([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_neg_negate_sorta([5, 5, 5]) == []\nassert op_neg_negate_sorta([3, 1, 2]) == []\nassert op_neg_negate_sorta([10]) == []\nassert op_neg_negate_sorta([2, 4, 6]) == []\nassert op_neg_negate_sorta([-7, 12, -7]) == [7, 7]"}
{"id": "op_neg_gt5_firsteven", "entry_point": "op_neg_gt5_firsteven", "primitives": ["neg", "gt5", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep values greater than five, then return the first even value (0 if none).", "solution": "def op_neg_gt5_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_gt5_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_gt5_firsteven([]) == 0\nassert op_neg_gt5_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_gt5_firsteven([5, 5, 5]) == 0\nassert op_neg_gt5_firsteven([3, 1, 2]) == 0\nassert op_neg_gt5_firsteven([10]) == 0\nassert op_neg_gt5_firsteven([2, 4, 6]) == 0\nassert op_neg_gt5_firsteven([-7, 12, -7]) == 0"}
{"id": "op_rev_dropfirst_issorted", "entry_point": "op_rev_dropfirst_issorted", "primitives": ["rev", "dropfirst", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first element, then return whether the list is sorted ascending.", "solution": "def op_rev_dropfirst_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:]\n    return r == sorted(r)", "tests": "assert op_rev_dropfirst_issorted([1, 2, 3, 4]) == False\nassert op_rev_dropfirst_issorted([]) == True\nassert op_rev_dropfirst_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_dropfirst_issorted([5, 5, 5]) == True\nassert op_rev_dropfirst_issorted([3, 1, 2]) == True\nassert op_rev_dropfirst_issorted([10]) == True\nassert op_rev_dropfirst_issorted([2, 4, 6]) == False\nassert op_rev_dropfirst_issorted([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_rev_dec", "entry_point": "op_dropwhileneg_rev_dec", "primitives": ["dropwhileneg", "rev", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then subtract one from each.", "solution": "def op_dropwhileneg_rev_dec(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_dropwhileneg_rev_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dropwhileneg_rev_dec([]) == []\nassert op_dropwhileneg_rev_dec([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_dropwhileneg_rev_dec([5, 5, 5]) == [4, 4, 4]\nassert op_dropwhileneg_rev_dec([3, 1, 2]) == [1, 0, 2]\nassert op_dropwhileneg_rev_dec([10]) == [9]\nassert op_dropwhileneg_rev_dec([2, 4, 6]) == [5, 3, 1]\nassert op_dropwhileneg_rev_dec([-7, 12, -7]) == [-8, 11]"}
{"id": "op_negate_clamp10_square", "entry_point": "op_negate_clamp10_square", "primitives": ["negate", "clamp10", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10, then square each.", "solution": "def op_negate_clamp10_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_clamp10_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_clamp10_square([]) == []\nassert op_negate_clamp10_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_clamp10_square([5, 5, 5]) == [25, 25, 25]\nassert op_negate_clamp10_square([3, 1, 2]) == [9, 1, 4]\nassert op_negate_clamp10_square([10]) == [100]\nassert op_negate_clamp10_square([2, 4, 6]) == [4, 16, 36]\nassert op_negate_clamp10_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_div3_dropzeros_dec", "entry_point": "op_div3_dropzeros_dec", "primitives": ["div3", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros, then subtract one from each.", "solution": "def op_div3_dropzeros_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_dropzeros_dec([1, 2, 3, 4]) == [2]\nassert op_div3_dropzeros_dec([]) == []\nassert op_div3_dropzeros_dec([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros_dec([5, 5, 5]) == []\nassert op_div3_dropzeros_dec([3, 1, 2]) == [2]\nassert op_div3_dropzeros_dec([10]) == []\nassert op_div3_dropzeros_dec([2, 4, 6]) == [5]\nassert op_div3_dropzeros_dec([-7, 12, -7]) == [11]"}
{"id": "op_sorta_rev_inc", "entry_point": "op_sorta_rev_inc", "primitives": ["sorta", "rev", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then add one to each.", "solution": "def op_sorta_rev_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_rev_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sorta_rev_inc([]) == []\nassert op_sorta_rev_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sorta_rev_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_rev_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sorta_rev_inc([10]) == [11]\nassert op_sorta_rev_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sorta_rev_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_evens_sortd_allpos", "entry_point": "op_evens_sortd_allpos", "primitives": ["evens", "sortd", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then return whether all values are positive.", "solution": "def op_evens_sortd_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return all(x > 0 for x in r)", "tests": "assert op_evens_sortd_allpos([1, 2, 3, 4]) == True\nassert op_evens_sortd_allpos([]) == True\nassert op_evens_sortd_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_sortd_allpos([5, 5, 5]) == True\nassert op_evens_sortd_allpos([3, 1, 2]) == True\nassert op_evens_sortd_allpos([10]) == True\nassert op_evens_sortd_allpos([2, 4, 6]) == True\nassert op_evens_sortd_allpos([-7, 12, -7]) == True"}
{"id": "op_clamp10_trimends_sorta", "entry_point": "op_clamp10_trimends_sorta", "primitives": ["clamp10", "trimends", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then sort ascending.", "solution": "def op_clamp10_trimends_sorta(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    r = sorted(r)\n    return r", "tests": "assert op_clamp10_trimends_sorta([1, 2, 3, 4]) == [2, 3]\nassert op_clamp10_trimends_sorta([]) == []\nassert op_clamp10_trimends_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_clamp10_trimends_sorta([5, 5, 5]) == [5]\nassert op_clamp10_trimends_sorta([3, 1, 2]) == [1]\nassert op_clamp10_trimends_sorta([10]) == []\nassert op_clamp10_trimends_sorta([2, 4, 6]) == [4]\nassert op_clamp10_trimends_sorta([-7, 12, -7]) == [10]"}
{"id": "op_add10_sortabs_rev", "entry_point": "op_add10_sortabs_rev", "primitives": ["add10", "sortabs", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then reverse the order.", "solution": "def op_add10_sortabs_rev(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = list(reversed(r))\n    return r", "tests": "assert op_add10_sortabs_rev([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_add10_sortabs_rev([]) == []\nassert op_add10_sortabs_rev([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_add10_sortabs_rev([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortabs_rev([3, 1, 2]) == [13, 12, 11]\nassert op_add10_sortabs_rev([10]) == [20]\nassert op_add10_sortabs_rev([2, 4, 6]) == [16, 14, 12]\nassert op_add10_sortabs_rev([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_padto3_uniq_max", "entry_point": "op_padto3_uniq_max", "primitives": ["padto3", "uniq", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then return the maximum (0 if empty).", "solution": "def op_padto3_uniq_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return max(r) if r else 0", "tests": "assert op_padto3_uniq_max([1, 2, 3, 4]) == 4\nassert op_padto3_uniq_max([]) == 0\nassert op_padto3_uniq_max([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_uniq_max([5, 5, 5]) == 5\nassert op_padto3_uniq_max([3, 1, 2]) == 3\nassert op_padto3_uniq_max([10]) == 10\nassert op_padto3_uniq_max([2, 4, 6]) == 6\nassert op_padto3_uniq_max([-7, 12, -7]) == 12"}
{"id": "op_rev_uniq_alldistinct", "entry_point": "op_rev_uniq_alldistinct", "primitives": ["rev", "uniq", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_rev_uniq_alldistinct(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_rev_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_rev_uniq_alldistinct([]) == True\nassert op_rev_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_rev_uniq_alldistinct([5, 5, 5]) == True\nassert op_rev_uniq_alldistinct([3, 1, 2]) == True\nassert op_rev_uniq_alldistinct([10]) == True\nassert op_rev_uniq_alldistinct([2, 4, 6]) == True\nassert op_rev_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sorta_evens_padto3", "entry_point": "op_sorta_evens_padto3", "primitives": ["sorta", "evens", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_sorta_evens_padto3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sorta_evens_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_sorta_evens_padto3([]) == [0, 0, 0]\nassert op_sorta_evens_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_sorta_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_sorta_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_sorta_evens_padto3([10]) == [10, 0, 0]\nassert op_sorta_evens_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sortalpha_strip_firstchar", "entry_point": "op_sortalpha_strip_firstchar", "primitives": ["sortalpha", "strip", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then trim whitespace from each, then keep the first character of each (dropping empties).", "solution": "def op_sortalpha_strip_firstchar(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_sortalpha_strip_firstchar(['Hello', 'world']) == ['H', 'w']\nassert op_sortalpha_strip_firstchar([]) == []\nassert op_sortalpha_strip_firstchar(['  a ', '', 'BC', 'bc']) == ['a', 'B', 'b']\nassert op_sortalpha_strip_firstchar(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_sortalpha_strip_firstchar(['x']) == ['x']\nassert op_sortalpha_strip_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortabs_pos_square", "entry_point": "op_sortabs_pos_square", "primitives": ["sortabs", "pos", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then square each.", "solution": "def op_sortabs_pos_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_pos_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_pos_square([]) == []\nassert op_sortabs_pos_square([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_sortabs_pos_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_pos_square([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_pos_square([10]) == [100]\nassert op_sortabs_pos_square([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_pos_square([-7, 12, -7]) == [144]"}
{"id": "op_dec_inc_square", "entry_point": "op_dec_inc_square", "primitives": ["dec", "inc", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then square each.", "solution": "def op_dec_inc_square(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dec_inc_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dec_inc_square([]) == []\nassert op_dec_inc_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_dec_inc_square([5, 5, 5]) == [25, 25, 25]\nassert op_dec_inc_square([3, 1, 2]) == [9, 1, 4]\nassert op_dec_inc_square([10]) == [100]\nassert op_dec_inc_square([2, 4, 6]) == [4, 16, 36]\nassert op_dec_inc_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_negate_first3_trimends", "entry_point": "op_negate_first3_trimends", "primitives": ["negate", "first3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three, then drop the first and last elements.", "solution": "def op_negate_first3_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_first3_trimends([1, 2, 3, 4]) == [-2]\nassert op_negate_first3_trimends([]) == []\nassert op_negate_first3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_negate_first3_trimends([5, 5, 5]) == [-5]\nassert op_negate_first3_trimends([3, 1, 2]) == [-1]\nassert op_negate_first3_trimends([10]) == []\nassert op_negate_first3_trimends([2, 4, 6]) == [-4]\nassert op_negate_first3_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_clamp10_absval_takewhilepos", "entry_point": "op_clamp10_absval_takewhilepos", "primitives": ["clamp10", "absval", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then take values while they are positive.", "solution": "def op_clamp10_absval_takewhilepos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_clamp10_absval_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_absval_takewhilepos([]) == []\nassert op_clamp10_absval_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_clamp10_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_absval_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_absval_takewhilepos([10]) == [10]\nassert op_clamp10_absval_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_absval_takewhilepos([-7, 12, -7]) == [7, 10, 7]"}
{"id": "op_names_dropshort_longest", "entry_point": "op_names_dropshort_longest", "primitives": ["names", "dropshort", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then drop strings shorter than three characters, then return the longest string (empty if none).", "solution": "def op_names_dropshort_longest(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s for s in r if len(s) >= 3]\n    return max(r, key=len) if r else ''", "tests": "assert op_names_dropshort_longest([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 'Ada'\nassert op_names_dropshort_longest([]) == ''\nassert op_names_dropshort_longest([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 'Dee'\nassert op_names_dropshort_longest([{'name': 'Fi', 'age': 41}]) == ''"}
{"id": "op_absval_beforezero_prod", "entry_point": "op_absval_beforezero_prod", "primitives": ["absval", "beforezero", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then return their product.", "solution": "def op_absval_beforezero_prod(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_absval_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_absval_beforezero_prod([]) == 1\nassert op_absval_beforezero_prod([-2, -1, 0, 1, 2]) == 2\nassert op_absval_beforezero_prod([5, 5, 5]) == 125\nassert op_absval_beforezero_prod([3, 1, 2]) == 6\nassert op_absval_beforezero_prod([10]) == 10\nassert op_absval_beforezero_prod([2, 4, 6]) == 48\nassert op_absval_beforezero_prod([-7, 12, -7]) == 588"}
{"id": "op_lower_nonempty_longest", "entry_point": "op_lower_nonempty_longest", "primitives": ["lower", "nonempty", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop empty strings, then return the longest string (empty if none).", "solution": "def op_lower_nonempty_longest(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_lower_nonempty_longest(['Hello', 'world']) == 'hello'\nassert op_lower_nonempty_longest([]) == ''\nassert op_lower_nonempty_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_lower_nonempty_longest(['one', 'one', 'Two']) == 'one'\nassert op_lower_nonempty_longest(['x']) == 'x'\nassert op_lower_nonempty_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_negate_last3_clamp10", "entry_point": "op_negate_last3_clamp10", "primitives": ["negate", "last3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the last three, then cap each value at 10.", "solution": "def op_negate_last3_clamp10(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_negate_last3_clamp10([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_last3_clamp10([]) == []\nassert op_negate_last3_clamp10([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_negate_last3_clamp10([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_last3_clamp10([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_last3_clamp10([10]) == [-10]\nassert op_negate_last3_clamp10([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_last3_clamp10([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_absval_negate_evens", "entry_point": "op_absval_negate_evens", "primitives": ["absval", "negate", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then keep the even numbers.", "solution": "def op_absval_negate_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_negate_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_absval_negate_evens([]) == []\nassert op_absval_negate_evens([-2, -1, 0, 1, 2]) == [-2, 0, -2]\nassert op_absval_negate_evens([5, 5, 5]) == []\nassert op_absval_negate_evens([3, 1, 2]) == [-2]\nassert op_absval_negate_evens([10]) == [-10]\nassert op_absval_negate_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_absval_negate_evens([-7, 12, -7]) == [-12]"}
{"id": "op_padto3_inc_double", "entry_point": "op_padto3_inc_double", "primitives": ["padto3", "inc", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then double each.", "solution": "def op_padto3_inc_double(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_padto3_inc_double([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_padto3_inc_double([]) == [2, 2, 2]\nassert op_padto3_inc_double([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4, 6]\nassert op_padto3_inc_double([5, 5, 5]) == [12, 12, 12]\nassert op_padto3_inc_double([3, 1, 2]) == [8, 4, 6]\nassert op_padto3_inc_double([10]) == [22, 2, 2]\nassert op_padto3_inc_double([2, 4, 6]) == [6, 10, 14]\nassert op_padto3_inc_double([-7, 12, -7]) == [-12, 26, -12]"}
{"id": "op_div3_dropfirst_square", "entry_point": "op_div3_dropfirst_square", "primitives": ["div3", "dropfirst", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first element, then square each.", "solution": "def op_div3_dropfirst_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_div3_dropfirst_square([1, 2, 3, 4]) == []\nassert op_div3_dropfirst_square([]) == []\nassert op_div3_dropfirst_square([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropfirst_square([5, 5, 5]) == []\nassert op_div3_dropfirst_square([3, 1, 2]) == []\nassert op_div3_dropfirst_square([10]) == []\nassert op_div3_dropfirst_square([2, 4, 6]) == []\nassert op_div3_dropfirst_square([-7, 12, -7]) == []"}
{"id": "op_last3_square_gt5", "entry_point": "op_last3_square_gt5", "primitives": ["last3", "square", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then keep values greater than five.", "solution": "def op_last3_square_gt5(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_last3_square_gt5([1, 2, 3, 4]) == [9, 16]\nassert op_last3_square_gt5([]) == []\nassert op_last3_square_gt5([-2, -1, 0, 1, 2]) == []\nassert op_last3_square_gt5([5, 5, 5]) == [25, 25, 25]\nassert op_last3_square_gt5([3, 1, 2]) == [9]\nassert op_last3_square_gt5([10]) == [100]\nassert op_last3_square_gt5([2, 4, 6]) == [16, 36]\nassert op_last3_square_gt5([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_trimends_sortabs_absval", "entry_point": "op_trimends_sortabs_absval", "primitives": ["trimends", "sortabs", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then take the absolute value of each.", "solution": "def op_trimends_sortabs_absval(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_trimends_sortabs_absval([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_sortabs_absval([]) == []\nassert op_trimends_sortabs_absval([-2, -1, 0, 1, 2]) == [0, 1, 1]\nassert op_trimends_sortabs_absval([5, 5, 5]) == [5]\nassert op_trimends_sortabs_absval([3, 1, 2]) == [1]\nassert op_trimends_sortabs_absval([10]) == []\nassert op_trimends_sortabs_absval([2, 4, 6]) == [4]\nassert op_trimends_sortabs_absval([-7, 12, -7]) == [12]"}
{"id": "op_negate_dropfirst_takewhilepos", "entry_point": "op_negate_dropfirst_takewhilepos", "primitives": ["negate", "dropfirst", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then take values while they are positive.", "solution": "def op_negate_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_dropfirst_takewhilepos([1, 2, 3, 4]) == []\nassert op_negate_dropfirst_takewhilepos([]) == []\nassert op_negate_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == [1]\nassert op_negate_dropfirst_takewhilepos([5, 5, 5]) == []\nassert op_negate_dropfirst_takewhilepos([3, 1, 2]) == []\nassert op_negate_dropfirst_takewhilepos([10]) == []\nassert op_negate_dropfirst_takewhilepos([2, 4, 6]) == []\nassert op_negate_dropfirst_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_odds_sum", "entry_point": "op_dropwhileneg_odds_sum", "primitives": ["dropwhileneg", "odds", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then return their sum.", "solution": "def op_dropwhileneg_odds_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return sum(r)", "tests": "assert op_dropwhileneg_odds_sum([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_odds_sum([]) == 0\nassert op_dropwhileneg_odds_sum([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_odds_sum([5, 5, 5]) == 15\nassert op_dropwhileneg_odds_sum([3, 1, 2]) == 4\nassert op_dropwhileneg_odds_sum([10]) == 0\nassert op_dropwhileneg_odds_sum([2, 4, 6]) == 0\nassert op_dropwhileneg_odds_sum([-7, 12, -7]) == -7"}
{"id": "op_add10_first3_dropwhileneg", "entry_point": "op_add10_first3_dropwhileneg", "primitives": ["add10", "first3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then drop the leading negative values.", "solution": "def op_add10_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_first3_dropwhileneg([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_first3_dropwhileneg([]) == []\nassert op_add10_first3_dropwhileneg([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_first3_dropwhileneg([3, 1, 2]) == [13, 11, 12]\nassert op_add10_first3_dropwhileneg([10]) == [20]\nassert op_add10_first3_dropwhileneg([2, 4, 6]) == [12, 14, 16]\nassert op_add10_first3_dropwhileneg([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_pos_sortabs_trimends", "entry_point": "op_pos_sortabs_trimends", "primitives": ["pos", "sortabs", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then drop the first and last elements.", "solution": "def op_pos_sortabs_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_pos_sortabs_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_pos_sortabs_trimends([]) == []\nassert op_pos_sortabs_trimends([-2, -1, 0, 1, 2]) == []\nassert op_pos_sortabs_trimends([5, 5, 5]) == [5]\nassert op_pos_sortabs_trimends([3, 1, 2]) == [2]\nassert op_pos_sortabs_trimends([10]) == []\nassert op_pos_sortabs_trimends([2, 4, 6]) == [4]\nassert op_pos_sortabs_trimends([-7, 12, -7]) == []"}
{"id": "op_neg_dropzeros_dec", "entry_point": "op_neg_dropzeros_dec", "primitives": ["neg", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then subtract one from each.", "solution": "def op_neg_dropzeros_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_neg_dropzeros_dec([1, 2, 3, 4]) == []\nassert op_neg_dropzeros_dec([]) == []\nassert op_neg_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_neg_dropzeros_dec([5, 5, 5]) == []\nassert op_neg_dropzeros_dec([3, 1, 2]) == []\nassert op_neg_dropzeros_dec([10]) == []\nassert op_neg_dropzeros_dec([2, 4, 6]) == []\nassert op_neg_dropzeros_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_odds_absval_sortabs", "entry_point": "op_odds_absval_sortabs", "primitives": ["odds", "absval", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then sort by absolute value.", "solution": "def op_odds_absval_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_absval_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_odds_absval_sortabs([]) == []\nassert op_odds_absval_sortabs([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_absval_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_odds_absval_sortabs([3, 1, 2]) == [1, 3]\nassert op_odds_absval_sortabs([10]) == []\nassert op_odds_absval_sortabs([2, 4, 6]) == []\nassert op_odds_absval_sortabs([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_neg_max", "entry_point": "op_ages_neg_max", "primitives": ["ages", "neg", "max"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_ages_neg_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_ages_neg_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 0\nassert op_ages_neg_max([]) == 0\nassert op_ages_neg_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 0\nassert op_ages_neg_max([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_first3_neg_absval", "entry_point": "op_first3_neg_absval", "primitives": ["first3", "neg", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers, then take the absolute value of each.", "solution": "def op_first3_neg_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_neg_absval([1, 2, 3, 4]) == []\nassert op_first3_neg_absval([]) == []\nassert op_first3_neg_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_first3_neg_absval([5, 5, 5]) == []\nassert op_first3_neg_absval([3, 1, 2]) == []\nassert op_first3_neg_absval([10]) == []\nassert op_first3_neg_absval([2, 4, 6]) == []\nassert op_first3_neg_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_oremptyzero_add10_trimends", "entry_point": "op_oremptyzero_add10_trimends", "primitives": ["oremptyzero", "add10", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then drop the first and last elements.", "solution": "def op_oremptyzero_add10_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_add10_trimends([1, 2, 3, 4]) == [12, 13]\nassert op_oremptyzero_add10_trimends([]) == []\nassert op_oremptyzero_add10_trimends([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_oremptyzero_add10_trimends([5, 5, 5]) == [15]\nassert op_oremptyzero_add10_trimends([3, 1, 2]) == [11]\nassert op_oremptyzero_add10_trimends([10]) == []\nassert op_oremptyzero_add10_trimends([2, 4, 6]) == [14]\nassert op_oremptyzero_add10_trimends([-7, 12, -7]) == [22]"}
{"id": "op_sortd_add10_neg", "entry_point": "op_sortd_add10_neg", "primitives": ["sortd", "add10", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then keep the negative numbers.", "solution": "def op_sortd_add10_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_add10_neg([1, 2, 3, 4]) == []\nassert op_sortd_add10_neg([]) == []\nassert op_sortd_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_sortd_add10_neg([5, 5, 5]) == []\nassert op_sortd_add10_neg([3, 1, 2]) == []\nassert op_sortd_add10_neg([10]) == []\nassert op_sortd_add10_neg([2, 4, 6]) == []\nassert op_sortd_add10_neg([-7, 12, -7]) == []"}
{"id": "op_gt5_sorta_counteven", "entry_point": "op_gt5_sorta_counteven", "primitives": ["gt5", "sorta", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then return how many values are even.", "solution": "def op_gt5_sorta_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_sorta_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_sorta_counteven([]) == 0\nassert op_gt5_sorta_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_sorta_counteven([5, 5, 5]) == 0\nassert op_gt5_sorta_counteven([3, 1, 2]) == 0\nassert op_gt5_sorta_counteven([10]) == 1\nassert op_gt5_sorta_counteven([2, 4, 6]) == 1\nassert op_gt5_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_uniq_beforezero_div3", "entry_point": "op_uniq_beforezero_div3", "primitives": ["uniq", "beforezero", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then keep multiples of three.", "solution": "def op_uniq_beforezero_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_beforezero_div3([1, 2, 3, 4]) == [3]\nassert op_uniq_beforezero_div3([]) == []\nassert op_uniq_beforezero_div3([-2, -1, 0, 1, 2]) == []\nassert op_uniq_beforezero_div3([5, 5, 5]) == []\nassert op_uniq_beforezero_div3([3, 1, 2]) == [3]\nassert op_uniq_beforezero_div3([10]) == []\nassert op_uniq_beforezero_div3([2, 4, 6]) == [6]\nassert op_uniq_beforezero_div3([-7, 12, -7]) == [12]"}
{"id": "op_names_lower_anyempty", "entry_point": "op_names_lower_anyempty", "primitives": ["names", "lower", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then lowercase each string, then return whether any string is empty.", "solution": "def op_names_lower_anyempty(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_names_lower_anyempty([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_names_lower_anyempty([]) == False\nassert op_names_lower_anyempty([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_names_lower_anyempty([{'name': 'Fi', 'age': 41}]) == False"}
{"id": "op_gt5_neg_padto3", "entry_point": "op_gt5_neg_padto3", "primitives": ["gt5", "neg", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_gt5_neg_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_gt5_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_neg_padto3([]) == [0, 0, 0]\nassert op_gt5_neg_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_neg_padto3([10]) == [0, 0, 0]\nassert op_gt5_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_gt5_neg_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_oremptyzero_rev_prod", "entry_point": "op_oremptyzero_rev_prod", "primitives": ["oremptyzero", "rev", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then return their product.", "solution": "def op_oremptyzero_rev_prod(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    return __import__('math').prod(r)", "tests": "assert op_oremptyzero_rev_prod([1, 2, 3, 4]) == 24\nassert op_oremptyzero_rev_prod([]) == 0\nassert op_oremptyzero_rev_prod([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_rev_prod([5, 5, 5]) == 125\nassert op_oremptyzero_rev_prod([3, 1, 2]) == 6\nassert op_oremptyzero_rev_prod([10]) == 10\nassert op_oremptyzero_rev_prod([2, 4, 6]) == 48\nassert op_oremptyzero_rev_prod([-7, 12, -7]) == 588"}
{"id": "op_ages_clamp10_dropzeros", "entry_point": "op_ages_clamp10_dropzeros", "primitives": ["ages", "clamp10", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then drop the zeros.", "solution": "def op_ages_clamp10_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_clamp10_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [10, 10]\nassert op_ages_clamp10_dropzeros([]) == []\nassert op_ages_clamp10_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10, 10, 10]\nassert op_ages_clamp10_dropzeros([{'name': 'Fi', 'age': 41}]) == [10]"}
{"id": "op_pos_sortd_prod", "entry_point": "op_pos_sortd_prod", "primitives": ["pos", "sortd", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then return their product.", "solution": "def op_pos_sortd_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return __import__('math').prod(r)", "tests": "assert op_pos_sortd_prod([1, 2, 3, 4]) == 24\nassert op_pos_sortd_prod([]) == 1\nassert op_pos_sortd_prod([-2, -1, 0, 1, 2]) == 2\nassert op_pos_sortd_prod([5, 5, 5]) == 125\nassert op_pos_sortd_prod([3, 1, 2]) == 6\nassert op_pos_sortd_prod([10]) == 10\nassert op_pos_sortd_prod([2, 4, 6]) == 48\nassert op_pos_sortd_prod([-7, 12, -7]) == 12"}
{"id": "op_gt5_takewhilepos_min", "entry_point": "op_gt5_takewhilepos_min", "primitives": ["gt5", "takewhilepos", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_gt5_takewhilepos_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_gt5_takewhilepos_min([1, 2, 3, 4]) == 0\nassert op_gt5_takewhilepos_min([]) == 0\nassert op_gt5_takewhilepos_min([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_takewhilepos_min([5, 5, 5]) == 0\nassert op_gt5_takewhilepos_min([3, 1, 2]) == 0\nassert op_gt5_takewhilepos_min([10]) == 10\nassert op_gt5_takewhilepos_min([2, 4, 6]) == 6\nassert op_gt5_takewhilepos_min([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_oremptyzero_counteven", "entry_point": "op_dropzeros_oremptyzero_counteven", "primitives": ["dropzeros", "oremptyzero", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then if empty, use a single zero, then return how many values are even.", "solution": "def op_dropzeros_oremptyzero_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r if r else [0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_oremptyzero_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_oremptyzero_counteven([]) == 1\nassert op_dropzeros_oremptyzero_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_oremptyzero_counteven([5, 5, 5]) == 0\nassert op_dropzeros_oremptyzero_counteven([3, 1, 2]) == 1\nassert op_dropzeros_oremptyzero_counteven([10]) == 1\nassert op_dropzeros_oremptyzero_counteven([2, 4, 6]) == 3\nassert op_dropzeros_oremptyzero_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropwhileneg_double_gt5", "entry_point": "op_dropwhileneg_double_gt5", "primitives": ["dropwhileneg", "double", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then keep values greater than five.", "solution": "def op_dropwhileneg_double_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_dropwhileneg_double_gt5([]) == []\nassert op_dropwhileneg_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_double_gt5([3, 1, 2]) == [6]\nassert op_dropwhileneg_double_gt5([10]) == [20]\nassert op_dropwhileneg_double_gt5([2, 4, 6]) == [8, 12]\nassert op_dropwhileneg_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_uniqs_dropshort_strip", "entry_point": "op_uniqs_dropshort_strip", "primitives": ["uniqs", "dropshort", "strip"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then drop strings shorter than three characters, then trim whitespace from each.", "solution": "def op_uniqs_dropshort_strip(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s for s in r if len(s) >= 3]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_uniqs_dropshort_strip(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_dropshort_strip([]) == []\nassert op_uniqs_dropshort_strip(['  a ', '', 'BC', 'bc']) == ['a']\nassert op_uniqs_dropshort_strip(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_dropshort_strip(['x']) == []\nassert op_uniqs_dropshort_strip(['abc', 'de', '']) == ['abc']"}
{"id": "op_evens_beforezero_square", "entry_point": "op_evens_beforezero_square", "primitives": ["evens", "beforezero", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then square each.", "solution": "def op_evens_beforezero_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_evens_beforezero_square([1, 2, 3, 4]) == [4, 16]\nassert op_evens_beforezero_square([]) == []\nassert op_evens_beforezero_square([-2, -1, 0, 1, 2]) == [4]\nassert op_evens_beforezero_square([5, 5, 5]) == []\nassert op_evens_beforezero_square([3, 1, 2]) == [4]\nassert op_evens_beforezero_square([10]) == [100]\nassert op_evens_beforezero_square([2, 4, 6]) == [4, 16, 36]\nassert op_evens_beforezero_square([-7, 12, -7]) == [144]"}
{"id": "op_div3_rev_dropzeros", "entry_point": "op_div3_rev_dropzeros", "primitives": ["div3", "rev", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then drop the zeros.", "solution": "def op_div3_rev_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_div3_rev_dropzeros([1, 2, 3, 4]) == [3]\nassert op_div3_rev_dropzeros([]) == []\nassert op_div3_rev_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_div3_rev_dropzeros([5, 5, 5]) == []\nassert op_div3_rev_dropzeros([3, 1, 2]) == [3]\nassert op_div3_rev_dropzeros([10]) == []\nassert op_div3_rev_dropzeros([2, 4, 6]) == [6]\nassert op_div3_rev_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_evens_rev_counteven", "entry_point": "op_evens_rev_counteven", "primitives": ["evens", "rev", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then return how many values are even.", "solution": "def op_evens_rev_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_rev_counteven([1, 2, 3, 4]) == 2\nassert op_evens_rev_counteven([]) == 0\nassert op_evens_rev_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_rev_counteven([5, 5, 5]) == 0\nassert op_evens_rev_counteven([3, 1, 2]) == 1\nassert op_evens_rev_counteven([10]) == 1\nassert op_evens_rev_counteven([2, 4, 6]) == 3\nassert op_evens_rev_counteven([-7, 12, -7]) == 1"}
{"id": "op_double_neg_dropzeros", "entry_point": "op_double_neg_dropzeros", "primitives": ["double", "neg", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the negative numbers, then drop the zeros.", "solution": "def op_double_neg_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_double_neg_dropzeros([]) == []\nassert op_double_neg_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_neg_dropzeros([5, 5, 5]) == []\nassert op_double_neg_dropzeros([3, 1, 2]) == []\nassert op_double_neg_dropzeros([10]) == []\nassert op_double_neg_dropzeros([2, 4, 6]) == []\nassert op_double_neg_dropzeros([-7, 12, -7]) == [-14, -14]"}
{"id": "op_first3_gt5_inc", "entry_point": "op_first3_gt5_inc", "primitives": ["first3", "gt5", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep values greater than five, then add one to each.", "solution": "def op_first3_gt5_inc(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_first3_gt5_inc([1, 2, 3, 4]) == []\nassert op_first3_gt5_inc([]) == []\nassert op_first3_gt5_inc([-2, -1, 0, 1, 2]) == []\nassert op_first3_gt5_inc([5, 5, 5]) == []\nassert op_first3_gt5_inc([3, 1, 2]) == []\nassert op_first3_gt5_inc([10]) == [11]\nassert op_first3_gt5_inc([2, 4, 6]) == [7]\nassert op_first3_gt5_inc([-7, 12, -7]) == [13]"}
{"id": "op_dropwhileneg_oremptyzero_prod", "entry_point": "op_dropwhileneg_oremptyzero_prod", "primitives": ["dropwhileneg", "oremptyzero", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then return their product.", "solution": "def op_dropwhileneg_oremptyzero_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_oremptyzero_prod([1, 2, 3, 4]) == 24\nassert op_dropwhileneg_oremptyzero_prod([]) == 0\nassert op_dropwhileneg_oremptyzero_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_oremptyzero_prod([5, 5, 5]) == 125\nassert op_dropwhileneg_oremptyzero_prod([3, 1, 2]) == 6\nassert op_dropwhileneg_oremptyzero_prod([10]) == 10\nassert op_dropwhileneg_oremptyzero_prod([2, 4, 6]) == 48\nassert op_dropwhileneg_oremptyzero_prod([-7, 12, -7]) == -84"}
{"id": "op_upper_sortalpha_longest", "entry_point": "op_upper_sortalpha_longest", "primitives": ["upper", "sortalpha", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort alphabetically, then return the longest string (empty if none).", "solution": "def op_upper_sortalpha_longest(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    return max(r, key=len) if r else ''", "tests": "assert op_upper_sortalpha_longest(['Hello', 'world']) == 'HELLO'\nassert op_upper_sortalpha_longest([]) == ''\nassert op_upper_sortalpha_longest(['  a ', '', 'BC', 'bc']) == '  A '\nassert op_upper_sortalpha_longest(['one', 'one', 'Two']) == 'ONE'\nassert op_upper_sortalpha_longest(['x']) == 'X'\nassert op_upper_sortalpha_longest(['abc', 'de', '']) == 'ABC'"}
{"id": "op_takewhilepos_sortd_min", "entry_point": "op_takewhilepos_sortd_min", "primitives": ["takewhilepos", "sortd", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort descending, then return the minimum (0 if empty).", "solution": "def op_takewhilepos_sortd_min(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_takewhilepos_sortd_min([1, 2, 3, 4]) == 1\nassert op_takewhilepos_sortd_min([]) == 0\nassert op_takewhilepos_sortd_min([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_sortd_min([5, 5, 5]) == 5\nassert op_takewhilepos_sortd_min([3, 1, 2]) == 1\nassert op_takewhilepos_sortd_min([10]) == 10\nassert op_takewhilepos_sortd_min([2, 4, 6]) == 2\nassert op_takewhilepos_sortd_min([-7, 12, -7]) == 0"}
{"id": "op_neg_dropwhileneg_trimends", "entry_point": "op_neg_dropwhileneg_trimends", "primitives": ["neg", "dropwhileneg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_neg_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_neg_dropwhileneg_trimends([1, 2, 3, 4]) == []\nassert op_neg_dropwhileneg_trimends([]) == []\nassert op_neg_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropwhileneg_trimends([5, 5, 5]) == []\nassert op_neg_dropwhileneg_trimends([3, 1, 2]) == []\nassert op_neg_dropwhileneg_trimends([10]) == []\nassert op_neg_dropwhileneg_trimends([2, 4, 6]) == []\nassert op_neg_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_rev_oremptyzero_max", "entry_point": "op_rev_oremptyzero_max", "primitives": ["rev", "oremptyzero", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_rev_oremptyzero_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_rev_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_rev_oremptyzero_max([]) == 0\nassert op_rev_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_oremptyzero_max([5, 5, 5]) == 5\nassert op_rev_oremptyzero_max([3, 1, 2]) == 3\nassert op_rev_oremptyzero_max([10]) == 10\nassert op_rev_oremptyzero_max([2, 4, 6]) == 6\nassert op_rev_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_inc_takewhilepos_alldistinct", "entry_point": "op_inc_takewhilepos_alldistinct", "primitives": ["inc", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_inc_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_inc_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_inc_takewhilepos_alldistinct([]) == True\nassert op_inc_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_inc_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_inc_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_inc_takewhilepos_alldistinct([10]) == True\nassert op_inc_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_inc_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_evens_first3_negate", "entry_point": "op_evens_first3_negate", "primitives": ["evens", "first3", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three, then negate each.", "solution": "def op_evens_first3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_evens_first3_negate([1, 2, 3, 4]) == [-2, -4]\nassert op_evens_first3_negate([]) == []\nassert op_evens_first3_negate([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_evens_first3_negate([5, 5, 5]) == []\nassert op_evens_first3_negate([3, 1, 2]) == [-2]\nassert op_evens_first3_negate([10]) == [-10]\nassert op_evens_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_evens_first3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_padto3_rev_min", "entry_point": "op_padto3_rev_min", "primitives": ["padto3", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_padto3_rev_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_padto3_rev_min([1, 2, 3, 4]) == 1\nassert op_padto3_rev_min([]) == 0\nassert op_padto3_rev_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_rev_min([5, 5, 5]) == 5\nassert op_padto3_rev_min([3, 1, 2]) == 1\nassert op_padto3_rev_min([10]) == 0\nassert op_padto3_rev_min([2, 4, 6]) == 2\nassert op_padto3_rev_min([-7, 12, -7]) == -7"}
{"id": "op_beforezero_absval_alldistinct", "entry_point": "op_beforezero_absval_alldistinct", "primitives": ["beforezero", "absval", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then return whether all values are distinct.", "solution": "def op_beforezero_absval_alldistinct(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_beforezero_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_beforezero_absval_alldistinct([]) == True\nassert op_beforezero_absval_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_absval_alldistinct([5, 5, 5]) == False\nassert op_beforezero_absval_alldistinct([3, 1, 2]) == True\nassert op_beforezero_absval_alldistinct([10]) == True\nassert op_beforezero_absval_alldistinct([2, 4, 6]) == True\nassert op_beforezero_absval_alldistinct([-7, 12, -7]) == False"}
{"id": "op_pos_sortd_dropfirst", "entry_point": "op_pos_sortd_dropfirst", "primitives": ["pos", "sortd", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then drop the first element.", "solution": "def op_pos_sortd_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return r", "tests": "assert op_pos_sortd_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_pos_sortd_dropfirst([]) == []\nassert op_pos_sortd_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_sortd_dropfirst([5, 5, 5]) == [5, 5]\nassert op_pos_sortd_dropfirst([3, 1, 2]) == [2, 1]\nassert op_pos_sortd_dropfirst([10]) == []\nassert op_pos_sortd_dropfirst([2, 4, 6]) == [4, 2]\nassert op_pos_sortd_dropfirst([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_rev_firsteven", "entry_point": "op_oremptyzero_rev_firsteven", "primitives": ["oremptyzero", "rev", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then reverse the order, then return the first even value (0 if none).", "solution": "def op_oremptyzero_rev_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_rev_firsteven([1, 2, 3, 4]) == 4\nassert op_oremptyzero_rev_firsteven([]) == 0\nassert op_oremptyzero_rev_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_oremptyzero_rev_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_rev_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_rev_firsteven([10]) == 10\nassert op_oremptyzero_rev_firsteven([2, 4, 6]) == 6\nassert op_oremptyzero_rev_firsteven([-7, 12, -7]) == 12"}
{"id": "op_clamp10_uniq_issorted", "entry_point": "op_clamp10_uniq_issorted", "primitives": ["clamp10", "uniq", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_clamp10_uniq_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_clamp10_uniq_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_uniq_issorted([]) == True\nassert op_clamp10_uniq_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_uniq_issorted([5, 5, 5]) == True\nassert op_clamp10_uniq_issorted([3, 1, 2]) == False\nassert op_clamp10_uniq_issorted([10]) == True\nassert op_clamp10_uniq_issorted([2, 4, 6]) == True\nassert op_clamp10_uniq_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_absval_haszero", "entry_point": "op_uniq_absval_haszero", "primitives": ["uniq", "absval", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_uniq_absval_haszero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_uniq_absval_haszero([1, 2, 3, 4]) == False\nassert op_uniq_absval_haszero([]) == False\nassert op_uniq_absval_haszero([-2, -1, 0, 1, 2]) == True\nassert op_uniq_absval_haszero([5, 5, 5]) == False\nassert op_uniq_absval_haszero([3, 1, 2]) == False\nassert op_uniq_absval_haszero([10]) == False\nassert op_uniq_absval_haszero([2, 4, 6]) == False\nassert op_uniq_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_beforezero_dropzeros", "entry_point": "op_clamp10_beforezero_dropzeros", "primitives": ["clamp10", "beforezero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep everything before the first zero, then drop the zeros.", "solution": "def op_clamp10_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_clamp10_beforezero_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_beforezero_dropzeros([]) == []\nassert op_clamp10_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_beforezero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_beforezero_dropzeros([10]) == [10]\nassert op_clamp10_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_beforezero_dropzeros([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_square_oremptyzero_div3", "entry_point": "op_square_oremptyzero_div3", "primitives": ["square", "oremptyzero", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then if empty, use a single zero, then keep multiples of three.", "solution": "def op_square_oremptyzero_div3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_square_oremptyzero_div3([1, 2, 3, 4]) == [9]\nassert op_square_oremptyzero_div3([]) == [0]\nassert op_square_oremptyzero_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_square_oremptyzero_div3([5, 5, 5]) == []\nassert op_square_oremptyzero_div3([3, 1, 2]) == [9]\nassert op_square_oremptyzero_div3([10]) == []\nassert op_square_oremptyzero_div3([2, 4, 6]) == [36]\nassert op_square_oremptyzero_div3([-7, 12, -7]) == [144]"}
{"id": "op_gt5_beforezero_odds", "entry_point": "op_gt5_beforezero_odds", "primitives": ["gt5", "beforezero", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_gt5_beforezero_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_beforezero_odds([1, 2, 3, 4]) == []\nassert op_gt5_beforezero_odds([]) == []\nassert op_gt5_beforezero_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_beforezero_odds([5, 5, 5]) == []\nassert op_gt5_beforezero_odds([3, 1, 2]) == []\nassert op_gt5_beforezero_odds([10]) == []\nassert op_gt5_beforezero_odds([2, 4, 6]) == []\nassert op_gt5_beforezero_odds([-7, 12, -7]) == []"}
{"id": "op_absval_gt5_sorta", "entry_point": "op_absval_gt5_sorta", "primitives": ["absval", "gt5", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then sort ascending.", "solution": "def op_absval_gt5_sorta(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_absval_gt5_sorta([1, 2, 3, 4]) == []\nassert op_absval_gt5_sorta([]) == []\nassert op_absval_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_sorta([5, 5, 5]) == []\nassert op_absval_gt5_sorta([3, 1, 2]) == []\nassert op_absval_gt5_sorta([10]) == [10]\nassert op_absval_gt5_sorta([2, 4, 6]) == [6]\nassert op_absval_gt5_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_first3_odds_add10", "entry_point": "op_first3_odds_add10", "primitives": ["first3", "odds", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then add ten to each.", "solution": "def op_first3_odds_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_odds_add10([1, 2, 3, 4]) == [11, 13]\nassert op_first3_odds_add10([]) == []\nassert op_first3_odds_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_first3_odds_add10([5, 5, 5]) == [15, 15, 15]\nassert op_first3_odds_add10([3, 1, 2]) == [13, 11]\nassert op_first3_odds_add10([10]) == []\nassert op_first3_odds_add10([2, 4, 6]) == []\nassert op_first3_odds_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_takewhilepos_odds_negate", "entry_point": "op_takewhilepos_odds_negate", "primitives": ["takewhilepos", "odds", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then negate each.", "solution": "def op_takewhilepos_odds_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_odds_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_takewhilepos_odds_negate([]) == []\nassert op_takewhilepos_odds_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_odds_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_odds_negate([3, 1, 2]) == [-3, -1]\nassert op_takewhilepos_odds_negate([10]) == []\nassert op_takewhilepos_odds_negate([2, 4, 6]) == []\nassert op_takewhilepos_odds_negate([-7, 12, -7]) == []"}
{"id": "op_negate_double_uniq", "entry_point": "op_negate_double_uniq", "primitives": ["negate", "double", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then drop duplicates keeping first occurrence.", "solution": "def op_negate_double_uniq(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_negate_double_uniq([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_negate_double_uniq([]) == []\nassert op_negate_double_uniq([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_negate_double_uniq([5, 5, 5]) == [-10]\nassert op_negate_double_uniq([3, 1, 2]) == [-6, -2, -4]\nassert op_negate_double_uniq([10]) == [-20]\nassert op_negate_double_uniq([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_double_uniq([-7, 12, -7]) == [14, -24]"}
{"id": "op_double_rev_haszero", "entry_point": "op_double_rev_haszero", "primitives": ["double", "rev", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then return whether the list contains a zero.", "solution": "def op_double_rev_haszero(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    return 0 in r", "tests": "assert op_double_rev_haszero([1, 2, 3, 4]) == False\nassert op_double_rev_haszero([]) == False\nassert op_double_rev_haszero([-2, -1, 0, 1, 2]) == True\nassert op_double_rev_haszero([5, 5, 5]) == False\nassert op_double_rev_haszero([3, 1, 2]) == False\nassert op_double_rev_haszero([10]) == False\nassert op_double_rev_haszero([2, 4, 6]) == False\nassert op_double_rev_haszero([-7, 12, -7]) == False"}
{"id": "op_trimends_pos_prod", "entry_point": "op_trimends_pos_prod", "primitives": ["trimends", "pos", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then return their product.", "solution": "def op_trimends_pos_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_trimends_pos_prod([1, 2, 3, 4]) == 6\nassert op_trimends_pos_prod([]) == 1\nassert op_trimends_pos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_pos_prod([5, 5, 5]) == 5\nassert op_trimends_pos_prod([3, 1, 2]) == 1\nassert op_trimends_pos_prod([10]) == 1\nassert op_trimends_pos_prod([2, 4, 6]) == 4\nassert op_trimends_pos_prod([-7, 12, -7]) == 12"}
{"id": "op_neg_clamp10_dec", "entry_point": "op_neg_clamp10_dec", "primitives": ["neg", "clamp10", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then subtract one from each.", "solution": "def op_neg_clamp10_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_neg_clamp10_dec([1, 2, 3, 4]) == []\nassert op_neg_clamp10_dec([]) == []\nassert op_neg_clamp10_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_neg_clamp10_dec([5, 5, 5]) == []\nassert op_neg_clamp10_dec([3, 1, 2]) == []\nassert op_neg_clamp10_dec([10]) == []\nassert op_neg_clamp10_dec([2, 4, 6]) == []\nassert op_neg_clamp10_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_uniq_dropfirst_rev", "entry_point": "op_uniq_dropfirst_rev", "primitives": ["uniq", "dropfirst", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then reverse the order.", "solution": "def op_uniq_dropfirst_rev(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_uniq_dropfirst_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_uniq_dropfirst_rev([]) == []\nassert op_uniq_dropfirst_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_uniq_dropfirst_rev([5, 5, 5]) == []\nassert op_uniq_dropfirst_rev([3, 1, 2]) == [2, 1]\nassert op_uniq_dropfirst_rev([10]) == []\nassert op_uniq_dropfirst_rev([2, 4, 6]) == [6, 4]\nassert op_uniq_dropfirst_rev([-7, 12, -7]) == [12]"}
{"id": "op_last3_neg_haszero", "entry_point": "op_last3_neg_haszero", "primitives": ["last3", "neg", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then return whether the list contains a zero.", "solution": "def op_last3_neg_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return 0 in r", "tests": "assert op_last3_neg_haszero([1, 2, 3, 4]) == False\nassert op_last3_neg_haszero([]) == False\nassert op_last3_neg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_last3_neg_haszero([5, 5, 5]) == False\nassert op_last3_neg_haszero([3, 1, 2]) == False\nassert op_last3_neg_haszero([10]) == False\nassert op_last3_neg_haszero([2, 4, 6]) == False\nassert op_last3_neg_haszero([-7, 12, -7]) == False"}
{"id": "op_padto3_absval_first3", "entry_point": "op_padto3_absval_first3", "primitives": ["padto3", "absval", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then keep only the first three.", "solution": "def op_padto3_absval_first3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_padto3_absval_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_absval_first3([]) == [0, 0, 0]\nassert op_padto3_absval_first3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_padto3_absval_first3([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_absval_first3([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_absval_first3([10]) == [10, 0, 0]\nassert op_padto3_absval_first3([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_absval_first3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_clamp10_add10_gt5", "entry_point": "op_clamp10_add10_gt5", "primitives": ["clamp10", "add10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add ten to each, then keep values greater than five.", "solution": "def op_clamp10_add10_gt5(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_clamp10_add10_gt5([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_add10_gt5([]) == []\nassert op_clamp10_add10_gt5([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_clamp10_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_clamp10_add10_gt5([10]) == [20]\nassert op_clamp10_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_add10_gt5([-7, 12, -7]) == [20]"}
{"id": "op_oremptyzero_trimends_dropwhileneg", "entry_point": "op_oremptyzero_trimends_dropwhileneg", "primitives": ["oremptyzero", "trimends", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then drop the leading negative values.", "solution": "def op_oremptyzero_trimends_dropwhileneg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_oremptyzero_trimends_dropwhileneg([1, 2, 3, 4]) == [2, 3]\nassert op_oremptyzero_trimends_dropwhileneg([]) == []\nassert op_oremptyzero_trimends_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_oremptyzero_trimends_dropwhileneg([5, 5, 5]) == [5]\nassert op_oremptyzero_trimends_dropwhileneg([3, 1, 2]) == [1]\nassert op_oremptyzero_trimends_dropwhileneg([10]) == []\nassert op_oremptyzero_trimends_dropwhileneg([2, 4, 6]) == [4]\nassert op_oremptyzero_trimends_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_add10_takewhilepos_min", "entry_point": "op_add10_takewhilepos_min", "primitives": ["add10", "takewhilepos", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then return the minimum (0 if empty).", "solution": "def op_add10_takewhilepos_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return min(r) if r else 0", "tests": "assert op_add10_takewhilepos_min([1, 2, 3, 4]) == 11\nassert op_add10_takewhilepos_min([]) == 0\nassert op_add10_takewhilepos_min([-2, -1, 0, 1, 2]) == 8\nassert op_add10_takewhilepos_min([5, 5, 5]) == 15\nassert op_add10_takewhilepos_min([3, 1, 2]) == 11\nassert op_add10_takewhilepos_min([10]) == 20\nassert op_add10_takewhilepos_min([2, 4, 6]) == 12\nassert op_add10_takewhilepos_min([-7, 12, -7]) == 3"}
{"id": "op_dropzeros_add10_anyeven", "entry_point": "op_dropzeros_add10_anyeven", "primitives": ["dropzeros", "add10", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then return whether any value is even.", "solution": "def op_dropzeros_add10_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_add10_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_add10_anyeven([]) == False\nassert op_dropzeros_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_add10_anyeven([5, 5, 5]) == False\nassert op_dropzeros_add10_anyeven([3, 1, 2]) == True\nassert op_dropzeros_add10_anyeven([10]) == True\nassert op_dropzeros_add10_anyeven([2, 4, 6]) == True\nassert op_dropzeros_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_negate_add10", "entry_point": "op_oremptyzero_negate_add10", "primitives": ["oremptyzero", "negate", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then add ten to each.", "solution": "def op_oremptyzero_negate_add10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_oremptyzero_negate_add10([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_oremptyzero_negate_add10([]) == [10]\nassert op_oremptyzero_negate_add10([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_oremptyzero_negate_add10([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_negate_add10([3, 1, 2]) == [7, 9, 8]\nassert op_oremptyzero_negate_add10([10]) == [0]\nassert op_oremptyzero_negate_add10([2, 4, 6]) == [8, 6, 4]\nassert op_oremptyzero_negate_add10([-7, 12, -7]) == [17, -2, 17]"}
{"id": "op_trimends_add10_neg", "entry_point": "op_trimends_add10_neg", "primitives": ["trimends", "add10", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then keep the negative numbers.", "solution": "def op_trimends_add10_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_add10_neg([1, 2, 3, 4]) == []\nassert op_trimends_add10_neg([]) == []\nassert op_trimends_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_trimends_add10_neg([5, 5, 5]) == []\nassert op_trimends_add10_neg([3, 1, 2]) == []\nassert op_trimends_add10_neg([10]) == []\nassert op_trimends_add10_neg([2, 4, 6]) == []\nassert op_trimends_add10_neg([-7, 12, -7]) == []"}
{"id": "op_dec_negate_neg", "entry_point": "op_dec_negate_neg", "primitives": ["dec", "negate", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then keep the negative numbers.", "solution": "def op_dec_negate_neg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dec_negate_neg([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_dec_negate_neg([]) == []\nassert op_dec_negate_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dec_negate_neg([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_negate_neg([3, 1, 2]) == [-2, -1]\nassert op_dec_negate_neg([10]) == [-9]\nassert op_dec_negate_neg([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_negate_neg([-7, 12, -7]) == [-11]"}
{"id": "op_sortd_sorta_oremptyzero", "entry_point": "op_sortd_sorta_oremptyzero", "primitives": ["sortd", "sorta", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort ascending, then if empty, use a single zero.", "solution": "def op_sortd_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_sorta_oremptyzero([]) == [0]\nassert op_sortd_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_sorta_oremptyzero([10]) == [10]\nassert op_sortd_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_ages_sortd_len", "entry_point": "op_ages_sortd_len", "primitives": ["ages", "sortd", "len"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then return how many remain.", "solution": "def op_ages_sortd_len(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    return len(r)", "tests": "assert op_ages_sortd_len([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_sortd_len([]) == 0\nassert op_ages_sortd_len([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 3\nassert op_ages_sortd_len([{'name': 'Fi', 'age': 41}]) == 1"}
{"id": "op_odds_double_issorted", "entry_point": "op_odds_double_issorted", "primitives": ["odds", "double", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each, then return whether the list is sorted ascending.", "solution": "def op_odds_double_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_odds_double_issorted([1, 2, 3, 4]) == True\nassert op_odds_double_issorted([]) == True\nassert op_odds_double_issorted([-2, -1, 0, 1, 2]) == True\nassert op_odds_double_issorted([5, 5, 5]) == True\nassert op_odds_double_issorted([3, 1, 2]) == False\nassert op_odds_double_issorted([10]) == True\nassert op_odds_double_issorted([2, 4, 6]) == True\nassert op_odds_double_issorted([-7, 12, -7]) == True"}
{"id": "op_pos_sortd_dec", "entry_point": "op_pos_sortd_dec", "primitives": ["pos", "sortd", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then subtract one from each.", "solution": "def op_pos_sortd_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_pos_sortd_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_pos_sortd_dec([]) == []\nassert op_pos_sortd_dec([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_pos_sortd_dec([5, 5, 5]) == [4, 4, 4]\nassert op_pos_sortd_dec([3, 1, 2]) == [2, 1, 0]\nassert op_pos_sortd_dec([10]) == [9]\nassert op_pos_sortd_dec([2, 4, 6]) == [5, 3, 1]\nassert op_pos_sortd_dec([-7, 12, -7]) == [11]"}
{"id": "op_sortabs_clamp10_haszero", "entry_point": "op_sortabs_clamp10_haszero", "primitives": ["sortabs", "clamp10", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then return whether the list contains a zero.", "solution": "def op_sortabs_clamp10_haszero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return 0 in r", "tests": "assert op_sortabs_clamp10_haszero([1, 2, 3, 4]) == False\nassert op_sortabs_clamp10_haszero([]) == False\nassert op_sortabs_clamp10_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_clamp10_haszero([5, 5, 5]) == False\nassert op_sortabs_clamp10_haszero([3, 1, 2]) == False\nassert op_sortabs_clamp10_haszero([10]) == False\nassert op_sortabs_clamp10_haszero([2, 4, 6]) == False\nassert op_sortabs_clamp10_haszero([-7, 12, -7]) == False"}
{"id": "op_clamp10_odds_prod", "entry_point": "op_clamp10_odds_prod", "primitives": ["clamp10", "odds", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then return their product.", "solution": "def op_clamp10_odds_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_odds_prod([1, 2, 3, 4]) == 3\nassert op_clamp10_odds_prod([]) == 1\nassert op_clamp10_odds_prod([-2, -1, 0, 1, 2]) == -1\nassert op_clamp10_odds_prod([5, 5, 5]) == 125\nassert op_clamp10_odds_prod([3, 1, 2]) == 3\nassert op_clamp10_odds_prod([10]) == 1\nassert op_clamp10_odds_prod([2, 4, 6]) == 1\nassert op_clamp10_odds_prod([-7, 12, -7]) == 49"}
{"id": "op_add10_uniq_dropzeros", "entry_point": "op_add10_uniq_dropzeros", "primitives": ["add10", "uniq", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_add10_uniq_dropzeros(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_add10_uniq_dropzeros([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_uniq_dropzeros([]) == []\nassert op_add10_uniq_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_uniq_dropzeros([5, 5, 5]) == [15]\nassert op_add10_uniq_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_add10_uniq_dropzeros([10]) == [20]\nassert op_add10_uniq_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_add10_uniq_dropzeros([-7, 12, -7]) == [3, 22]"}
{"id": "op_neg_oremptyzero_pos", "entry_point": "op_neg_oremptyzero_pos", "primitives": ["neg", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_neg_oremptyzero_pos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_neg_oremptyzero_pos([1, 2, 3, 4]) == []\nassert op_neg_oremptyzero_pos([]) == []\nassert op_neg_oremptyzero_pos([-2, -1, 0, 1, 2]) == []\nassert op_neg_oremptyzero_pos([5, 5, 5]) == []\nassert op_neg_oremptyzero_pos([3, 1, 2]) == []\nassert op_neg_oremptyzero_pos([10]) == []\nassert op_neg_oremptyzero_pos([2, 4, 6]) == []\nassert op_neg_oremptyzero_pos([-7, 12, -7]) == []"}
{"id": "op_sorta_double_pos", "entry_point": "op_sorta_double_pos", "primitives": ["sorta", "double", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then double each, then keep the positive numbers.", "solution": "def op_sorta_double_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_double_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sorta_double_pos([]) == []\nassert op_sorta_double_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_sorta_double_pos([5, 5, 5]) == [10, 10, 10]\nassert op_sorta_double_pos([3, 1, 2]) == [2, 4, 6]\nassert op_sorta_double_pos([10]) == [20]\nassert op_sorta_double_pos([2, 4, 6]) == [4, 8, 12]\nassert op_sorta_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_div3_dropwhileneg_sorta", "entry_point": "op_div3_dropwhileneg_sorta", "primitives": ["div3", "dropwhileneg", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the leading negative values, then sort ascending.", "solution": "def op_div3_dropwhileneg_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    return r", "tests": "assert op_div3_dropwhileneg_sorta([1, 2, 3, 4]) == [3]\nassert op_div3_dropwhileneg_sorta([]) == []\nassert op_div3_dropwhileneg_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_dropwhileneg_sorta([5, 5, 5]) == []\nassert op_div3_dropwhileneg_sorta([3, 1, 2]) == [3]\nassert op_div3_dropwhileneg_sorta([10]) == []\nassert op_div3_dropwhileneg_sorta([2, 4, 6]) == [6]\nassert op_div3_dropwhileneg_sorta([-7, 12, -7]) == [12]"}
{"id": "op_last3_padto3_sortd", "entry_point": "op_last3_padto3_sortd", "primitives": ["last3", "padto3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_last3_padto3_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_padto3_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_padto3_sortd([]) == [0, 0, 0]\nassert op_last3_padto3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_padto3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_padto3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_padto3_sortd([10]) == [10, 0, 0]\nassert op_last3_padto3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_padto3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_absval_len", "entry_point": "op_gt5_absval_len", "primitives": ["gt5", "absval", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then take the absolute value of each, then return how many remain.", "solution": "def op_gt5_absval_len(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [abs(x) for x in r]\n    return len(r)", "tests": "assert op_gt5_absval_len([1, 2, 3, 4]) == 0\nassert op_gt5_absval_len([]) == 0\nassert op_gt5_absval_len([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_absval_len([5, 5, 5]) == 0\nassert op_gt5_absval_len([3, 1, 2]) == 0\nassert op_gt5_absval_len([10]) == 1\nassert op_gt5_absval_len([2, 4, 6]) == 1\nassert op_gt5_absval_len([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_inc_haszero", "entry_point": "op_oremptyzero_inc_haszero", "primitives": ["oremptyzero", "inc", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each, then return whether the list contains a zero.", "solution": "def op_oremptyzero_inc_haszero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_oremptyzero_inc_haszero([1, 2, 3, 4]) == False\nassert op_oremptyzero_inc_haszero([]) == False\nassert op_oremptyzero_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_inc_haszero([5, 5, 5]) == False\nassert op_oremptyzero_inc_haszero([3, 1, 2]) == False\nassert op_oremptyzero_inc_haszero([10]) == False\nassert op_oremptyzero_inc_haszero([2, 4, 6]) == False\nassert op_oremptyzero_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_oremptyzero_alldistinct", "entry_point": "op_sorta_oremptyzero_alldistinct", "primitives": ["sorta", "oremptyzero", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then return whether all values are distinct.", "solution": "def op_sorta_oremptyzero_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    return len(r) == len(set(r))", "tests": "assert op_sorta_oremptyzero_alldistinct([1, 2, 3, 4]) == True\nassert op_sorta_oremptyzero_alldistinct([]) == True\nassert op_sorta_oremptyzero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sorta_oremptyzero_alldistinct([5, 5, 5]) == False\nassert op_sorta_oremptyzero_alldistinct([3, 1, 2]) == True\nassert op_sorta_oremptyzero_alldistinct([10]) == True\nassert op_sorta_oremptyzero_alldistinct([2, 4, 6]) == True\nassert op_sorta_oremptyzero_alldistinct([-7, 12, -7]) == False"}
{"id": "op_padto3_odds_square", "entry_point": "op_padto3_odds_square", "primitives": ["padto3", "odds", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the odd numbers, then square each.", "solution": "def op_padto3_odds_square(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_padto3_odds_square([1, 2, 3, 4]) == [1, 9]\nassert op_padto3_odds_square([]) == []\nassert op_padto3_odds_square([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_padto3_odds_square([5, 5, 5]) == [25, 25, 25]\nassert op_padto3_odds_square([3, 1, 2]) == [9, 1]\nassert op_padto3_odds_square([10]) == []\nassert op_padto3_odds_square([2, 4, 6]) == []\nassert op_padto3_odds_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_neg_first3_beforezero", "entry_point": "op_neg_first3_beforezero", "primitives": ["neg", "first3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three, then keep everything before the first zero.", "solution": "def op_neg_first3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_first3_beforezero([1, 2, 3, 4]) == []\nassert op_neg_first3_beforezero([]) == []\nassert op_neg_first3_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_first3_beforezero([5, 5, 5]) == []\nassert op_neg_first3_beforezero([3, 1, 2]) == []\nassert op_neg_first3_beforezero([10]) == []\nassert op_neg_first3_beforezero([2, 4, 6]) == []\nassert op_neg_first3_beforezero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_prefixup_nonempty_sortalpha", "entry_point": "op_prefixup_nonempty_sortalpha", "primitives": ["prefixup", "nonempty", "sortalpha"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop empty strings, then sort alphabetically.", "solution": "def op_prefixup_nonempty_sortalpha(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if s]\n    r = sorted(r)\n    return r", "tests": "assert op_prefixup_nonempty_sortalpha(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_nonempty_sortalpha([]) == []\nassert op_prefixup_nonempty_sortalpha(['  a ', '', 'BC', 'bc']) == ['#', '#  a ', '#BC', '#bc']\nassert op_prefixup_nonempty_sortalpha(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_prefixup_nonempty_sortalpha(['x']) == ['#x']\nassert op_prefixup_nonempty_sortalpha(['abc', 'de', '']) == ['#', '#abc', '#de']"}
{"id": "op_pos_uniq_rev", "entry_point": "op_pos_uniq_rev", "primitives": ["pos", "uniq", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_pos_uniq_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_uniq_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_uniq_rev([]) == []\nassert op_pos_uniq_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_uniq_rev([5, 5, 5]) == [5]\nassert op_pos_uniq_rev([3, 1, 2]) == [2, 1, 3]\nassert op_pos_uniq_rev([10]) == [10]\nassert op_pos_uniq_rev([2, 4, 6]) == [6, 4, 2]\nassert op_pos_uniq_rev([-7, 12, -7]) == [12]"}
{"id": "op_padto3_dec_prod", "entry_point": "op_padto3_dec_prod", "primitives": ["padto3", "dec", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then return their product.", "solution": "def op_padto3_dec_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_padto3_dec_prod([1, 2, 3, 4]) == 0\nassert op_padto3_dec_prod([]) == -1\nassert op_padto3_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_dec_prod([5, 5, 5]) == 64\nassert op_padto3_dec_prod([3, 1, 2]) == 0\nassert op_padto3_dec_prod([10]) == 9\nassert op_padto3_dec_prod([2, 4, 6]) == 15\nassert op_padto3_dec_prod([-7, 12, -7]) == 704"}
{"id": "op_double_square_allpos", "entry_point": "op_double_square_allpos", "primitives": ["double", "square", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then return whether all values are positive.", "solution": "def op_double_square_allpos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_double_square_allpos([1, 2, 3, 4]) == True\nassert op_double_square_allpos([]) == True\nassert op_double_square_allpos([-2, -1, 0, 1, 2]) == False\nassert op_double_square_allpos([5, 5, 5]) == True\nassert op_double_square_allpos([3, 1, 2]) == True\nassert op_double_square_allpos([10]) == True\nassert op_double_square_allpos([2, 4, 6]) == True\nassert op_double_square_allpos([-7, 12, -7]) == True"}
{"id": "op_rev_negate_len", "entry_point": "op_rev_negate_len", "primitives": ["rev", "negate", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then return how many remain.", "solution": "def op_rev_negate_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_rev_negate_len([1, 2, 3, 4]) == 4\nassert op_rev_negate_len([]) == 0\nassert op_rev_negate_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_negate_len([5, 5, 5]) == 3\nassert op_rev_negate_len([3, 1, 2]) == 3\nassert op_rev_negate_len([10]) == 1\nassert op_rev_negate_len([2, 4, 6]) == 3\nassert op_rev_negate_len([-7, 12, -7]) == 3"}
{"id": "op_div3_takewhilepos_first3", "entry_point": "op_div3_takewhilepos_first3", "primitives": ["div3", "takewhilepos", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then keep only the first three.", "solution": "def op_div3_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_div3_takewhilepos_first3([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos_first3([]) == []\nassert op_div3_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_first3([5, 5, 5]) == []\nassert op_div3_takewhilepos_first3([3, 1, 2]) == [3]\nassert op_div3_takewhilepos_first3([10]) == []\nassert op_div3_takewhilepos_first3([2, 4, 6]) == [6]\nassert op_div3_takewhilepos_first3([-7, 12, -7]) == [12]"}
{"id": "op_pos_uniq_alldistinct", "entry_point": "op_pos_uniq_alldistinct", "primitives": ["pos", "uniq", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then return whether all values are distinct.", "solution": "def op_pos_uniq_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return len(r) == len(set(r))", "tests": "assert op_pos_uniq_alldistinct([1, 2, 3, 4]) == True\nassert op_pos_uniq_alldistinct([]) == True\nassert op_pos_uniq_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_pos_uniq_alldistinct([5, 5, 5]) == True\nassert op_pos_uniq_alldistinct([3, 1, 2]) == True\nassert op_pos_uniq_alldistinct([10]) == True\nassert op_pos_uniq_alldistinct([2, 4, 6]) == True\nassert op_pos_uniq_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_square_haszero", "entry_point": "op_div3_square_haszero", "primitives": ["div3", "square", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then return whether the list contains a zero.", "solution": "def op_div3_square_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_div3_square_haszero([1, 2, 3, 4]) == False\nassert op_div3_square_haszero([]) == False\nassert op_div3_square_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_square_haszero([5, 5, 5]) == False\nassert op_div3_square_haszero([3, 1, 2]) == False\nassert op_div3_square_haszero([10]) == False\nassert op_div3_square_haszero([2, 4, 6]) == False\nassert op_div3_square_haszero([-7, 12, -7]) == False"}
{"id": "op_add10_rev_trimends", "entry_point": "op_add10_rev_trimends", "primitives": ["add10", "rev", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then reverse the order, then drop the first and last elements.", "solution": "def op_add10_rev_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(reversed(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_rev_trimends([1, 2, 3, 4]) == [13, 12]\nassert op_add10_rev_trimends([]) == []\nassert op_add10_rev_trimends([-2, -1, 0, 1, 2]) == [11, 10, 9]\nassert op_add10_rev_trimends([5, 5, 5]) == [15]\nassert op_add10_rev_trimends([3, 1, 2]) == [11]\nassert op_add10_rev_trimends([10]) == []\nassert op_add10_rev_trimends([2, 4, 6]) == [14]\nassert op_add10_rev_trimends([-7, 12, -7]) == [22]"}
{"id": "op_rev_oremptyzero_uniq", "entry_point": "op_rev_oremptyzero_uniq", "primitives": ["rev", "oremptyzero", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_rev_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_oremptyzero_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_uniq([]) == [0]\nassert op_rev_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_oremptyzero_uniq([5, 5, 5]) == [5]\nassert op_rev_oremptyzero_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_uniq([10]) == [10]\nassert op_rev_oremptyzero_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_first3_inc_issorted", "entry_point": "op_first3_inc_issorted", "primitives": ["first3", "inc", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then return whether the list is sorted ascending.", "solution": "def op_first3_inc_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_first3_inc_issorted([1, 2, 3, 4]) == True\nassert op_first3_inc_issorted([]) == True\nassert op_first3_inc_issorted([-2, -1, 0, 1, 2]) == True\nassert op_first3_inc_issorted([5, 5, 5]) == True\nassert op_first3_inc_issorted([3, 1, 2]) == False\nassert op_first3_inc_issorted([10]) == True\nassert op_first3_inc_issorted([2, 4, 6]) == True\nassert op_first3_inc_issorted([-7, 12, -7]) == False"}
{"id": "op_sortabs_sortd_padto3", "entry_point": "op_sortabs_sortd_padto3", "primitives": ["sortabs", "sortd", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort descending, then pad with zeros to at least three elements.", "solution": "def op_sortabs_sortd_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_sortd_padto3([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_sortd_padto3([]) == [0, 0, 0]\nassert op_sortabs_sortd_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortabs_sortd_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sortd_padto3([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_sortd_padto3([10]) == [10, 0, 0]\nassert op_sortabs_sortd_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_sortd_padto3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_trimends_anyeven", "entry_point": "op_gt5_trimends_anyeven", "primitives": ["gt5", "trimends", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then return whether any value is even.", "solution": "def op_gt5_trimends_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_trimends_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_trimends_anyeven([]) == False\nassert op_gt5_trimends_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_trimends_anyeven([5, 5, 5]) == False\nassert op_gt5_trimends_anyeven([3, 1, 2]) == False\nassert op_gt5_trimends_anyeven([10]) == False\nassert op_gt5_trimends_anyeven([2, 4, 6]) == False\nassert op_gt5_trimends_anyeven([-7, 12, -7]) == False"}
{"id": "op_double_pos_rev", "entry_point": "op_double_pos_rev", "primitives": ["double", "pos", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the positive numbers, then reverse the order.", "solution": "def op_double_pos_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_pos_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_pos_rev([]) == []\nassert op_double_pos_rev([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_double_pos_rev([5, 5, 5]) == [10, 10, 10]\nassert op_double_pos_rev([3, 1, 2]) == [4, 2, 6]\nassert op_double_pos_rev([10]) == [20]\nassert op_double_pos_rev([2, 4, 6]) == [12, 8, 4]\nassert op_double_pos_rev([-7, 12, -7]) == [24]"}
{"id": "op_oremptyzero_last3_trimends", "entry_point": "op_oremptyzero_last3_trimends", "primitives": ["oremptyzero", "last3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep only the last three, then drop the first and last elements.", "solution": "def op_oremptyzero_last3_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[-3:]\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_last3_trimends([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_last3_trimends([]) == []\nassert op_oremptyzero_last3_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_oremptyzero_last3_trimends([5, 5, 5]) == [5]\nassert op_oremptyzero_last3_trimends([3, 1, 2]) == [1]\nassert op_oremptyzero_last3_trimends([10]) == []\nassert op_oremptyzero_last3_trimends([2, 4, 6]) == [4]\nassert op_oremptyzero_last3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_odds_sorta_double", "entry_point": "op_odds_sorta_double", "primitives": ["odds", "sorta", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then double each.", "solution": "def op_odds_sorta_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_sorta_double([1, 2, 3, 4]) == [2, 6]\nassert op_odds_sorta_double([]) == []\nassert op_odds_sorta_double([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_odds_sorta_double([5, 5, 5]) == [10, 10, 10]\nassert op_odds_sorta_double([3, 1, 2]) == [2, 6]\nassert op_odds_sorta_double([10]) == []\nassert op_odds_sorta_double([2, 4, 6]) == []\nassert op_odds_sorta_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_rev_dropwhileneg_trimends", "entry_point": "op_rev_dropwhileneg_trimends", "primitives": ["rev", "dropwhileneg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_rev_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_dropwhileneg_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_rev_dropwhileneg_trimends([]) == []\nassert op_rev_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_rev_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_rev_dropwhileneg_trimends([3, 1, 2]) == [1]\nassert op_rev_dropwhileneg_trimends([10]) == []\nassert op_rev_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_rev_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_absval_firsteven", "entry_point": "op_sorta_absval_firsteven", "primitives": ["sorta", "absval", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_sorta_absval_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_absval_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_absval_firsteven([]) == 0\nassert op_sorta_absval_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_absval_firsteven([5, 5, 5]) == 0\nassert op_sorta_absval_firsteven([3, 1, 2]) == 2\nassert op_sorta_absval_firsteven([10]) == 10\nassert op_sorta_absval_firsteven([2, 4, 6]) == 2\nassert op_sorta_absval_firsteven([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_neg_dropzeros", "entry_point": "op_oremptyzero_neg_dropzeros", "primitives": ["oremptyzero", "neg", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the negative numbers, then drop the zeros.", "solution": "def op_oremptyzero_neg_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_neg_dropzeros([1, 2, 3, 4]) == []\nassert op_oremptyzero_neg_dropzeros([]) == []\nassert op_oremptyzero_neg_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_neg_dropzeros([5, 5, 5]) == []\nassert op_oremptyzero_neg_dropzeros([3, 1, 2]) == []\nassert op_oremptyzero_neg_dropzeros([10]) == []\nassert op_oremptyzero_neg_dropzeros([2, 4, 6]) == []\nassert op_oremptyzero_neg_dropzeros([-7, 12, -7]) == [-7, -7]"}
{"id": "op_double_dropfirst_sorta", "entry_point": "op_double_dropfirst_sorta", "primitives": ["double", "dropfirst", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then sort ascending.", "solution": "def op_double_dropfirst_sorta(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    r = sorted(r)\n    return r", "tests": "assert op_double_dropfirst_sorta([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst_sorta([]) == []\nassert op_double_dropfirst_sorta([-2, -1, 0, 1, 2]) == [-2, 0, 2, 4]\nassert op_double_dropfirst_sorta([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst_sorta([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst_sorta([10]) == []\nassert op_double_dropfirst_sorta([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst_sorta([-7, 12, -7]) == [-14, 24]"}
{"id": "op_uniq_inc_neg", "entry_point": "op_uniq_inc_neg", "primitives": ["uniq", "inc", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then keep the negative numbers.", "solution": "def op_uniq_inc_neg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_uniq_inc_neg([1, 2, 3, 4]) == []\nassert op_uniq_inc_neg([]) == []\nassert op_uniq_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_uniq_inc_neg([5, 5, 5]) == []\nassert op_uniq_inc_neg([3, 1, 2]) == []\nassert op_uniq_inc_neg([10]) == []\nassert op_uniq_inc_neg([2, 4, 6]) == []\nassert op_uniq_inc_neg([-7, 12, -7]) == [-6]"}
{"id": "op_upper_sortalpha_lower", "entry_point": "op_upper_sortalpha_lower", "primitives": ["upper", "sortalpha", "lower"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort alphabetically, then lowercase each string.", "solution": "def op_upper_sortalpha_lower(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r)\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_upper_sortalpha_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_upper_sortalpha_lower([]) == []\nassert op_upper_sortalpha_lower(['  a ', '', 'BC', 'bc']) == ['', '  a ', 'bc', 'bc']\nassert op_upper_sortalpha_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_upper_sortalpha_lower(['x']) == ['x']\nassert op_upper_sortalpha_lower(['abc', 'de', '']) == ['', 'abc', 'de']"}
{"id": "op_takewhilepos_uniq_prod", "entry_point": "op_takewhilepos_uniq_prod", "primitives": ["takewhilepos", "uniq", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop duplicates keeping first occurrence, then return their product.", "solution": "def op_takewhilepos_uniq_prod(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_takewhilepos_uniq_prod([1, 2, 3, 4]) == 24\nassert op_takewhilepos_uniq_prod([]) == 1\nassert op_takewhilepos_uniq_prod([-2, -1, 0, 1, 2]) == 1\nassert op_takewhilepos_uniq_prod([5, 5, 5]) == 5\nassert op_takewhilepos_uniq_prod([3, 1, 2]) == 6\nassert op_takewhilepos_uniq_prod([10]) == 10\nassert op_takewhilepos_uniq_prod([2, 4, 6]) == 48\nassert op_takewhilepos_uniq_prod([-7, 12, -7]) == 1"}
{"id": "op_div3_rev_padto3", "entry_point": "op_div3_rev_padto3", "primitives": ["div3", "rev", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then pad with zeros to at least three elements.", "solution": "def op_div3_rev_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_rev_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_div3_rev_padto3([]) == [0, 0, 0]\nassert op_div3_rev_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_rev_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_rev_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_div3_rev_padto3([10]) == [0, 0, 0]\nassert op_div3_rev_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_div3_rev_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sortd_pos_dropwhileneg", "entry_point": "op_sortd_pos_dropwhileneg", "primitives": ["sortd", "pos", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then drop the leading negative values.", "solution": "def op_sortd_pos_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_pos_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_pos_dropwhileneg([]) == []\nassert op_sortd_pos_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_pos_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_pos_dropwhileneg([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_pos_dropwhileneg([10]) == [10]\nassert op_sortd_pos_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_pos_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_padto3_neg_sum", "entry_point": "op_padto3_neg_sum", "primitives": ["padto3", "neg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then return their sum.", "solution": "def op_padto3_neg_sum(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_padto3_neg_sum([1, 2, 3, 4]) == 0\nassert op_padto3_neg_sum([]) == 0\nassert op_padto3_neg_sum([-2, -1, 0, 1, 2]) == -3\nassert op_padto3_neg_sum([5, 5, 5]) == 0\nassert op_padto3_neg_sum([3, 1, 2]) == 0\nassert op_padto3_neg_sum([10]) == 0\nassert op_padto3_neg_sum([2, 4, 6]) == 0\nassert op_padto3_neg_sum([-7, 12, -7]) == -14"}
{"id": "op_sorta_oremptyzero_counteven", "entry_point": "op_sorta_oremptyzero_counteven", "primitives": ["sorta", "oremptyzero", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then return how many values are even.", "solution": "def op_sorta_oremptyzero_counteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sorta_oremptyzero_counteven([1, 2, 3, 4]) == 2\nassert op_sorta_oremptyzero_counteven([]) == 1\nassert op_sorta_oremptyzero_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_sorta_oremptyzero_counteven([5, 5, 5]) == 0\nassert op_sorta_oremptyzero_counteven([3, 1, 2]) == 1\nassert op_sorta_oremptyzero_counteven([10]) == 1\nassert op_sorta_oremptyzero_counteven([2, 4, 6]) == 3\nassert op_sorta_oremptyzero_counteven([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_add10_allpos", "entry_point": "op_oremptyzero_add10_allpos", "primitives": ["oremptyzero", "add10", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add ten to each, then return whether all values are positive.", "solution": "def op_oremptyzero_add10_allpos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_oremptyzero_add10_allpos([1, 2, 3, 4]) == True\nassert op_oremptyzero_add10_allpos([]) == True\nassert op_oremptyzero_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_add10_allpos([5, 5, 5]) == True\nassert op_oremptyzero_add10_allpos([3, 1, 2]) == True\nassert op_oremptyzero_add10_allpos([10]) == True\nassert op_oremptyzero_add10_allpos([2, 4, 6]) == True\nassert op_oremptyzero_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_clamp10_takewhilepos_max", "entry_point": "op_clamp10_takewhilepos_max", "primitives": ["clamp10", "takewhilepos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_clamp10_takewhilepos_max(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_clamp10_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_clamp10_takewhilepos_max([]) == 0\nassert op_clamp10_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_takewhilepos_max([5, 5, 5]) == 5\nassert op_clamp10_takewhilepos_max([3, 1, 2]) == 3\nassert op_clamp10_takewhilepos_max([10]) == 10\nassert op_clamp10_takewhilepos_max([2, 4, 6]) == 6\nassert op_clamp10_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_dropfirst_evens_sortd", "entry_point": "op_dropfirst_evens_sortd", "primitives": ["dropfirst", "evens", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then sort descending.", "solution": "def op_dropfirst_evens_sortd(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dropfirst_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_dropfirst_evens_sortd([]) == []\nassert op_dropfirst_evens_sortd([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_dropfirst_evens_sortd([5, 5, 5]) == []\nassert op_dropfirst_evens_sortd([3, 1, 2]) == [2]\nassert op_dropfirst_evens_sortd([10]) == []\nassert op_dropfirst_evens_sortd([2, 4, 6]) == [6, 4]\nassert op_dropfirst_evens_sortd([-7, 12, -7]) == [12]"}
{"id": "op_inc_absval_negate", "entry_point": "op_inc_absval_negate", "primitives": ["inc", "absval", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each, then negate each.", "solution": "def op_inc_absval_negate(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_inc_absval_negate([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_inc_absval_negate([]) == []\nassert op_inc_absval_negate([-2, -1, 0, 1, 2]) == [-1, 0, -1, -2, -3]\nassert op_inc_absval_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_inc_absval_negate([3, 1, 2]) == [-4, -2, -3]\nassert op_inc_absval_negate([10]) == [-11]\nassert op_inc_absval_negate([2, 4, 6]) == [-3, -5, -7]\nassert op_inc_absval_negate([-7, 12, -7]) == [-6, -13, -6]"}
{"id": "op_dec_first3_absval", "entry_point": "op_dec_first3_absval", "primitives": ["dec", "first3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then take the absolute value of each.", "solution": "def op_dec_first3_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_first3_absval([1, 2, 3, 4]) == [0, 1, 2]\nassert op_dec_first3_absval([]) == []\nassert op_dec_first3_absval([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_dec_first3_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3_absval([3, 1, 2]) == [2, 0, 1]\nassert op_dec_first3_absval([10]) == [9]\nassert op_dec_first3_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3_absval([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_takewhilepos_absval_max", "entry_point": "op_takewhilepos_absval_max", "primitives": ["takewhilepos", "absval", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_takewhilepos_absval_max(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_takewhilepos_absval_max([1, 2, 3, 4]) == 4\nassert op_takewhilepos_absval_max([]) == 0\nassert op_takewhilepos_absval_max([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_absval_max([5, 5, 5]) == 5\nassert op_takewhilepos_absval_max([3, 1, 2]) == 3\nassert op_takewhilepos_absval_max([10]) == 10\nassert op_takewhilepos_absval_max([2, 4, 6]) == 6\nassert op_takewhilepos_absval_max([-7, 12, -7]) == 0"}
{"id": "op_add10_gt5_dropwhileneg", "entry_point": "op_add10_gt5_dropwhileneg", "primitives": ["add10", "gt5", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then drop the leading negative values.", "solution": "def op_add10_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_add10_gt5_dropwhileneg([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_gt5_dropwhileneg([]) == []\nassert op_add10_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_gt5_dropwhileneg([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5_dropwhileneg([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5_dropwhileneg([10]) == [20]\nassert op_add10_gt5_dropwhileneg([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5_dropwhileneg([-7, 12, -7]) == [22]"}
{"id": "op_add10_sortabs_min", "entry_point": "op_add10_sortabs_min", "primitives": ["add10", "sortabs", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then return the minimum (0 if empty).", "solution": "def op_add10_sortabs_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return min(r) if r else 0", "tests": "assert op_add10_sortabs_min([1, 2, 3, 4]) == 11\nassert op_add10_sortabs_min([]) == 0\nassert op_add10_sortabs_min([-2, -1, 0, 1, 2]) == 8\nassert op_add10_sortabs_min([5, 5, 5]) == 15\nassert op_add10_sortabs_min([3, 1, 2]) == 11\nassert op_add10_sortabs_min([10]) == 20\nassert op_add10_sortabs_min([2, 4, 6]) == 12\nassert op_add10_sortabs_min([-7, 12, -7]) == 3"}
{"id": "op_negate_dropzeros_odds", "entry_point": "op_negate_dropzeros_odds", "primitives": ["negate", "dropzeros", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then keep the odd numbers.", "solution": "def op_negate_dropzeros_odds(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_negate_dropzeros_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_negate_dropzeros_odds([]) == []\nassert op_negate_dropzeros_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_dropzeros_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_dropzeros_odds([3, 1, 2]) == [-3, -1]\nassert op_negate_dropzeros_odds([10]) == []\nassert op_negate_dropzeros_odds([2, 4, 6]) == []\nassert op_negate_dropzeros_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_beforezero_sortd_sortabs", "entry_point": "op_beforezero_sortd_sortabs", "primitives": ["beforezero", "sortd", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort descending, then sort by absolute value.", "solution": "def op_beforezero_sortd_sortabs(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_beforezero_sortd_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sortd_sortabs([]) == []\nassert op_beforezero_sortd_sortabs([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortd_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortd_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortd_sortabs([10]) == [10]\nassert op_beforezero_sortd_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortd_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dropzeros_padto3_anyeven", "entry_point": "op_dropzeros_padto3_anyeven", "primitives": ["dropzeros", "padto3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_dropzeros_padto3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_padto3_anyeven([]) == True\nassert op_dropzeros_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_padto3_anyeven([5, 5, 5]) == False\nassert op_dropzeros_padto3_anyeven([3, 1, 2]) == True\nassert op_dropzeros_padto3_anyeven([10]) == True\nassert op_dropzeros_padto3_anyeven([2, 4, 6]) == True\nassert op_dropzeros_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_rev_dec_beforezero", "entry_point": "op_rev_dec_beforezero", "primitives": ["rev", "dec", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then subtract one from each, then keep everything before the first zero.", "solution": "def op_rev_dec_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_dec_beforezero([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_dec_beforezero([]) == []\nassert op_rev_dec_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_rev_dec_beforezero([5, 5, 5]) == [4, 4, 4]\nassert op_rev_dec_beforezero([3, 1, 2]) == [1]\nassert op_rev_dec_beforezero([10]) == [9]\nassert op_rev_dec_beforezero([2, 4, 6]) == [5, 3, 1]\nassert op_rev_dec_beforezero([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_rev_beforezero_pos", "entry_point": "op_rev_beforezero_pos", "primitives": ["rev", "beforezero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then keep the positive numbers.", "solution": "def op_rev_beforezero_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_beforezero_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_beforezero_pos([]) == []\nassert op_rev_beforezero_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_beforezero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_beforezero_pos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_beforezero_pos([10]) == [10]\nassert op_rev_beforezero_pos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_beforezero_pos([-7, 12, -7]) == [12]"}
{"id": "op_add10_neg_inc", "entry_point": "op_add10_neg_inc", "primitives": ["add10", "neg", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then add one to each.", "solution": "def op_add10_neg_inc(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_add10_neg_inc([1, 2, 3, 4]) == []\nassert op_add10_neg_inc([]) == []\nassert op_add10_neg_inc([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_inc([5, 5, 5]) == []\nassert op_add10_neg_inc([3, 1, 2]) == []\nassert op_add10_neg_inc([10]) == []\nassert op_add10_neg_inc([2, 4, 6]) == []\nassert op_add10_neg_inc([-7, 12, -7]) == []"}
{"id": "op_first3_takewhilepos_dec", "entry_point": "op_first3_takewhilepos_dec", "primitives": ["first3", "takewhilepos", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then subtract one from each.", "solution": "def op_first3_takewhilepos_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_takewhilepos_dec([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_takewhilepos_dec([]) == []\nassert op_first3_takewhilepos_dec([-2, -1, 0, 1, 2]) == []\nassert op_first3_takewhilepos_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_takewhilepos_dec([3, 1, 2]) == [2, 0, 1]\nassert op_first3_takewhilepos_dec([10]) == [9]\nassert op_first3_takewhilepos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_first3_takewhilepos_dec([-7, 12, -7]) == []"}
{"id": "op_square_dec_gt5", "entry_point": "op_square_dec_gt5", "primitives": ["square", "dec", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each, then keep values greater than five.", "solution": "def op_square_dec_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_dec_gt5([1, 2, 3, 4]) == [8, 15]\nassert op_square_dec_gt5([]) == []\nassert op_square_dec_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_dec_gt5([5, 5, 5]) == [24, 24, 24]\nassert op_square_dec_gt5([3, 1, 2]) == [8]\nassert op_square_dec_gt5([10]) == [99]\nassert op_square_dec_gt5([2, 4, 6]) == [15, 35]\nassert op_square_dec_gt5([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_sorta_clamp10_absval", "entry_point": "op_sorta_clamp10_absval", "primitives": ["sorta", "clamp10", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cap each value at 10, then take the absolute value of each.", "solution": "def op_sorta_clamp10_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_clamp10_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_clamp10_absval([]) == []\nassert op_sorta_clamp10_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_clamp10_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_clamp10_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_clamp10_absval([10]) == [10]\nassert op_sorta_clamp10_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_clamp10_absval([-7, 12, -7]) == [7, 7, 10]"}
{"id": "op_sortd_dropzeros_prod", "entry_point": "op_sortd_dropzeros_prod", "primitives": ["sortd", "dropzeros", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then return their product.", "solution": "def op_sortd_dropzeros_prod(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_sortd_dropzeros_prod([1, 2, 3, 4]) == 24\nassert op_sortd_dropzeros_prod([]) == 1\nassert op_sortd_dropzeros_prod([-2, -1, 0, 1, 2]) == 4\nassert op_sortd_dropzeros_prod([5, 5, 5]) == 125\nassert op_sortd_dropzeros_prod([3, 1, 2]) == 6\nassert op_sortd_dropzeros_prod([10]) == 10\nassert op_sortd_dropzeros_prod([2, 4, 6]) == 48\nassert op_sortd_dropzeros_prod([-7, 12, -7]) == 588"}
{"id": "op_neg_odds_firsteven", "entry_point": "op_neg_odds_firsteven", "primitives": ["neg", "odds", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_neg_odds_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_neg_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_neg_odds_firsteven([]) == 0\nassert op_neg_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_neg_odds_firsteven([5, 5, 5]) == 0\nassert op_neg_odds_firsteven([3, 1, 2]) == 0\nassert op_neg_odds_firsteven([10]) == 0\nassert op_neg_odds_firsteven([2, 4, 6]) == 0\nassert op_neg_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_sortabs_sorta_clamp10", "entry_point": "op_sortabs_sorta_clamp10", "primitives": ["sortabs", "sorta", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then cap each value at 10.", "solution": "def op_sortabs_sorta_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_sorta_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_sorta_clamp10([]) == []\nassert op_sortabs_sorta_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortabs_sorta_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_sorta_clamp10([10]) == [10]\nassert op_sortabs_sorta_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_sorta_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_sortalpha_sortlen_joinc", "entry_point": "op_sortalpha_sortlen_joinc", "primitives": ["sortalpha", "sortlen", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then sort by length, shortest first, then join them with commas.", "solution": "def op_sortalpha_sortlen_joinc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=len)\n    return ','.join(r)", "tests": "assert op_sortalpha_sortlen_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortalpha_sortlen_joinc([]) == ''\nassert op_sortalpha_sortlen_joinc(['  a ', '', 'BC', 'bc']) == ',BC,bc,  a '\nassert op_sortalpha_sortlen_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_sortalpha_sortlen_joinc(['x']) == 'x'\nassert op_sortalpha_sortlen_joinc(['abc', 'de', '']) == ',de,abc'"}
{"id": "op_takewhilepos_sorta_alldistinct", "entry_point": "op_takewhilepos_sorta_alldistinct", "primitives": ["takewhilepos", "sorta", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort ascending, then return whether all values are distinct.", "solution": "def op_takewhilepos_sorta_alldistinct(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return len(r) == len(set(r))", "tests": "assert op_takewhilepos_sorta_alldistinct([1, 2, 3, 4]) == True\nassert op_takewhilepos_sorta_alldistinct([]) == True\nassert op_takewhilepos_sorta_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_sorta_alldistinct([5, 5, 5]) == False\nassert op_takewhilepos_sorta_alldistinct([3, 1, 2]) == True\nassert op_takewhilepos_sorta_alldistinct([10]) == True\nassert op_takewhilepos_sorta_alldistinct([2, 4, 6]) == True\nassert op_takewhilepos_sorta_alldistinct([-7, 12, -7]) == True"}
{"id": "op_pos_sortabs_negate", "entry_point": "op_pos_sortabs_negate", "primitives": ["pos", "sortabs", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort by absolute value, then negate each.", "solution": "def op_pos_sortabs_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_sortabs_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_sortabs_negate([]) == []\nassert op_pos_sortabs_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_sortabs_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_sortabs_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_pos_sortabs_negate([10]) == [-10]\nassert op_pos_sortabs_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_sortabs_negate([-7, 12, -7]) == [-12]"}
{"id": "op_last3_odds_issorted", "entry_point": "op_last3_odds_issorted", "primitives": ["last3", "odds", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the odd numbers, then return whether the list is sorted ascending.", "solution": "def op_last3_odds_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r == sorted(r)", "tests": "assert op_last3_odds_issorted([1, 2, 3, 4]) == True\nassert op_last3_odds_issorted([]) == True\nassert op_last3_odds_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_odds_issorted([5, 5, 5]) == True\nassert op_last3_odds_issorted([3, 1, 2]) == False\nassert op_last3_odds_issorted([10]) == True\nassert op_last3_odds_issorted([2, 4, 6]) == True\nassert op_last3_odds_issorted([-7, 12, -7]) == True"}
{"id": "op_rev_square_max", "entry_point": "op_rev_square_max", "primitives": ["rev", "square", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then return the maximum (0 if empty).", "solution": "def op_rev_square_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_rev_square_max([1, 2, 3, 4]) == 16\nassert op_rev_square_max([]) == 0\nassert op_rev_square_max([-2, -1, 0, 1, 2]) == 4\nassert op_rev_square_max([5, 5, 5]) == 25\nassert op_rev_square_max([3, 1, 2]) == 9\nassert op_rev_square_max([10]) == 100\nassert op_rev_square_max([2, 4, 6]) == 36\nassert op_rev_square_max([-7, 12, -7]) == 144"}
{"id": "op_double_negate_sum", "entry_point": "op_double_negate_sum", "primitives": ["double", "negate", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then return their sum.", "solution": "def op_double_negate_sum(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_double_negate_sum([1, 2, 3, 4]) == -20\nassert op_double_negate_sum([]) == 0\nassert op_double_negate_sum([-2, -1, 0, 1, 2]) == 0\nassert op_double_negate_sum([5, 5, 5]) == -30\nassert op_double_negate_sum([3, 1, 2]) == -12\nassert op_double_negate_sum([10]) == -20\nassert op_double_negate_sum([2, 4, 6]) == -24\nassert op_double_negate_sum([-7, 12, -7]) == 4"}
{"id": "op_gt5_negate_sortd", "entry_point": "op_gt5_negate_sortd", "primitives": ["gt5", "negate", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then sort descending.", "solution": "def op_gt5_negate_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_negate_sortd([1, 2, 3, 4]) == []\nassert op_gt5_negate_sortd([]) == []\nassert op_gt5_negate_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_negate_sortd([5, 5, 5]) == []\nassert op_gt5_negate_sortd([3, 1, 2]) == []\nassert op_gt5_negate_sortd([10]) == [-10]\nassert op_gt5_negate_sortd([2, 4, 6]) == [-6]\nassert op_gt5_negate_sortd([-7, 12, -7]) == [-12]"}
{"id": "op_clamp10_gt5_min", "entry_point": "op_clamp10_gt5_min", "primitives": ["clamp10", "gt5", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep values greater than five, then return the minimum (0 if empty).", "solution": "def op_clamp10_gt5_min(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return min(r) if r else 0", "tests": "assert op_clamp10_gt5_min([1, 2, 3, 4]) == 0\nassert op_clamp10_gt5_min([]) == 0\nassert op_clamp10_gt5_min([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_gt5_min([5, 5, 5]) == 0\nassert op_clamp10_gt5_min([3, 1, 2]) == 0\nassert op_clamp10_gt5_min([10]) == 10\nassert op_clamp10_gt5_min([2, 4, 6]) == 6\nassert op_clamp10_gt5_min([-7, 12, -7]) == 10"}
{"id": "op_sorta_first3_clamp10", "entry_point": "op_sorta_first3_clamp10", "primitives": ["sorta", "first3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the first three, then cap each value at 10.", "solution": "def op_sorta_first3_clamp10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sorta_first3_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_first3_clamp10([]) == []\nassert op_sorta_first3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_sorta_first3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_first3_clamp10([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_first3_clamp10([10]) == [10]\nassert op_sorta_first3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_first3_clamp10([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_odds_div3_double", "entry_point": "op_odds_div3_double", "primitives": ["odds", "div3", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then double each.", "solution": "def op_odds_div3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_div3_double([1, 2, 3, 4]) == [6]\nassert op_odds_div3_double([]) == []\nassert op_odds_div3_double([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_double([5, 5, 5]) == []\nassert op_odds_div3_double([3, 1, 2]) == [6]\nassert op_odds_div3_double([10]) == []\nassert op_odds_div3_double([2, 4, 6]) == []\nassert op_odds_div3_double([-7, 12, -7]) == []"}
{"id": "op_dropzeros_odds_sortabs", "entry_point": "op_dropzeros_odds_sortabs", "primitives": ["dropzeros", "odds", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then sort by absolute value.", "solution": "def op_dropzeros_odds_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_odds_sortabs([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds_sortabs([]) == []\nassert op_dropzeros_odds_sortabs([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_odds_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_sortabs([3, 1, 2]) == [1, 3]\nassert op_dropzeros_odds_sortabs([10]) == []\nassert op_dropzeros_odds_sortabs([2, 4, 6]) == []\nassert op_dropzeros_odds_sortabs([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_inc_sortabs", "entry_point": "op_div3_inc_sortabs", "primitives": ["div3", "inc", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add one to each, then sort by absolute value.", "solution": "def op_div3_inc_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_div3_inc_sortabs([1, 2, 3, 4]) == [4]\nassert op_div3_inc_sortabs([]) == []\nassert op_div3_inc_sortabs([-2, -1, 0, 1, 2]) == [1]\nassert op_div3_inc_sortabs([5, 5, 5]) == []\nassert op_div3_inc_sortabs([3, 1, 2]) == [4]\nassert op_div3_inc_sortabs([10]) == []\nassert op_div3_inc_sortabs([2, 4, 6]) == [7]\nassert op_div3_inc_sortabs([-7, 12, -7]) == [13]"}
{"id": "op_sortalpha_uniqs_lens", "entry_point": "op_sortalpha_uniqs_lens", "primitives": ["sortalpha", "uniqs", "lens"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then return the total number of characters.", "solution": "def op_sortalpha_uniqs_lens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return sum(len(s) for s in r)", "tests": "assert op_sortalpha_uniqs_lens(['Hello', 'world']) == 10\nassert op_sortalpha_uniqs_lens([]) == 0\nassert op_sortalpha_uniqs_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_sortalpha_uniqs_lens(['one', 'one', 'Two']) == 6\nassert op_sortalpha_uniqs_lens(['x']) == 1\nassert op_sortalpha_uniqs_lens(['abc', 'de', '']) == 5"}
{"id": "op_double_evens_min", "entry_point": "op_double_evens_min", "primitives": ["double", "evens", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_double_evens_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_double_evens_min([1, 2, 3, 4]) == 2\nassert op_double_evens_min([]) == 0\nassert op_double_evens_min([-2, -1, 0, 1, 2]) == -4\nassert op_double_evens_min([5, 5, 5]) == 10\nassert op_double_evens_min([3, 1, 2]) == 2\nassert op_double_evens_min([10]) == 20\nassert op_double_evens_min([2, 4, 6]) == 4\nassert op_double_evens_min([-7, 12, -7]) == -14"}
{"id": "op_pos_odds_dropzeros", "entry_point": "op_pos_odds_dropzeros", "primitives": ["pos", "odds", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then drop the zeros.", "solution": "def op_pos_odds_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_odds_dropzeros([1, 2, 3, 4]) == [1, 3]\nassert op_pos_odds_dropzeros([]) == []\nassert op_pos_odds_dropzeros([-2, -1, 0, 1, 2]) == [1]\nassert op_pos_odds_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_pos_odds_dropzeros([3, 1, 2]) == [3, 1]\nassert op_pos_odds_dropzeros([10]) == []\nassert op_pos_odds_dropzeros([2, 4, 6]) == []\nassert op_pos_odds_dropzeros([-7, 12, -7]) == []"}
{"id": "op_sortd_square_first3", "entry_point": "op_sortd_square_first3", "primitives": ["sortd", "square", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then keep only the first three.", "solution": "def op_sortd_square_first3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_sortd_square_first3([1, 2, 3, 4]) == [16, 9, 4]\nassert op_sortd_square_first3([]) == []\nassert op_sortd_square_first3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_sortd_square_first3([5, 5, 5]) == [25, 25, 25]\nassert op_sortd_square_first3([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_square_first3([10]) == [100]\nassert op_sortd_square_first3([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square_first3([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_takewhilepos_clamp10_trimends", "entry_point": "op_takewhilepos_clamp10_trimends", "primitives": ["takewhilepos", "clamp10", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cap each value at 10, then drop the first and last elements.", "solution": "def op_takewhilepos_clamp10_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_clamp10_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_takewhilepos_clamp10_trimends([]) == []\nassert op_takewhilepos_clamp10_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_clamp10_trimends([5, 5, 5]) == [5]\nassert op_takewhilepos_clamp10_trimends([3, 1, 2]) == [1]\nassert op_takewhilepos_clamp10_trimends([10]) == []\nassert op_takewhilepos_clamp10_trimends([2, 4, 6]) == [4]\nassert op_takewhilepos_clamp10_trimends([-7, 12, -7]) == []"}
{"id": "op_first3_double_haszero", "entry_point": "op_first3_double_haszero", "primitives": ["first3", "double", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then return whether the list contains a zero.", "solution": "def op_first3_double_haszero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_first3_double_haszero([1, 2, 3, 4]) == False\nassert op_first3_double_haszero([]) == False\nassert op_first3_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_first3_double_haszero([5, 5, 5]) == False\nassert op_first3_double_haszero([3, 1, 2]) == False\nassert op_first3_double_haszero([10]) == False\nassert op_first3_double_haszero([2, 4, 6]) == False\nassert op_first3_double_haszero([-7, 12, -7]) == False"}
{"id": "op_inc_double_div3", "entry_point": "op_inc_double_div3", "primitives": ["inc", "double", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then keep multiples of three.", "solution": "def op_inc_double_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_double_div3([1, 2, 3, 4]) == [6]\nassert op_inc_double_div3([]) == []\nassert op_inc_double_div3([-2, -1, 0, 1, 2]) == [0, 6]\nassert op_inc_double_div3([5, 5, 5]) == [12, 12, 12]\nassert op_inc_double_div3([3, 1, 2]) == [6]\nassert op_inc_double_div3([10]) == []\nassert op_inc_double_div3([2, 4, 6]) == [6]\nassert op_inc_double_div3([-7, 12, -7]) == [-12, -12]"}
{"id": "op_last3_add10_min", "entry_point": "op_last3_add10_min", "primitives": ["last3", "add10", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_last3_add10_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_last3_add10_min([1, 2, 3, 4]) == 12\nassert op_last3_add10_min([]) == 0\nassert op_last3_add10_min([-2, -1, 0, 1, 2]) == 10\nassert op_last3_add10_min([5, 5, 5]) == 15\nassert op_last3_add10_min([3, 1, 2]) == 11\nassert op_last3_add10_min([10]) == 20\nassert op_last3_add10_min([2, 4, 6]) == 12\nassert op_last3_add10_min([-7, 12, -7]) == 3"}
{"id": "op_first3_sortd_add10", "entry_point": "op_first3_sortd_add10", "primitives": ["first3", "sortd", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then add ten to each.", "solution": "def op_first3_sortd_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_sortd_add10([1, 2, 3, 4]) == [13, 12, 11]\nassert op_first3_sortd_add10([]) == []\nassert op_first3_sortd_add10([-2, -1, 0, 1, 2]) == [10, 9, 8]\nassert op_first3_sortd_add10([5, 5, 5]) == [15, 15, 15]\nassert op_first3_sortd_add10([3, 1, 2]) == [13, 12, 11]\nassert op_first3_sortd_add10([10]) == [20]\nassert op_first3_sortd_add10([2, 4, 6]) == [16, 14, 12]\nassert op_first3_sortd_add10([-7, 12, -7]) == [22, 3, 3]"}
{"id": "op_add10_trimends_firsteven", "entry_point": "op_add10_trimends_firsteven", "primitives": ["add10", "trimends", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_add10_trimends_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_trimends_firsteven([1, 2, 3, 4]) == 12\nassert op_add10_trimends_firsteven([]) == 0\nassert op_add10_trimends_firsteven([-2, -1, 0, 1, 2]) == 10\nassert op_add10_trimends_firsteven([5, 5, 5]) == 0\nassert op_add10_trimends_firsteven([3, 1, 2]) == 0\nassert op_add10_trimends_firsteven([10]) == 0\nassert op_add10_trimends_firsteven([2, 4, 6]) == 14\nassert op_add10_trimends_firsteven([-7, 12, -7]) == 22"}
{"id": "op_sortalpha_dropshort_upper", "entry_point": "op_sortalpha_dropshort_upper", "primitives": ["sortalpha", "dropshort", "upper"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop strings shorter than three characters, then uppercase each string.", "solution": "def op_sortalpha_dropshort_upper(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_sortalpha_dropshort_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortalpha_dropshort_upper([]) == []\nassert op_sortalpha_dropshort_upper(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_sortalpha_dropshort_upper(['one', 'one', 'Two']) == ['TWO', 'ONE', 'ONE']\nassert op_sortalpha_dropshort_upper(['x']) == []\nassert op_sortalpha_dropshort_upper(['abc', 'de', '']) == ['ABC']"}
{"id": "op_neg_square_last3", "entry_point": "op_neg_square_last3", "primitives": ["neg", "square", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then square each, then keep only the last three.", "solution": "def op_neg_square_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_neg_square_last3([1, 2, 3, 4]) == []\nassert op_neg_square_last3([]) == []\nassert op_neg_square_last3([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_neg_square_last3([5, 5, 5]) == []\nassert op_neg_square_last3([3, 1, 2]) == []\nassert op_neg_square_last3([10]) == []\nassert op_neg_square_last3([2, 4, 6]) == []\nassert op_neg_square_last3([-7, 12, -7]) == [49, 49]"}
{"id": "op_dropfirst_oremptyzero_padto3", "entry_point": "op_dropfirst_oremptyzero_padto3", "primitives": ["dropfirst", "oremptyzero", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_oremptyzero_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_dropfirst_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_oremptyzero_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_oremptyzero_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_oremptyzero_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_oremptyzero_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_oremptyzero_padto3([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_beforezero_dec_pos", "entry_point": "op_beforezero_dec_pos", "primitives": ["beforezero", "dec", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then keep the positive numbers.", "solution": "def op_beforezero_dec_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_dec_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_dec_pos([]) == []\nassert op_beforezero_dec_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_dec_pos([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dec_pos([3, 1, 2]) == [2, 1]\nassert op_beforezero_dec_pos([10]) == [9]\nassert op_beforezero_dec_pos([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_dec_pos([-7, 12, -7]) == [11]"}
{"id": "op_first3_clamp10_last3", "entry_point": "op_first3_clamp10_last3", "primitives": ["first3", "clamp10", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then keep only the last three.", "solution": "def op_first3_clamp10_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_clamp10_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10_last3([]) == []\nassert op_first3_clamp10_last3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_clamp10_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_clamp10_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_clamp10_last3([10]) == [10]\nassert op_first3_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10_last3([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_evens_sortd_min", "entry_point": "op_evens_sortd_min", "primitives": ["evens", "sortd", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then return the minimum (0 if empty).", "solution": "def op_evens_sortd_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_evens_sortd_min([1, 2, 3, 4]) == 2\nassert op_evens_sortd_min([]) == 0\nassert op_evens_sortd_min([-2, -1, 0, 1, 2]) == -2\nassert op_evens_sortd_min([5, 5, 5]) == 0\nassert op_evens_sortd_min([3, 1, 2]) == 2\nassert op_evens_sortd_min([10]) == 10\nassert op_evens_sortd_min([2, 4, 6]) == 2\nassert op_evens_sortd_min([-7, 12, -7]) == 12"}
{"id": "op_evens_double_dropwhileneg", "entry_point": "op_evens_double_dropwhileneg", "primitives": ["evens", "double", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then drop the leading negative values.", "solution": "def op_evens_double_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_evens_double_dropwhileneg([1, 2, 3, 4]) == [4, 8]\nassert op_evens_double_dropwhileneg([]) == []\nassert op_evens_double_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_evens_double_dropwhileneg([5, 5, 5]) == []\nassert op_evens_double_dropwhileneg([3, 1, 2]) == [4]\nassert op_evens_double_dropwhileneg([10]) == [20]\nassert op_evens_double_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_evens_double_dropwhileneg([-7, 12, -7]) == [24]"}
{"id": "op_odds_evens_beforezero", "entry_point": "op_odds_evens_beforezero", "primitives": ["odds", "evens", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_odds_evens_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_odds_evens_beforezero([1, 2, 3, 4]) == []\nassert op_odds_evens_beforezero([]) == []\nassert op_odds_evens_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_beforezero([5, 5, 5]) == []\nassert op_odds_evens_beforezero([3, 1, 2]) == []\nassert op_odds_evens_beforezero([10]) == []\nassert op_odds_evens_beforezero([2, 4, 6]) == []\nassert op_odds_evens_beforezero([-7, 12, -7]) == []"}
{"id": "op_sortage_ages_issorted", "entry_point": "op_sortage_ages_issorted", "primitives": ["sortage", "ages", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then return whether the list is sorted ascending.", "solution": "def op_sortage_ages_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    return r == sorted(r)", "tests": "assert op_sortage_ages_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_sortage_ages_issorted([]) == True\nassert op_sortage_ages_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_sortage_ages_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_pos_div3_takewhilepos", "entry_point": "op_pos_div3_takewhilepos", "primitives": ["pos", "div3", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep multiples of three, then take values while they are positive.", "solution": "def op_pos_div3_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_pos_div3_takewhilepos([1, 2, 3, 4]) == [3]\nassert op_pos_div3_takewhilepos([]) == []\nassert op_pos_div3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_pos_div3_takewhilepos([5, 5, 5]) == []\nassert op_pos_div3_takewhilepos([3, 1, 2]) == [3]\nassert op_pos_div3_takewhilepos([10]) == []\nassert op_pos_div3_takewhilepos([2, 4, 6]) == [6]\nassert op_pos_div3_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_sorta_absval", "entry_point": "op_dropfirst_sorta_absval", "primitives": ["dropfirst", "sorta", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then take the absolute value of each.", "solution": "def op_dropfirst_sorta_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_sorta_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sorta_absval([]) == []\nassert op_dropfirst_sorta_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2]\nassert op_dropfirst_sorta_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sorta_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sorta_absval([10]) == []\nassert op_dropfirst_sorta_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sorta_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_evens_sortabs_square", "entry_point": "op_evens_sortabs_square", "primitives": ["evens", "sortabs", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then square each.", "solution": "def op_evens_sortabs_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_evens_sortabs_square([1, 2, 3, 4]) == [4, 16]\nassert op_evens_sortabs_square([]) == []\nassert op_evens_sortabs_square([-2, -1, 0, 1, 2]) == [0, 4, 4]\nassert op_evens_sortabs_square([5, 5, 5]) == []\nassert op_evens_sortabs_square([3, 1, 2]) == [4]\nassert op_evens_sortabs_square([10]) == [100]\nassert op_evens_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_evens_sortabs_square([-7, 12, -7]) == [144]"}
{"id": "op_absval_trimends_dropfirst", "entry_point": "op_absval_trimends_dropfirst", "primitives": ["absval", "trimends", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first and last elements, then drop the first element.", "solution": "def op_absval_trimends_dropfirst(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_absval_trimends_dropfirst([1, 2, 3, 4]) == [3]\nassert op_absval_trimends_dropfirst([]) == []\nassert op_absval_trimends_dropfirst([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_absval_trimends_dropfirst([5, 5, 5]) == []\nassert op_absval_trimends_dropfirst([3, 1, 2]) == []\nassert op_absval_trimends_dropfirst([10]) == []\nassert op_absval_trimends_dropfirst([2, 4, 6]) == []\nassert op_absval_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_odds_sortabs_absval", "entry_point": "op_odds_sortabs_absval", "primitives": ["odds", "sortabs", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then take the absolute value of each.", "solution": "def op_odds_sortabs_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_sortabs_absval([1, 2, 3, 4]) == [1, 3]\nassert op_odds_sortabs_absval([]) == []\nassert op_odds_sortabs_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_sortabs_absval([5, 5, 5]) == [5, 5, 5]\nassert op_odds_sortabs_absval([3, 1, 2]) == [1, 3]\nassert op_odds_sortabs_absval([10]) == []\nassert op_odds_sortabs_absval([2, 4, 6]) == []\nassert op_odds_sortabs_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_trimends_dec_dropfirst", "entry_point": "op_trimends_dec_dropfirst", "primitives": ["trimends", "dec", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then drop the first element.", "solution": "def op_trimends_dec_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_dec_dropfirst([1, 2, 3, 4]) == [2]\nassert op_trimends_dec_dropfirst([]) == []\nassert op_trimends_dec_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_trimends_dec_dropfirst([5, 5, 5]) == []\nassert op_trimends_dec_dropfirst([3, 1, 2]) == []\nassert op_trimends_dec_dropfirst([10]) == []\nassert op_trimends_dec_dropfirst([2, 4, 6]) == []\nassert op_trimends_dec_dropfirst([-7, 12, -7]) == []"}
{"id": "op_add10_negate_square", "entry_point": "op_add10_negate_square", "primitives": ["add10", "negate", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each, then square each.", "solution": "def op_add10_negate_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_negate_square([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_negate_square([]) == []\nassert op_add10_negate_square([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_negate_square([5, 5, 5]) == [225, 225, 225]\nassert op_add10_negate_square([3, 1, 2]) == [169, 121, 144]\nassert op_add10_negate_square([10]) == [400]\nassert op_add10_negate_square([2, 4, 6]) == [144, 196, 256]\nassert op_add10_negate_square([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_evens_last3_allpos", "entry_point": "op_evens_last3_allpos", "primitives": ["evens", "last3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the last three, then return whether all values are positive.", "solution": "def op_evens_last3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_last3_allpos([1, 2, 3, 4]) == True\nassert op_evens_last3_allpos([]) == True\nassert op_evens_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_last3_allpos([5, 5, 5]) == True\nassert op_evens_last3_allpos([3, 1, 2]) == True\nassert op_evens_last3_allpos([10]) == True\nassert op_evens_last3_allpos([2, 4, 6]) == True\nassert op_evens_last3_allpos([-7, 12, -7]) == True"}
{"id": "op_trimends_add10_padto3", "entry_point": "op_trimends_add10_padto3", "primitives": ["trimends", "add10", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_trimends_add10_padto3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_trimends_add10_padto3([1, 2, 3, 4]) == [12, 13, 0]\nassert op_trimends_add10_padto3([]) == [0, 0, 0]\nassert op_trimends_add10_padto3([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_trimends_add10_padto3([5, 5, 5]) == [15, 0, 0]\nassert op_trimends_add10_padto3([3, 1, 2]) == [11, 0, 0]\nassert op_trimends_add10_padto3([10]) == [0, 0, 0]\nassert op_trimends_add10_padto3([2, 4, 6]) == [14, 0, 0]\nassert op_trimends_add10_padto3([-7, 12, -7]) == [22, 0, 0]"}
{"id": "op_square_pos_prod", "entry_point": "op_square_pos_prod", "primitives": ["square", "pos", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then return their product.", "solution": "def op_square_pos_prod(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_square_pos_prod([1, 2, 3, 4]) == 576\nassert op_square_pos_prod([]) == 1\nassert op_square_pos_prod([-2, -1, 0, 1, 2]) == 16\nassert op_square_pos_prod([5, 5, 5]) == 15625\nassert op_square_pos_prod([3, 1, 2]) == 36\nassert op_square_pos_prod([10]) == 100\nassert op_square_pos_prod([2, 4, 6]) == 2304\nassert op_square_pos_prod([-7, 12, -7]) == 345744"}
{"id": "op_beforezero_sortabs_counteven", "entry_point": "op_beforezero_sortabs_counteven", "primitives": ["beforezero", "sortabs", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then return how many values are even.", "solution": "def op_beforezero_sortabs_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_sortabs_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_sortabs_counteven([]) == 0\nassert op_beforezero_sortabs_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_sortabs_counteven([5, 5, 5]) == 0\nassert op_beforezero_sortabs_counteven([3, 1, 2]) == 1\nassert op_beforezero_sortabs_counteven([10]) == 1\nassert op_beforezero_sortabs_counteven([2, 4, 6]) == 3\nassert op_beforezero_sortabs_counteven([-7, 12, -7]) == 1"}
{"id": "op_pos_square_dropzeros", "entry_point": "op_pos_square_dropzeros", "primitives": ["pos", "square", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then drop the zeros.", "solution": "def op_pos_square_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_square_dropzeros([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_square_dropzeros([]) == []\nassert op_pos_square_dropzeros([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_square_dropzeros([5, 5, 5]) == [25, 25, 25]\nassert op_pos_square_dropzeros([3, 1, 2]) == [9, 1, 4]\nassert op_pos_square_dropzeros([10]) == [100]\nassert op_pos_square_dropzeros([2, 4, 6]) == [4, 16, 36]\nassert op_pos_square_dropzeros([-7, 12, -7]) == [144]"}
{"id": "op_ages_rev_last3", "entry_point": "op_ages_rev_last3", "primitives": ["ages", "rev", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then keep only the last three.", "solution": "def op_ages_rev_last3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = r[-3:]\n    return r", "tests": "assert op_ages_rev_last3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_rev_last3([]) == []\nassert op_ages_rev_last3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 65, 18]\nassert op_ages_rev_last3([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_odds_beforezero_negate", "entry_point": "op_odds_beforezero_negate", "primitives": ["odds", "beforezero", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then negate each.", "solution": "def op_odds_beforezero_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_beforezero_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_beforezero_negate([]) == []\nassert op_odds_beforezero_negate([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_beforezero_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_beforezero_negate([3, 1, 2]) == [-3, -1]\nassert op_odds_beforezero_negate([10]) == []\nassert op_odds_beforezero_negate([2, 4, 6]) == []\nassert op_odds_beforezero_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_rev_pos_anyeven", "entry_point": "op_rev_pos_anyeven", "primitives": ["rev", "pos", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the positive numbers, then return whether any value is even.", "solution": "def op_rev_pos_anyeven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_rev_pos_anyeven([1, 2, 3, 4]) == True\nassert op_rev_pos_anyeven([]) == False\nassert op_rev_pos_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_rev_pos_anyeven([5, 5, 5]) == False\nassert op_rev_pos_anyeven([3, 1, 2]) == True\nassert op_rev_pos_anyeven([10]) == True\nassert op_rev_pos_anyeven([2, 4, 6]) == True\nassert op_rev_pos_anyeven([-7, 12, -7]) == True"}
{"id": "op_rev_sortd_issorted", "entry_point": "op_rev_sortd_issorted", "primitives": ["rev", "sortd", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then return whether the list is sorted ascending.", "solution": "def op_rev_sortd_issorted(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return r == sorted(r)", "tests": "assert op_rev_sortd_issorted([1, 2, 3, 4]) == False\nassert op_rev_sortd_issorted([]) == True\nassert op_rev_sortd_issorted([-2, -1, 0, 1, 2]) == False\nassert op_rev_sortd_issorted([5, 5, 5]) == True\nassert op_rev_sortd_issorted([3, 1, 2]) == False\nassert op_rev_sortd_issorted([10]) == True\nassert op_rev_sortd_issorted([2, 4, 6]) == False\nassert op_rev_sortd_issorted([-7, 12, -7]) == False"}
{"id": "op_sorta_neg_uniq", "entry_point": "op_sorta_neg_uniq", "primitives": ["sorta", "neg", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_sorta_neg_uniq(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sorta_neg_uniq([1, 2, 3, 4]) == []\nassert op_sorta_neg_uniq([]) == []\nassert op_sorta_neg_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sorta_neg_uniq([5, 5, 5]) == []\nassert op_sorta_neg_uniq([3, 1, 2]) == []\nassert op_sorta_neg_uniq([10]) == []\nassert op_sorta_neg_uniq([2, 4, 6]) == []\nassert op_sorta_neg_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_dropshort_sortalpha_counts", "entry_point": "op_dropshort_sortalpha_counts", "primitives": ["dropshort", "sortalpha", "counts"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then sort alphabetically, then return how many strings remain.", "solution": "def op_dropshort_sortalpha_counts(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = sorted(r)\n    return len(r)", "tests": "assert op_dropshort_sortalpha_counts(['Hello', 'world']) == 2\nassert op_dropshort_sortalpha_counts([]) == 0\nassert op_dropshort_sortalpha_counts(['  a ', '', 'BC', 'bc']) == 1\nassert op_dropshort_sortalpha_counts(['one', 'one', 'Two']) == 3\nassert op_dropshort_sortalpha_counts(['x']) == 0\nassert op_dropshort_sortalpha_counts(['abc', 'de', '']) == 1"}
{"id": "op_pos_dropwhileneg_sum", "entry_point": "op_pos_dropwhileneg_sum", "primitives": ["pos", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the leading negative values, then return their sum.", "solution": "def op_pos_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_pos_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_pos_dropwhileneg_sum([]) == 0\nassert op_pos_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 3\nassert op_pos_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_pos_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_pos_dropwhileneg_sum([10]) == 10\nassert op_pos_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_pos_dropwhileneg_sum([-7, 12, -7]) == 12"}
{"id": "op_dropshort_firstchar_lower", "entry_point": "op_dropshort_firstchar_lower", "primitives": ["dropshort", "firstchar", "lower"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then keep the first character of each (dropping empties), then lowercase each string.", "solution": "def op_dropshort_firstchar_lower(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s[0] for s in r if s]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_dropshort_firstchar_lower(['Hello', 'world']) == ['h', 'w']\nassert op_dropshort_firstchar_lower([]) == []\nassert op_dropshort_firstchar_lower(['  a ', '', 'BC', 'bc']) == [' ']\nassert op_dropshort_firstchar_lower(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_dropshort_firstchar_lower(['x']) == []\nassert op_dropshort_firstchar_lower(['abc', 'de', '']) == ['a']"}
{"id": "op_dropwhileneg_oremptyzero_takewhilepos", "entry_point": "op_dropwhileneg_oremptyzero_takewhilepos", "primitives": ["dropwhileneg", "oremptyzero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then if empty, use a single zero, then take values while they are positive.", "solution": "def op_dropwhileneg_oremptyzero_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_oremptyzero_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_oremptyzero_takewhilepos([]) == []\nassert op_dropwhileneg_oremptyzero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_oremptyzero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_oremptyzero_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_oremptyzero_takewhilepos([10]) == [10]\nassert op_dropwhileneg_oremptyzero_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_oremptyzero_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_double_dec_uniq", "entry_point": "op_double_dec_uniq", "primitives": ["double", "dec", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then drop duplicates keeping first occurrence.", "solution": "def op_double_dec_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_dec_uniq([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_double_dec_uniq([]) == []\nassert op_double_dec_uniq([-2, -1, 0, 1, 2]) == [-5, -3, -1, 1, 3]\nassert op_double_dec_uniq([5, 5, 5]) == [9]\nassert op_double_dec_uniq([3, 1, 2]) == [5, 1, 3]\nassert op_double_dec_uniq([10]) == [19]\nassert op_double_dec_uniq([2, 4, 6]) == [3, 7, 11]\nassert op_double_dec_uniq([-7, 12, -7]) == [-15, 23]"}
{"id": "op_ages_first3_firsteven", "entry_point": "op_ages_first3_firsteven", "primitives": ["ages", "first3", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_ages_first3_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_first3_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_first3_firsteven([]) == 0\nassert op_ages_first3_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 18\nassert op_ages_first3_firsteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_dec_evens_haszero", "entry_point": "op_dec_evens_haszero", "primitives": ["dec", "evens", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then return whether the list contains a zero.", "solution": "def op_dec_evens_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return 0 in r", "tests": "assert op_dec_evens_haszero([1, 2, 3, 4]) == True\nassert op_dec_evens_haszero([]) == False\nassert op_dec_evens_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dec_evens_haszero([5, 5, 5]) == False\nassert op_dec_evens_haszero([3, 1, 2]) == True\nassert op_dec_evens_haszero([10]) == False\nassert op_dec_evens_haszero([2, 4, 6]) == False\nassert op_dec_evens_haszero([-7, 12, -7]) == False"}
{"id": "op_last3_absval_first3", "entry_point": "op_last3_absval_first3", "primitives": ["last3", "absval", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then keep only the first three.", "solution": "def op_last3_absval_first3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_last3_absval_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_absval_first3([]) == []\nassert op_last3_absval_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_absval_first3([5, 5, 5]) == [5, 5, 5]\nassert op_last3_absval_first3([3, 1, 2]) == [3, 1, 2]\nassert op_last3_absval_first3([10]) == [10]\nassert op_last3_absval_first3([2, 4, 6]) == [2, 4, 6]\nassert op_last3_absval_first3([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_padto3_dropfirst_firsteven", "entry_point": "op_padto3_dropfirst_firsteven", "primitives": ["padto3", "dropfirst", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element, then return the first even value (0 if none).", "solution": "def op_padto3_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_dropfirst_firsteven([1, 2, 3, 4]) == 2\nassert op_padto3_dropfirst_firsteven([]) == 0\nassert op_padto3_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_padto3_dropfirst_firsteven([3, 1, 2]) == 2\nassert op_padto3_dropfirst_firsteven([10]) == 0\nassert op_padto3_dropfirst_firsteven([2, 4, 6]) == 4\nassert op_padto3_dropfirst_firsteven([-7, 12, -7]) == 12"}
{"id": "op_trimends_dec_div3", "entry_point": "op_trimends_dec_div3", "primitives": ["trimends", "dec", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then keep multiples of three.", "solution": "def op_trimends_dec_div3(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_trimends_dec_div3([1, 2, 3, 4]) == []\nassert op_trimends_dec_div3([]) == []\nassert op_trimends_dec_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_trimends_dec_div3([5, 5, 5]) == []\nassert op_trimends_dec_div3([3, 1, 2]) == [0]\nassert op_trimends_dec_div3([10]) == []\nassert op_trimends_dec_div3([2, 4, 6]) == [3]\nassert op_trimends_dec_div3([-7, 12, -7]) == []"}
{"id": "op_trimends_sorta_max", "entry_point": "op_trimends_sorta_max", "primitives": ["trimends", "sorta", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_trimends_sorta_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_trimends_sorta_max([1, 2, 3, 4]) == 3\nassert op_trimends_sorta_max([]) == 0\nassert op_trimends_sorta_max([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_sorta_max([5, 5, 5]) == 5\nassert op_trimends_sorta_max([3, 1, 2]) == 1\nassert op_trimends_sorta_max([10]) == 0\nassert op_trimends_sorta_max([2, 4, 6]) == 4\nassert op_trimends_sorta_max([-7, 12, -7]) == 12"}
{"id": "op_add10_square_oremptyzero", "entry_point": "op_add10_square_oremptyzero", "primitives": ["add10", "square", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then if empty, use a single zero.", "solution": "def op_add10_square_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_square_oremptyzero([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_square_oremptyzero([]) == [0]\nassert op_add10_square_oremptyzero([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_square_oremptyzero([5, 5, 5]) == [225, 225, 225]\nassert op_add10_square_oremptyzero([3, 1, 2]) == [169, 121, 144]\nassert op_add10_square_oremptyzero([10]) == [400]\nassert op_add10_square_oremptyzero([2, 4, 6]) == [144, 196, 256]\nassert op_add10_square_oremptyzero([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_trimends_neg_dropfirst", "entry_point": "op_trimends_neg_dropfirst", "primitives": ["trimends", "neg", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then drop the first element.", "solution": "def op_trimends_neg_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_neg_dropfirst([1, 2, 3, 4]) == []\nassert op_trimends_neg_dropfirst([]) == []\nassert op_trimends_neg_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_trimends_neg_dropfirst([5, 5, 5]) == []\nassert op_trimends_neg_dropfirst([3, 1, 2]) == []\nassert op_trimends_neg_dropfirst([10]) == []\nassert op_trimends_neg_dropfirst([2, 4, 6]) == []\nassert op_trimends_neg_dropfirst([-7, 12, -7]) == []"}
{"id": "op_rev_uniq_clamp10", "entry_point": "op_rev_uniq_clamp10", "primitives": ["rev", "uniq", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_rev_uniq_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_uniq_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_uniq_clamp10([]) == []\nassert op_rev_uniq_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_uniq_clamp10([5, 5, 5]) == [5]\nassert op_rev_uniq_clamp10([3, 1, 2]) == [2, 1, 3]\nassert op_rev_uniq_clamp10([10]) == [10]\nassert op_rev_uniq_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_rev_uniq_clamp10([-7, 12, -7]) == [-7, 10]"}
{"id": "op_absval_add10_first3", "entry_point": "op_absval_add10_first3", "primitives": ["absval", "add10", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then keep only the first three.", "solution": "def op_absval_add10_first3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_absval_add10_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_absval_add10_first3([]) == []\nassert op_absval_add10_first3([-2, -1, 0, 1, 2]) == [12, 11, 10]\nassert op_absval_add10_first3([5, 5, 5]) == [15, 15, 15]\nassert op_absval_add10_first3([3, 1, 2]) == [13, 11, 12]\nassert op_absval_add10_first3([10]) == [20]\nassert op_absval_add10_first3([2, 4, 6]) == [12, 14, 16]\nassert op_absval_add10_first3([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_sortalpha_firstchar_counts", "entry_point": "op_sortalpha_firstchar_counts", "primitives": ["sortalpha", "firstchar", "counts"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then keep the first character of each (dropping empties), then return how many strings remain.", "solution": "def op_sortalpha_firstchar_counts(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    return len(r)", "tests": "assert op_sortalpha_firstchar_counts(['Hello', 'world']) == 2\nassert op_sortalpha_firstchar_counts([]) == 0\nassert op_sortalpha_firstchar_counts(['  a ', '', 'BC', 'bc']) == 3\nassert op_sortalpha_firstchar_counts(['one', 'one', 'Two']) == 3\nassert op_sortalpha_firstchar_counts(['x']) == 1\nassert op_sortalpha_firstchar_counts(['abc', 'de', '']) == 2"}
{"id": "op_div3_trimends_len", "entry_point": "op_div3_trimends_len", "primitives": ["div3", "trimends", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then return how many remain.", "solution": "def op_div3_trimends_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return len(r)", "tests": "assert op_div3_trimends_len([1, 2, 3, 4]) == 0\nassert op_div3_trimends_len([]) == 0\nassert op_div3_trimends_len([-2, -1, 0, 1, 2]) == 0\nassert op_div3_trimends_len([5, 5, 5]) == 0\nassert op_div3_trimends_len([3, 1, 2]) == 0\nassert op_div3_trimends_len([10]) == 0\nassert op_div3_trimends_len([2, 4, 6]) == 0\nassert op_div3_trimends_len([-7, 12, -7]) == 0"}
{"id": "op_gt5_dropwhileneg_negate", "entry_point": "op_gt5_dropwhileneg_negate", "primitives": ["gt5", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the leading negative values, then negate each.", "solution": "def op_gt5_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_dropwhileneg_negate([1, 2, 3, 4]) == []\nassert op_gt5_dropwhileneg_negate([]) == []\nassert op_gt5_dropwhileneg_negate([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropwhileneg_negate([5, 5, 5]) == []\nassert op_gt5_dropwhileneg_negate([3, 1, 2]) == []\nassert op_gt5_dropwhileneg_negate([10]) == [-10]\nassert op_gt5_dropwhileneg_negate([2, 4, 6]) == [-6]\nassert op_gt5_dropwhileneg_negate([-7, 12, -7]) == [-12]"}
{"id": "op_sorta_dropzeros_last3", "entry_point": "op_sorta_dropzeros_last3", "primitives": ["sorta", "dropzeros", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then keep only the last three.", "solution": "def op_sorta_dropzeros_last3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_sorta_dropzeros_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_dropzeros_last3([]) == []\nassert op_sorta_dropzeros_last3([-2, -1, 0, 1, 2]) == [-1, 1, 2]\nassert op_sorta_dropzeros_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropzeros_last3([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_dropzeros_last3([10]) == [10]\nassert op_sorta_dropzeros_last3([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropzeros_last3([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_trimends_clamp10_dropfirst", "entry_point": "op_trimends_clamp10_dropfirst", "primitives": ["trimends", "clamp10", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cap each value at 10, then drop the first element.", "solution": "def op_trimends_clamp10_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_clamp10_dropfirst([1, 2, 3, 4]) == [3]\nassert op_trimends_clamp10_dropfirst([]) == []\nassert op_trimends_clamp10_dropfirst([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_clamp10_dropfirst([5, 5, 5]) == []\nassert op_trimends_clamp10_dropfirst([3, 1, 2]) == []\nassert op_trimends_clamp10_dropfirst([10]) == []\nassert op_trimends_clamp10_dropfirst([2, 4, 6]) == []\nassert op_trimends_clamp10_dropfirst([-7, 12, -7]) == []"}
{"id": "op_pos_trimends_rev", "entry_point": "op_pos_trimends_rev", "primitives": ["pos", "trimends", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the first and last elements, then reverse the order.", "solution": "def op_pos_trimends_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_pos_trimends_rev([]) == []\nassert op_pos_trimends_rev([-2, -1, 0, 1, 2]) == []\nassert op_pos_trimends_rev([5, 5, 5]) == [5]\nassert op_pos_trimends_rev([3, 1, 2]) == [1]\nassert op_pos_trimends_rev([10]) == []\nassert op_pos_trimends_rev([2, 4, 6]) == [4]\nassert op_pos_trimends_rev([-7, 12, -7]) == []"}
{"id": "op_firstchar_upper_dropshort", "entry_point": "op_firstchar_upper_dropshort", "primitives": ["firstchar", "upper", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then uppercase each string, then drop strings shorter than three characters.", "solution": "def op_firstchar_upper_dropshort(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_firstchar_upper_dropshort(['Hello', 'world']) == []\nassert op_firstchar_upper_dropshort([]) == []\nassert op_firstchar_upper_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_firstchar_upper_dropshort(['one', 'one', 'Two']) == []\nassert op_firstchar_upper_dropshort(['x']) == []\nassert op_firstchar_upper_dropshort(['abc', 'de', '']) == []"}
{"id": "op_inc_absval_sum", "entry_point": "op_inc_absval_sum", "primitives": ["inc", "absval", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each, then return their sum.", "solution": "def op_inc_absval_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_inc_absval_sum([1, 2, 3, 4]) == 14\nassert op_inc_absval_sum([]) == 0\nassert op_inc_absval_sum([-2, -1, 0, 1, 2]) == 7\nassert op_inc_absval_sum([5, 5, 5]) == 18\nassert op_inc_absval_sum([3, 1, 2]) == 9\nassert op_inc_absval_sum([10]) == 11\nassert op_inc_absval_sum([2, 4, 6]) == 15\nassert op_inc_absval_sum([-7, 12, -7]) == 25"}
{"id": "op_square_absval_clamp10", "entry_point": "op_square_absval_clamp10", "primitives": ["square", "absval", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take the absolute value of each, then cap each value at 10.", "solution": "def op_square_absval_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_absval_clamp10([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_square_absval_clamp10([]) == []\nassert op_square_absval_clamp10([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_absval_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_square_absval_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_square_absval_clamp10([10]) == [10]\nassert op_square_absval_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_square_absval_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_takewhilepos_absval_sortabs", "entry_point": "op_takewhilepos_absval_sortabs", "primitives": ["takewhilepos", "absval", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then sort by absolute value.", "solution": "def op_takewhilepos_absval_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_absval_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_absval_sortabs([]) == []\nassert op_takewhilepos_absval_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_absval_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_absval_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_absval_sortabs([10]) == [10]\nassert op_takewhilepos_absval_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_absval_sortabs([-7, 12, -7]) == []"}
{"id": "op_dropfirst_uniq_len", "entry_point": "op_dropfirst_uniq_len", "primitives": ["dropfirst", "uniq", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_dropfirst_uniq_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_dropfirst_uniq_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_uniq_len([]) == 0\nassert op_dropfirst_uniq_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_uniq_len([5, 5, 5]) == 1\nassert op_dropfirst_uniq_len([3, 1, 2]) == 2\nassert op_dropfirst_uniq_len([10]) == 0\nassert op_dropfirst_uniq_len([2, 4, 6]) == 2\nassert op_dropfirst_uniq_len([-7, 12, -7]) == 2"}
{"id": "op_ages_dec_dropfirst", "entry_point": "op_ages_dec_dropfirst", "primitives": ["ages", "dec", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then drop the first element.", "solution": "def op_ages_dec_dropfirst(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_ages_dec_dropfirst([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [11]\nassert op_ages_dec_dropfirst([]) == []\nassert op_ages_dec_dropfirst([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [64, 16]\nassert op_ages_dec_dropfirst([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_ages_neg_absval", "entry_point": "op_ages_neg_absval", "primitives": ["ages", "neg", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then take the absolute value of each.", "solution": "def op_ages_neg_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_neg_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg_absval([]) == []\nassert op_ages_neg_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg_absval([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_ages_dec_oremptyzero", "entry_point": "op_ages_dec_oremptyzero", "primitives": ["ages", "dec", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then subtract one from each, then if empty, use a single zero.", "solution": "def op_ages_dec_oremptyzero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_ages_dec_oremptyzero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [35, 11]\nassert op_ages_dec_oremptyzero([]) == [0]\nassert op_ages_dec_oremptyzero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [17, 64, 16]\nassert op_ages_dec_oremptyzero([{'name': 'Fi', 'age': 41}]) == [40]"}
{"id": "op_takewhilepos_beforezero_alldistinct", "entry_point": "op_takewhilepos_beforezero_alldistinct", "primitives": ["takewhilepos", "beforezero", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then return whether all values are distinct.", "solution": "def op_takewhilepos_beforezero_alldistinct(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return len(r) == len(set(r))", "tests": "assert op_takewhilepos_beforezero_alldistinct([1, 2, 3, 4]) == True\nassert op_takewhilepos_beforezero_alldistinct([]) == True\nassert op_takewhilepos_beforezero_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_takewhilepos_beforezero_alldistinct([5, 5, 5]) == False\nassert op_takewhilepos_beforezero_alldistinct([3, 1, 2]) == True\nassert op_takewhilepos_beforezero_alldistinct([10]) == True\nassert op_takewhilepos_beforezero_alldistinct([2, 4, 6]) == True\nassert op_takewhilepos_beforezero_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dec_sortabs_max", "entry_point": "op_dec_sortabs_max", "primitives": ["dec", "sortabs", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then return the maximum (0 if empty).", "solution": "def op_dec_sortabs_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return max(r) if r else 0", "tests": "assert op_dec_sortabs_max([1, 2, 3, 4]) == 3\nassert op_dec_sortabs_max([]) == 0\nassert op_dec_sortabs_max([-2, -1, 0, 1, 2]) == 1\nassert op_dec_sortabs_max([5, 5, 5]) == 4\nassert op_dec_sortabs_max([3, 1, 2]) == 2\nassert op_dec_sortabs_max([10]) == 9\nassert op_dec_sortabs_max([2, 4, 6]) == 5\nassert op_dec_sortabs_max([-7, 12, -7]) == 11"}
{"id": "op_div3_sorta_alldistinct", "entry_point": "op_div3_sorta_alldistinct", "primitives": ["div3", "sorta", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort ascending, then return whether all values are distinct.", "solution": "def op_div3_sorta_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return len(r) == len(set(r))", "tests": "assert op_div3_sorta_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_sorta_alldistinct([]) == True\nassert op_div3_sorta_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_sorta_alldistinct([5, 5, 5]) == True\nassert op_div3_sorta_alldistinct([3, 1, 2]) == True\nassert op_div3_sorta_alldistinct([10]) == True\nassert op_div3_sorta_alldistinct([2, 4, 6]) == True\nassert op_div3_sorta_alldistinct([-7, 12, -7]) == True"}
{"id": "op_first3_pos_odds", "entry_point": "op_first3_pos_odds", "primitives": ["first3", "pos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_first3_pos_odds(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_first3_pos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_first3_pos_odds([]) == []\nassert op_first3_pos_odds([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_first3_pos_odds([3, 1, 2]) == [3, 1]\nassert op_first3_pos_odds([10]) == []\nassert op_first3_pos_odds([2, 4, 6]) == []\nassert op_first3_pos_odds([-7, 12, -7]) == []"}
{"id": "op_evens_oremptyzero_double", "entry_point": "op_evens_oremptyzero_double", "primitives": ["evens", "oremptyzero", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then double each.", "solution": "def op_evens_oremptyzero_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_oremptyzero_double([1, 2, 3, 4]) == [4, 8]\nassert op_evens_oremptyzero_double([]) == [0]\nassert op_evens_oremptyzero_double([-2, -1, 0, 1, 2]) == [-4, 0, 4]\nassert op_evens_oremptyzero_double([5, 5, 5]) == [0]\nassert op_evens_oremptyzero_double([3, 1, 2]) == [4]\nassert op_evens_oremptyzero_double([10]) == [20]\nassert op_evens_oremptyzero_double([2, 4, 6]) == [4, 8, 12]\nassert op_evens_oremptyzero_double([-7, 12, -7]) == [24]"}
{"id": "op_odds_sorta_len", "entry_point": "op_odds_sorta_len", "primitives": ["odds", "sorta", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort ascending, then return how many remain.", "solution": "def op_odds_sorta_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return len(r)", "tests": "assert op_odds_sorta_len([1, 2, 3, 4]) == 2\nassert op_odds_sorta_len([]) == 0\nassert op_odds_sorta_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_sorta_len([5, 5, 5]) == 3\nassert op_odds_sorta_len([3, 1, 2]) == 2\nassert op_odds_sorta_len([10]) == 0\nassert op_odds_sorta_len([2, 4, 6]) == 0\nassert op_odds_sorta_len([-7, 12, -7]) == 2"}
{"id": "op_padto3_dropwhileneg_div3", "entry_point": "op_padto3_dropwhileneg_div3", "primitives": ["padto3", "dropwhileneg", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then keep multiples of three.", "solution": "def op_padto3_dropwhileneg_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_dropwhileneg_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_dropwhileneg_div3([]) == [0, 0, 0]\nassert op_padto3_dropwhileneg_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_dropwhileneg_div3([5, 5, 5]) == []\nassert op_padto3_dropwhileneg_div3([3, 1, 2]) == [3]\nassert op_padto3_dropwhileneg_div3([10]) == [0, 0]\nassert op_padto3_dropwhileneg_div3([2, 4, 6]) == [6]\nassert op_padto3_dropwhileneg_div3([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_dropwhileneg_add10", "entry_point": "op_clamp10_dropwhileneg_add10", "primitives": ["clamp10", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then add ten to each.", "solution": "def op_clamp10_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_dropwhileneg_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_clamp10_dropwhileneg_add10([]) == []\nassert op_clamp10_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_clamp10_dropwhileneg_add10([5, 5, 5]) == [15, 15, 15]\nassert op_clamp10_dropwhileneg_add10([3, 1, 2]) == [13, 11, 12]\nassert op_clamp10_dropwhileneg_add10([10]) == [20]\nassert op_clamp10_dropwhileneg_add10([2, 4, 6]) == [12, 14, 16]\nassert op_clamp10_dropwhileneg_add10([-7, 12, -7]) == [20, 3]"}
{"id": "op_absval_pos_max", "entry_point": "op_absval_pos_max", "primitives": ["absval", "pos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_absval_pos_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_absval_pos_max([1, 2, 3, 4]) == 4\nassert op_absval_pos_max([]) == 0\nassert op_absval_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_absval_pos_max([5, 5, 5]) == 5\nassert op_absval_pos_max([3, 1, 2]) == 3\nassert op_absval_pos_max([10]) == 10\nassert op_absval_pos_max([2, 4, 6]) == 6\nassert op_absval_pos_max([-7, 12, -7]) == 12"}
{"id": "op_square_oremptyzero_last3", "entry_point": "op_square_oremptyzero_last3", "primitives": ["square", "oremptyzero", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then if empty, use a single zero, then keep only the last three.", "solution": "def op_square_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_square_oremptyzero_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_oremptyzero_last3([]) == [0]\nassert op_square_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_square_oremptyzero_last3([5, 5, 5]) == [25, 25, 25]\nassert op_square_oremptyzero_last3([3, 1, 2]) == [9, 1, 4]\nassert op_square_oremptyzero_last3([10]) == [100]\nassert op_square_oremptyzero_last3([2, 4, 6]) == [4, 16, 36]\nassert op_square_oremptyzero_last3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_square_gt5_padto3", "entry_point": "op_square_gt5_padto3", "primitives": ["square", "gt5", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then pad with zeros to at least three elements.", "solution": "def op_square_gt5_padto3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_square_gt5_padto3([1, 2, 3, 4]) == [9, 16, 0]\nassert op_square_gt5_padto3([]) == [0, 0, 0]\nassert op_square_gt5_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_square_gt5_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5_padto3([3, 1, 2]) == [9, 0, 0]\nassert op_square_gt5_padto3([10]) == [100, 0, 0]\nassert op_square_gt5_padto3([2, 4, 6]) == [16, 36, 0]\nassert op_square_gt5_padto3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_takewhilepos_negate_odds", "entry_point": "op_takewhilepos_negate_odds", "primitives": ["takewhilepos", "negate", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then keep the odd numbers.", "solution": "def op_takewhilepos_negate_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_negate_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_takewhilepos_negate_odds([]) == []\nassert op_takewhilepos_negate_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_takewhilepos_negate_odds([10]) == []\nassert op_takewhilepos_negate_odds([2, 4, 6]) == []\nassert op_takewhilepos_negate_odds([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_odds_firsteven", "entry_point": "op_dropwhileneg_odds_firsteven", "primitives": ["dropwhileneg", "odds", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then return the first even value (0 if none).", "solution": "def op_dropwhileneg_odds_firsteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropwhileneg_odds_firsteven([1, 2, 3, 4]) == 0\nassert op_dropwhileneg_odds_firsteven([]) == 0\nassert op_dropwhileneg_odds_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_odds_firsteven([5, 5, 5]) == 0\nassert op_dropwhileneg_odds_firsteven([3, 1, 2]) == 0\nassert op_dropwhileneg_odds_firsteven([10]) == 0\nassert op_dropwhileneg_odds_firsteven([2, 4, 6]) == 0\nassert op_dropwhileneg_odds_firsteven([-7, 12, -7]) == 0"}
{"id": "op_inc_beforezero_takewhilepos", "entry_point": "op_inc_beforezero_takewhilepos", "primitives": ["inc", "beforezero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_inc_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_beforezero_takewhilepos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_beforezero_takewhilepos([]) == []\nassert op_inc_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_beforezero_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_beforezero_takewhilepos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_beforezero_takewhilepos([10]) == [11]\nassert op_inc_beforezero_takewhilepos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sortd_clamp10_rev", "entry_point": "op_sortd_clamp10_rev", "primitives": ["sortd", "clamp10", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10, then reverse the order.", "solution": "def op_sortd_clamp10_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_clamp10_rev([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortd_clamp10_rev([]) == []\nassert op_sortd_clamp10_rev([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortd_clamp10_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_clamp10_rev([3, 1, 2]) == [1, 2, 3]\nassert op_sortd_clamp10_rev([10]) == [10]\nassert op_sortd_clamp10_rev([2, 4, 6]) == [2, 4, 6]\nassert op_sortd_clamp10_rev([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_sorta_evens_takewhilepos", "entry_point": "op_sorta_evens_takewhilepos", "primitives": ["sorta", "evens", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then take values while they are positive.", "solution": "def op_sorta_evens_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sorta_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_evens_takewhilepos([]) == []\nassert op_sorta_evens_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sorta_evens_takewhilepos([5, 5, 5]) == []\nassert op_sorta_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_sorta_evens_takewhilepos([10]) == [10]\nassert op_sorta_evens_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_double_sorta_rev", "entry_point": "op_double_sorta_rev", "primitives": ["double", "sorta", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort ascending, then reverse the order.", "solution": "def op_double_sorta_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_sorta_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_sorta_rev([]) == []\nassert op_double_sorta_rev([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_sorta_rev([5, 5, 5]) == [10, 10, 10]\nassert op_double_sorta_rev([3, 1, 2]) == [6, 4, 2]\nassert op_double_sorta_rev([10]) == [20]\nassert op_double_sorta_rev([2, 4, 6]) == [12, 8, 4]\nassert op_double_sorta_rev([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_oremptyzero_dropwhileneg_first3", "entry_point": "op_oremptyzero_dropwhileneg_first3", "primitives": ["oremptyzero", "dropwhileneg", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then keep only the first three.", "solution": "def op_oremptyzero_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_oremptyzero_dropwhileneg_first3([]) == [0]\nassert op_oremptyzero_dropwhileneg_first3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_oremptyzero_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_dropwhileneg_first3([10]) == [10]\nassert op_oremptyzero_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_dropwhileneg_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_padto3_double_sorta", "entry_point": "op_padto3_double_sorta", "primitives": ["padto3", "double", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then sort ascending.", "solution": "def op_padto3_double_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_double_sorta([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_double_sorta([]) == [0, 0, 0]\nassert op_padto3_double_sorta([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_padto3_double_sorta([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double_sorta([3, 1, 2]) == [2, 4, 6]\nassert op_padto3_double_sorta([10]) == [0, 0, 20]\nassert op_padto3_double_sorta([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_double_sorta([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_uniq_clamp10_pos", "entry_point": "op_uniq_clamp10_pos", "primitives": ["uniq", "clamp10", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then keep the positive numbers.", "solution": "def op_uniq_clamp10_pos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_uniq_clamp10_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_clamp10_pos([]) == []\nassert op_uniq_clamp10_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_clamp10_pos([5, 5, 5]) == [5]\nassert op_uniq_clamp10_pos([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_clamp10_pos([10]) == [10]\nassert op_uniq_clamp10_pos([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_clamp10_pos([-7, 12, -7]) == [10]"}
{"id": "op_padto3_takewhilepos_pos", "entry_point": "op_padto3_takewhilepos_pos", "primitives": ["padto3", "takewhilepos", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then keep the positive numbers.", "solution": "def op_padto3_takewhilepos_pos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_padto3_takewhilepos_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_takewhilepos_pos([]) == []\nassert op_padto3_takewhilepos_pos([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_pos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_pos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_takewhilepos_pos([10]) == [10]\nassert op_padto3_takewhilepos_pos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_takewhilepos_pos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_negate_counteven", "entry_point": "op_dropfirst_negate_counteven", "primitives": ["dropfirst", "negate", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then return how many values are even.", "solution": "def op_dropfirst_negate_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_negate_counteven([1, 2, 3, 4]) == 2\nassert op_dropfirst_negate_counteven([]) == 0\nassert op_dropfirst_negate_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_negate_counteven([5, 5, 5]) == 0\nassert op_dropfirst_negate_counteven([3, 1, 2]) == 1\nassert op_dropfirst_negate_counteven([10]) == 0\nassert op_dropfirst_negate_counteven([2, 4, 6]) == 2\nassert op_dropfirst_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_rev_evens_len", "entry_point": "op_rev_evens_len", "primitives": ["rev", "evens", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the even numbers, then return how many remain.", "solution": "def op_rev_evens_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_rev_evens_len([1, 2, 3, 4]) == 2\nassert op_rev_evens_len([]) == 0\nassert op_rev_evens_len([-2, -1, 0, 1, 2]) == 3\nassert op_rev_evens_len([5, 5, 5]) == 0\nassert op_rev_evens_len([3, 1, 2]) == 1\nassert op_rev_evens_len([10]) == 1\nassert op_rev_evens_len([2, 4, 6]) == 3\nassert op_rev_evens_len([-7, 12, -7]) == 1"}
{"id": "op_sortabs_dropwhileneg_sorta", "entry_point": "op_sortabs_dropwhileneg_sorta", "primitives": ["sortabs", "dropwhileneg", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the leading negative values, then sort ascending.", "solution": "def op_sortabs_dropwhileneg_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_dropwhileneg_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_dropwhileneg_sorta([]) == []\nassert op_sortabs_dropwhileneg_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortabs_dropwhileneg_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_dropwhileneg_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_dropwhileneg_sorta([10]) == [10]\nassert op_sortabs_dropwhileneg_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_dropwhileneg_sorta([-7, 12, -7]) == [12]"}
{"id": "op_evens_add10_last3", "entry_point": "op_evens_add10_last3", "primitives": ["evens", "add10", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then keep only the last three.", "solution": "def op_evens_add10_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_evens_add10_last3([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10_last3([]) == []\nassert op_evens_add10_last3([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10_last3([5, 5, 5]) == []\nassert op_evens_add10_last3([3, 1, 2]) == [12]\nassert op_evens_add10_last3([10]) == [20]\nassert op_evens_add10_last3([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10_last3([-7, 12, -7]) == [22]"}
{"id": "op_first3_clamp10_sorta", "entry_point": "op_first3_clamp10_sorta", "primitives": ["first3", "clamp10", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then sort ascending.", "solution": "def op_first3_clamp10_sorta(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_first3_clamp10_sorta([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10_sorta([]) == []\nassert op_first3_clamp10_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_clamp10_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_first3_clamp10_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_first3_clamp10_sorta([10]) == [10]\nassert op_first3_clamp10_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10_sorta([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_pos_dropzeros_min", "entry_point": "op_pos_dropzeros_min", "primitives": ["pos", "dropzeros", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop the zeros, then return the minimum (0 if empty).", "solution": "def op_pos_dropzeros_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x != 0]\n    return min(r) if r else 0", "tests": "assert op_pos_dropzeros_min([1, 2, 3, 4]) == 1\nassert op_pos_dropzeros_min([]) == 0\nassert op_pos_dropzeros_min([-2, -1, 0, 1, 2]) == 1\nassert op_pos_dropzeros_min([5, 5, 5]) == 5\nassert op_pos_dropzeros_min([3, 1, 2]) == 1\nassert op_pos_dropzeros_min([10]) == 10\nassert op_pos_dropzeros_min([2, 4, 6]) == 2\nassert op_pos_dropzeros_min([-7, 12, -7]) == 12"}
{"id": "op_odds_last3_padto3", "entry_point": "op_odds_last3_padto3", "primitives": ["odds", "last3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep only the last three, then pad with zeros to at least three elements.", "solution": "def op_odds_last3_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_odds_last3_padto3([1, 2, 3, 4]) == [1, 3, 0]\nassert op_odds_last3_padto3([]) == [0, 0, 0]\nassert op_odds_last3_padto3([-2, -1, 0, 1, 2]) == [-1, 1, 0]\nassert op_odds_last3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_last3_padto3([3, 1, 2]) == [3, 1, 0]\nassert op_odds_last3_padto3([10]) == [0, 0, 0]\nassert op_odds_last3_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_odds_last3_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_inc_dropzeros_prod", "entry_point": "op_inc_dropzeros_prod", "primitives": ["inc", "dropzeros", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then return their product.", "solution": "def op_inc_dropzeros_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_inc_dropzeros_prod([1, 2, 3, 4]) == 120\nassert op_inc_dropzeros_prod([]) == 1\nassert op_inc_dropzeros_prod([-2, -1, 0, 1, 2]) == -6\nassert op_inc_dropzeros_prod([5, 5, 5]) == 216\nassert op_inc_dropzeros_prod([3, 1, 2]) == 24\nassert op_inc_dropzeros_prod([10]) == 11\nassert op_inc_dropzeros_prod([2, 4, 6]) == 105\nassert op_inc_dropzeros_prod([-7, 12, -7]) == 468"}
{"id": "op_sorta_evens_trimends", "entry_point": "op_sorta_evens_trimends", "primitives": ["sorta", "evens", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then drop the first and last elements.", "solution": "def op_sorta_evens_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_evens_trimends([1, 2, 3, 4]) == []\nassert op_sorta_evens_trimends([]) == []\nassert op_sorta_evens_trimends([-2, -1, 0, 1, 2]) == [0]\nassert op_sorta_evens_trimends([5, 5, 5]) == []\nassert op_sorta_evens_trimends([3, 1, 2]) == []\nassert op_sorta_evens_trimends([10]) == []\nassert op_sorta_evens_trimends([2, 4, 6]) == [4]\nassert op_sorta_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_gt5_neg_min", "entry_point": "op_gt5_neg_min", "primitives": ["gt5", "neg", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_gt5_neg_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_gt5_neg_min([1, 2, 3, 4]) == 0\nassert op_gt5_neg_min([]) == 0\nassert op_gt5_neg_min([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_neg_min([5, 5, 5]) == 0\nassert op_gt5_neg_min([3, 1, 2]) == 0\nassert op_gt5_neg_min([10]) == 0\nassert op_gt5_neg_min([2, 4, 6]) == 0\nassert op_gt5_neg_min([-7, 12, -7]) == 0"}
{"id": "op_dec_sorta_max", "entry_point": "op_dec_sorta_max", "primitives": ["dec", "sorta", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort ascending, then return the maximum (0 if empty).", "solution": "def op_dec_sorta_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r)\n    return max(r) if r else 0", "tests": "assert op_dec_sorta_max([1, 2, 3, 4]) == 3\nassert op_dec_sorta_max([]) == 0\nassert op_dec_sorta_max([-2, -1, 0, 1, 2]) == 1\nassert op_dec_sorta_max([5, 5, 5]) == 4\nassert op_dec_sorta_max([3, 1, 2]) == 2\nassert op_dec_sorta_max([10]) == 9\nassert op_dec_sorta_max([2, 4, 6]) == 5\nassert op_dec_sorta_max([-7, 12, -7]) == 11"}
{"id": "op_first3_sortabs_gt5", "entry_point": "op_first3_sortabs_gt5", "primitives": ["first3", "sortabs", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort by absolute value, then keep values greater than five.", "solution": "def op_first3_sortabs_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_sortabs_gt5([1, 2, 3, 4]) == []\nassert op_first3_sortabs_gt5([]) == []\nassert op_first3_sortabs_gt5([-2, -1, 0, 1, 2]) == []\nassert op_first3_sortabs_gt5([5, 5, 5]) == []\nassert op_first3_sortabs_gt5([3, 1, 2]) == []\nassert op_first3_sortabs_gt5([10]) == [10]\nassert op_first3_sortabs_gt5([2, 4, 6]) == [6]\nassert op_first3_sortabs_gt5([-7, 12, -7]) == [12]"}
{"id": "op_padto3_beforezero_neg", "entry_point": "op_padto3_beforezero_neg", "primitives": ["padto3", "beforezero", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_padto3_beforezero_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_beforezero_neg([1, 2, 3, 4]) == []\nassert op_padto3_beforezero_neg([]) == []\nassert op_padto3_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_padto3_beforezero_neg([5, 5, 5]) == []\nassert op_padto3_beforezero_neg([3, 1, 2]) == []\nassert op_padto3_beforezero_neg([10]) == []\nassert op_padto3_beforezero_neg([2, 4, 6]) == []\nassert op_padto3_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_first3_inc", "entry_point": "op_square_first3_inc", "primitives": ["square", "first3", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then add one to each.", "solution": "def op_square_first3_inc(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_square_first3_inc([1, 2, 3, 4]) == [2, 5, 10]\nassert op_square_first3_inc([]) == []\nassert op_square_first3_inc([-2, -1, 0, 1, 2]) == [5, 2, 1]\nassert op_square_first3_inc([5, 5, 5]) == [26, 26, 26]\nassert op_square_first3_inc([3, 1, 2]) == [10, 2, 5]\nassert op_square_first3_inc([10]) == [101]\nassert op_square_first3_inc([2, 4, 6]) == [5, 17, 37]\nassert op_square_first3_inc([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_beforezero_double_dropfirst", "entry_point": "op_beforezero_double_dropfirst", "primitives": ["beforezero", "double", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then double each, then drop the first element.", "solution": "def op_beforezero_double_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * 2 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_double_dropfirst([1, 2, 3, 4]) == [4, 6, 8]\nassert op_beforezero_double_dropfirst([]) == []\nassert op_beforezero_double_dropfirst([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_double_dropfirst([5, 5, 5]) == [10, 10]\nassert op_beforezero_double_dropfirst([3, 1, 2]) == [2, 4]\nassert op_beforezero_double_dropfirst([10]) == []\nassert op_beforezero_double_dropfirst([2, 4, 6]) == [8, 12]\nassert op_beforezero_double_dropfirst([-7, 12, -7]) == [24, -14]"}
{"id": "op_sortabs_neg_padto3", "entry_point": "op_sortabs_neg_padto3", "primitives": ["sortabs", "neg", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_sortabs_neg_padto3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortabs_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([-2, -1, 0, 1, 2]) == [-1, -2, 0]\nassert op_sortabs_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([10]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_sortabs_neg_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_odds_add10_sortabs", "entry_point": "op_odds_add10_sortabs", "primitives": ["odds", "add10", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then sort by absolute value.", "solution": "def op_odds_add10_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_odds_add10_sortabs([1, 2, 3, 4]) == [11, 13]\nassert op_odds_add10_sortabs([]) == []\nassert op_odds_add10_sortabs([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_add10_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10_sortabs([3, 1, 2]) == [11, 13]\nassert op_odds_add10_sortabs([10]) == []\nassert op_odds_add10_sortabs([2, 4, 6]) == []\nassert op_odds_add10_sortabs([-7, 12, -7]) == [3, 3]"}
{"id": "op_takewhilepos_first3_pos", "entry_point": "op_takewhilepos_first3_pos", "primitives": ["takewhilepos", "first3", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then keep the positive numbers.", "solution": "def op_takewhilepos_first3_pos(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_takewhilepos_first3_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_first3_pos([]) == []\nassert op_takewhilepos_first3_pos([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_pos([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3_pos([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_first3_pos([10]) == [10]\nassert op_takewhilepos_first3_pos([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_first3_pos([-7, 12, -7]) == []"}
{"id": "op_negate_clamp10_evens", "entry_point": "op_negate_clamp10_evens", "primitives": ["negate", "clamp10", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then cap each value at 10, then keep the even numbers.", "solution": "def op_negate_clamp10_evens(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_negate_clamp10_evens([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_clamp10_evens([]) == []\nassert op_negate_clamp10_evens([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_clamp10_evens([5, 5, 5]) == []\nassert op_negate_clamp10_evens([3, 1, 2]) == [-2]\nassert op_negate_clamp10_evens([10]) == [-10]\nassert op_negate_clamp10_evens([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_clamp10_evens([-7, 12, -7]) == [-12]"}
{"id": "op_ages_takewhilepos_beforezero", "entry_point": "op_ages_takewhilepos_beforezero", "primitives": ["ages", "takewhilepos", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_ages_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_takewhilepos_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos_beforezero([]) == []\nassert op_ages_takewhilepos_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos_beforezero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_add10_pos_beforezero", "entry_point": "op_add10_pos_beforezero", "primitives": ["add10", "pos", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the positive numbers, then keep everything before the first zero.", "solution": "def op_add10_pos_beforezero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_add10_pos_beforezero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_pos_beforezero([]) == []\nassert op_add10_pos_beforezero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_pos_beforezero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_pos_beforezero([3, 1, 2]) == [13, 11, 12]\nassert op_add10_pos_beforezero([10]) == [20]\nassert op_add10_pos_beforezero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_pos_beforezero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_inc_double_haszero", "entry_point": "op_inc_double_haszero", "primitives": ["inc", "double", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then return whether the list contains a zero.", "solution": "def op_inc_double_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_inc_double_haszero([1, 2, 3, 4]) == False\nassert op_inc_double_haszero([]) == False\nassert op_inc_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_inc_double_haszero([5, 5, 5]) == False\nassert op_inc_double_haszero([3, 1, 2]) == False\nassert op_inc_double_haszero([10]) == False\nassert op_inc_double_haszero([2, 4, 6]) == False\nassert op_inc_double_haszero([-7, 12, -7]) == False"}
{"id": "op_absval_sortd_evens", "entry_point": "op_absval_sortd_evens", "primitives": ["absval", "sortd", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort descending, then keep the even numbers.", "solution": "def op_absval_sortd_evens(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_absval_sortd_evens([1, 2, 3, 4]) == [4, 2]\nassert op_absval_sortd_evens([]) == []\nassert op_absval_sortd_evens([-2, -1, 0, 1, 2]) == [2, 2, 0]\nassert op_absval_sortd_evens([5, 5, 5]) == []\nassert op_absval_sortd_evens([3, 1, 2]) == [2]\nassert op_absval_sortd_evens([10]) == [10]\nassert op_absval_sortd_evens([2, 4, 6]) == [6, 4, 2]\nassert op_absval_sortd_evens([-7, 12, -7]) == [12]"}
{"id": "op_rev_div3_oremptyzero", "entry_point": "op_rev_div3_oremptyzero", "primitives": ["rev", "div3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then if empty, use a single zero.", "solution": "def op_rev_div3_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_div3_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_rev_div3_oremptyzero([]) == [0]\nassert op_rev_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_rev_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_rev_div3_oremptyzero([3, 1, 2]) == [3]\nassert op_rev_div3_oremptyzero([10]) == [0]\nassert op_rev_div3_oremptyzero([2, 4, 6]) == [6]\nassert op_rev_div3_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_div3_dropwhileneg", "entry_point": "op_dropzeros_div3_dropwhileneg", "primitives": ["dropzeros", "div3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then drop the leading negative values.", "solution": "def op_dropzeros_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_div3_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_dropwhileneg([]) == []\nassert op_dropzeros_div3_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_dropwhileneg([5, 5, 5]) == []\nassert op_dropzeros_div3_dropwhileneg([3, 1, 2]) == [3]\nassert op_dropzeros_div3_dropwhileneg([10]) == []\nassert op_dropzeros_div3_dropwhileneg([2, 4, 6]) == [6]\nassert op_dropzeros_div3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_padto3_oremptyzero_haszero", "entry_point": "op_padto3_oremptyzero_haszero", "primitives": ["padto3", "oremptyzero", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then return whether the list contains a zero.", "solution": "def op_padto3_oremptyzero_haszero(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return 0 in r", "tests": "assert op_padto3_oremptyzero_haszero([1, 2, 3, 4]) == False\nassert op_padto3_oremptyzero_haszero([]) == True\nassert op_padto3_oremptyzero_haszero([-2, -1, 0, 1, 2]) == True\nassert op_padto3_oremptyzero_haszero([5, 5, 5]) == False\nassert op_padto3_oremptyzero_haszero([3, 1, 2]) == False\nassert op_padto3_oremptyzero_haszero([10]) == True\nassert op_padto3_oremptyzero_haszero([2, 4, 6]) == False\nassert op_padto3_oremptyzero_haszero([-7, 12, -7]) == False"}
{"id": "op_add10_last3_allpos", "entry_point": "op_add10_last3_allpos", "primitives": ["add10", "last3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return whether all values are positive.", "solution": "def op_add10_last3_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_last3_allpos([1, 2, 3, 4]) == True\nassert op_add10_last3_allpos([]) == True\nassert op_add10_last3_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_last3_allpos([5, 5, 5]) == True\nassert op_add10_last3_allpos([3, 1, 2]) == True\nassert op_add10_last3_allpos([10]) == True\nassert op_add10_last3_allpos([2, 4, 6]) == True\nassert op_add10_last3_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_absval_sortd", "entry_point": "op_dec_absval_sortd", "primitives": ["dec", "absval", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then sort descending.", "solution": "def op_dec_absval_sortd(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_dec_absval_sortd([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_absval_sortd([]) == []\nassert op_dec_absval_sortd([-2, -1, 0, 1, 2]) == [3, 2, 1, 1, 0]\nassert op_dec_absval_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_sortd([3, 1, 2]) == [2, 1, 0]\nassert op_dec_absval_sortd([10]) == [9]\nassert op_dec_absval_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_dec_absval_sortd([-7, 12, -7]) == [11, 8, 8]"}
{"id": "op_sortd_absval_dropzeros", "entry_point": "op_sortd_absval_dropzeros", "primitives": ["sortd", "absval", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then drop the zeros.", "solution": "def op_sortd_absval_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortd_absval_dropzeros([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_absval_dropzeros([]) == []\nassert op_sortd_absval_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_sortd_absval_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_absval_dropzeros([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_absval_dropzeros([10]) == [10]\nassert op_sortd_absval_dropzeros([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_absval_dropzeros([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_negate_evens_uniq", "entry_point": "op_negate_evens_uniq", "primitives": ["negate", "evens", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers, then drop duplicates keeping first occurrence.", "solution": "def op_negate_evens_uniq(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_negate_evens_uniq([1, 2, 3, 4]) == [-2, -4]\nassert op_negate_evens_uniq([]) == []\nassert op_negate_evens_uniq([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_evens_uniq([5, 5, 5]) == []\nassert op_negate_evens_uniq([3, 1, 2]) == [-2]\nassert op_negate_evens_uniq([10]) == [-10]\nassert op_negate_evens_uniq([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_evens_uniq([-7, 12, -7]) == [-12]"}
{"id": "op_oremptyzero_padto3_min", "entry_point": "op_oremptyzero_padto3_min", "primitives": ["oremptyzero", "padto3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_oremptyzero_padto3_min(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_oremptyzero_padto3_min([1, 2, 3, 4]) == 1\nassert op_oremptyzero_padto3_min([]) == 0\nassert op_oremptyzero_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_oremptyzero_padto3_min([5, 5, 5]) == 5\nassert op_oremptyzero_padto3_min([3, 1, 2]) == 1\nassert op_oremptyzero_padto3_min([10]) == 0\nassert op_oremptyzero_padto3_min([2, 4, 6]) == 2\nassert op_oremptyzero_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_takewhilepos_sortd_inc", "entry_point": "op_takewhilepos_sortd_inc", "primitives": ["takewhilepos", "sortd", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort descending, then add one to each.", "solution": "def op_takewhilepos_sortd_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_sortd_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_takewhilepos_sortd_inc([]) == []\nassert op_takewhilepos_sortd_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortd_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_sortd_inc([3, 1, 2]) == [4, 3, 2]\nassert op_takewhilepos_sortd_inc([10]) == [11]\nassert op_takewhilepos_sortd_inc([2, 4, 6]) == [7, 5, 3]\nassert op_takewhilepos_sortd_inc([-7, 12, -7]) == []"}
{"id": "op_inc_sorta_takewhilepos", "entry_point": "op_inc_sorta_takewhilepos", "primitives": ["inc", "sorta", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then take values while they are positive.", "solution": "def op_inc_sorta_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_sorta_takewhilepos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sorta_takewhilepos([]) == []\nassert op_inc_sorta_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_sorta_takewhilepos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sorta_takewhilepos([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sorta_takewhilepos([10]) == [11]\nassert op_inc_sorta_takewhilepos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_gt5_trimends_sum", "entry_point": "op_gt5_trimends_sum", "primitives": ["gt5", "trimends", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then return their sum.", "solution": "def op_gt5_trimends_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return sum(r)", "tests": "assert op_gt5_trimends_sum([1, 2, 3, 4]) == 0\nassert op_gt5_trimends_sum([]) == 0\nassert op_gt5_trimends_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_trimends_sum([5, 5, 5]) == 0\nassert op_gt5_trimends_sum([3, 1, 2]) == 0\nassert op_gt5_trimends_sum([10]) == 0\nassert op_gt5_trimends_sum([2, 4, 6]) == 0\nassert op_gt5_trimends_sum([-7, 12, -7]) == 0"}
{"id": "op_trimends_sortabs_sum", "entry_point": "op_trimends_sortabs_sum", "primitives": ["trimends", "sortabs", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort by absolute value, then return their sum.", "solution": "def op_trimends_sortabs_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return sum(r)", "tests": "assert op_trimends_sortabs_sum([1, 2, 3, 4]) == 5\nassert op_trimends_sortabs_sum([]) == 0\nassert op_trimends_sortabs_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_sortabs_sum([5, 5, 5]) == 5\nassert op_trimends_sortabs_sum([3, 1, 2]) == 1\nassert op_trimends_sortabs_sum([10]) == 0\nassert op_trimends_sortabs_sum([2, 4, 6]) == 4\nassert op_trimends_sortabs_sum([-7, 12, -7]) == 12"}
{"id": "op_div3_uniq_first3", "entry_point": "op_div3_uniq_first3", "primitives": ["div3", "uniq", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then keep only the first three.", "solution": "def op_div3_uniq_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    return r", "tests": "assert op_div3_uniq_first3([1, 2, 3, 4]) == [3]\nassert op_div3_uniq_first3([]) == []\nassert op_div3_uniq_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_uniq_first3([5, 5, 5]) == []\nassert op_div3_uniq_first3([3, 1, 2]) == [3]\nassert op_div3_uniq_first3([10]) == []\nassert op_div3_uniq_first3([2, 4, 6]) == [6]\nassert op_div3_uniq_first3([-7, 12, -7]) == [12]"}
{"id": "op_last3_evens_prod", "entry_point": "op_last3_evens_prod", "primitives": ["last3", "evens", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers, then return their product.", "solution": "def op_last3_evens_prod(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_last3_evens_prod([1, 2, 3, 4]) == 8\nassert op_last3_evens_prod([]) == 1\nassert op_last3_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_last3_evens_prod([5, 5, 5]) == 1\nassert op_last3_evens_prod([3, 1, 2]) == 2\nassert op_last3_evens_prod([10]) == 10\nassert op_last3_evens_prod([2, 4, 6]) == 48\nassert op_last3_evens_prod([-7, 12, -7]) == 12"}
{"id": "op_neg_inc_negate", "entry_point": "op_neg_inc_negate", "primitives": ["neg", "inc", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then negate each.", "solution": "def op_neg_inc_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_neg_inc_negate([1, 2, 3, 4]) == []\nassert op_neg_inc_negate([]) == []\nassert op_neg_inc_negate([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_neg_inc_negate([5, 5, 5]) == []\nassert op_neg_inc_negate([3, 1, 2]) == []\nassert op_neg_inc_negate([10]) == []\nassert op_neg_inc_negate([2, 4, 6]) == []\nassert op_neg_inc_negate([-7, 12, -7]) == [6, 6]"}
{"id": "op_clamp10_trimends_rev", "entry_point": "op_clamp10_trimends_rev", "primitives": ["clamp10", "trimends", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then reverse the order.", "solution": "def op_clamp10_trimends_rev(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_clamp10_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_clamp10_trimends_rev([]) == []\nassert op_clamp10_trimends_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_clamp10_trimends_rev([5, 5, 5]) == [5]\nassert op_clamp10_trimends_rev([3, 1, 2]) == [1]\nassert op_clamp10_trimends_rev([10]) == []\nassert op_clamp10_trimends_rev([2, 4, 6]) == [4]\nassert op_clamp10_trimends_rev([-7, 12, -7]) == [10]"}
{"id": "op_negate_sorta_sum", "entry_point": "op_negate_sorta_sum", "primitives": ["negate", "sorta", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then return their sum.", "solution": "def op_negate_sorta_sum(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    return sum(r)", "tests": "assert op_negate_sorta_sum([1, 2, 3, 4]) == -10\nassert op_negate_sorta_sum([]) == 0\nassert op_negate_sorta_sum([-2, -1, 0, 1, 2]) == 0\nassert op_negate_sorta_sum([5, 5, 5]) == -15\nassert op_negate_sorta_sum([3, 1, 2]) == -6\nassert op_negate_sorta_sum([10]) == -10\nassert op_negate_sorta_sum([2, 4, 6]) == -12\nassert op_negate_sorta_sum([-7, 12, -7]) == 2"}
{"id": "op_padto3_double_dropwhileneg", "entry_point": "op_padto3_double_dropwhileneg", "primitives": ["padto3", "double", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then drop the leading negative values.", "solution": "def op_padto3_double_dropwhileneg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_padto3_double_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_padto3_double_dropwhileneg([]) == [0, 0, 0]\nassert op_padto3_double_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_padto3_double_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double_dropwhileneg([3, 1, 2]) == [6, 2, 4]\nassert op_padto3_double_dropwhileneg([10]) == [20, 0, 0]\nassert op_padto3_double_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_padto3_double_dropwhileneg([-7, 12, -7]) == [24, -14]"}
{"id": "op_takewhilepos_add10_sortabs", "entry_point": "op_takewhilepos_add10_sortabs", "primitives": ["takewhilepos", "add10", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then add ten to each, then sort by absolute value.", "solution": "def op_takewhilepos_add10_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_add10_sortabs([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_takewhilepos_add10_sortabs([]) == []\nassert op_takewhilepos_add10_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_add10_sortabs([5, 5, 5]) == [15, 15, 15]\nassert op_takewhilepos_add10_sortabs([3, 1, 2]) == [11, 12, 13]\nassert op_takewhilepos_add10_sortabs([10]) == [20]\nassert op_takewhilepos_add10_sortabs([2, 4, 6]) == [12, 14, 16]\nassert op_takewhilepos_add10_sortabs([-7, 12, -7]) == []"}
{"id": "op_div3_evens_len", "entry_point": "op_div3_evens_len", "primitives": ["div3", "evens", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then return how many remain.", "solution": "def op_div3_evens_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    return len(r)", "tests": "assert op_div3_evens_len([1, 2, 3, 4]) == 0\nassert op_div3_evens_len([]) == 0\nassert op_div3_evens_len([-2, -1, 0, 1, 2]) == 1\nassert op_div3_evens_len([5, 5, 5]) == 0\nassert op_div3_evens_len([3, 1, 2]) == 0\nassert op_div3_evens_len([10]) == 0\nassert op_div3_evens_len([2, 4, 6]) == 1\nassert op_div3_evens_len([-7, 12, -7]) == 1"}
{"id": "op_pos_double_neg", "entry_point": "op_pos_double_neg", "primitives": ["pos", "double", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then keep the negative numbers.", "solution": "def op_pos_double_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_pos_double_neg([1, 2, 3, 4]) == []\nassert op_pos_double_neg([]) == []\nassert op_pos_double_neg([-2, -1, 0, 1, 2]) == []\nassert op_pos_double_neg([5, 5, 5]) == []\nassert op_pos_double_neg([3, 1, 2]) == []\nassert op_pos_double_neg([10]) == []\nassert op_pos_double_neg([2, 4, 6]) == []\nassert op_pos_double_neg([-7, 12, -7]) == []"}
{"id": "op_padto3_sortabs_negate", "entry_point": "op_padto3_sortabs_negate", "primitives": ["padto3", "sortabs", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort by absolute value, then negate each.", "solution": "def op_padto3_sortabs_negate(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_padto3_sortabs_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_padto3_sortabs_negate([]) == [0, 0, 0]\nassert op_padto3_sortabs_negate([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_padto3_sortabs_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_padto3_sortabs_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_padto3_sortabs_negate([10]) == [0, 0, -10]\nassert op_padto3_sortabs_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_padto3_sortabs_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_beforezero_sorta_len", "entry_point": "op_beforezero_sorta_len", "primitives": ["beforezero", "sorta", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then return how many remain.", "solution": "def op_beforezero_sorta_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    return len(r)", "tests": "assert op_beforezero_sorta_len([1, 2, 3, 4]) == 4\nassert op_beforezero_sorta_len([]) == 0\nassert op_beforezero_sorta_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_sorta_len([5, 5, 5]) == 3\nassert op_beforezero_sorta_len([3, 1, 2]) == 3\nassert op_beforezero_sorta_len([10]) == 1\nassert op_beforezero_sorta_len([2, 4, 6]) == 3\nassert op_beforezero_sorta_len([-7, 12, -7]) == 3"}
{"id": "op_dropzeros_dropwhileneg_last3", "entry_point": "op_dropzeros_dropwhileneg_last3", "primitives": ["dropzeros", "dropwhileneg", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then keep only the last three.", "solution": "def op_dropzeros_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropwhileneg_last3([]) == []\nassert op_dropzeros_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_dropwhileneg_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_dropwhileneg_last3([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_dropwhileneg_last3([10]) == [10]\nassert op_dropzeros_dropwhileneg_last3([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_dropwhileneg_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_sorta_dec_sortd", "entry_point": "op_sorta_dec_sortd", "primitives": ["sorta", "dec", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then sort descending.", "solution": "def op_sorta_dec_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_dec_sortd([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sorta_dec_sortd([]) == []\nassert op_sorta_dec_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_sorta_dec_sortd([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_dec_sortd([3, 1, 2]) == [2, 1, 0]\nassert op_sorta_dec_sortd([10]) == [9]\nassert op_sorta_dec_sortd([2, 4, 6]) == [5, 3, 1]\nassert op_sorta_dec_sortd([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_inc_dropwhileneg_square", "entry_point": "op_inc_dropwhileneg_square", "primitives": ["inc", "dropwhileneg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the leading negative values, then square each.", "solution": "def op_inc_dropwhileneg_square(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_inc_dropwhileneg_square([1, 2, 3, 4]) == [4, 9, 16, 25]\nassert op_inc_dropwhileneg_square([]) == []\nassert op_inc_dropwhileneg_square([-2, -1, 0, 1, 2]) == [0, 1, 4, 9]\nassert op_inc_dropwhileneg_square([5, 5, 5]) == [36, 36, 36]\nassert op_inc_dropwhileneg_square([3, 1, 2]) == [16, 4, 9]\nassert op_inc_dropwhileneg_square([10]) == [121]\nassert op_inc_dropwhileneg_square([2, 4, 6]) == [9, 25, 49]\nassert op_inc_dropwhileneg_square([-7, 12, -7]) == [169, 36]"}
{"id": "op_square_takewhilepos_sortabs", "entry_point": "op_square_takewhilepos_sortabs", "primitives": ["square", "takewhilepos", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then sort by absolute value.", "solution": "def op_square_takewhilepos_sortabs(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_square_takewhilepos_sortabs([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_takewhilepos_sortabs([]) == []\nassert op_square_takewhilepos_sortabs([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_square_takewhilepos_sortabs([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_sortabs([3, 1, 2]) == [1, 4, 9]\nassert op_square_takewhilepos_sortabs([10]) == [100]\nassert op_square_takewhilepos_sortabs([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_sortabs([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_gt5_dropzeros_issorted", "entry_point": "op_gt5_dropzeros_issorted", "primitives": ["gt5", "dropzeros", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_gt5_dropzeros_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_gt5_dropzeros_issorted([1, 2, 3, 4]) == True\nassert op_gt5_dropzeros_issorted([]) == True\nassert op_gt5_dropzeros_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_dropzeros_issorted([5, 5, 5]) == True\nassert op_gt5_dropzeros_issorted([3, 1, 2]) == True\nassert op_gt5_dropzeros_issorted([10]) == True\nassert op_gt5_dropzeros_issorted([2, 4, 6]) == True\nassert op_gt5_dropzeros_issorted([-7, 12, -7]) == True"}
{"id": "op_uniq_last3_issorted", "entry_point": "op_uniq_last3_issorted", "primitives": ["uniq", "last3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the last three, then return whether the list is sorted ascending.", "solution": "def op_uniq_last3_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[-3:]\n    return r == sorted(r)", "tests": "assert op_uniq_last3_issorted([1, 2, 3, 4]) == True\nassert op_uniq_last3_issorted([]) == True\nassert op_uniq_last3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_last3_issorted([5, 5, 5]) == True\nassert op_uniq_last3_issorted([3, 1, 2]) == False\nassert op_uniq_last3_issorted([10]) == True\nassert op_uniq_last3_issorted([2, 4, 6]) == True\nassert op_uniq_last3_issorted([-7, 12, -7]) == True"}
{"id": "op_neg_sortd_anyeven", "entry_point": "op_neg_sortd_anyeven", "primitives": ["neg", "sortd", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort descending, then return whether any value is even.", "solution": "def op_neg_sortd_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_neg_sortd_anyeven([1, 2, 3, 4]) == False\nassert op_neg_sortd_anyeven([]) == False\nassert op_neg_sortd_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_neg_sortd_anyeven([5, 5, 5]) == False\nassert op_neg_sortd_anyeven([3, 1, 2]) == False\nassert op_neg_sortd_anyeven([10]) == False\nassert op_neg_sortd_anyeven([2, 4, 6]) == False\nassert op_neg_sortd_anyeven([-7, 12, -7]) == False"}
{"id": "op_negate_beforezero_rev", "entry_point": "op_negate_beforezero_rev", "primitives": ["negate", "beforezero", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then reverse the order.", "solution": "def op_negate_beforezero_rev(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_negate_beforezero_rev([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_negate_beforezero_rev([]) == []\nassert op_negate_beforezero_rev([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_negate_beforezero_rev([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_beforezero_rev([3, 1, 2]) == [-2, -1, -3]\nassert op_negate_beforezero_rev([10]) == [-10]\nassert op_negate_beforezero_rev([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_beforezero_rev([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_add10_odds_counteven", "entry_point": "op_add10_odds_counteven", "primitives": ["add10", "odds", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then return how many values are even.", "solution": "def op_add10_odds_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_odds_counteven([1, 2, 3, 4]) == 0\nassert op_add10_odds_counteven([]) == 0\nassert op_add10_odds_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_add10_odds_counteven([5, 5, 5]) == 0\nassert op_add10_odds_counteven([3, 1, 2]) == 0\nassert op_add10_odds_counteven([10]) == 0\nassert op_add10_odds_counteven([2, 4, 6]) == 0\nassert op_add10_odds_counteven([-7, 12, -7]) == 0"}
{"id": "op_trimends_dec_dropzeros", "entry_point": "op_trimends_dec_dropzeros", "primitives": ["trimends", "dec", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then subtract one from each, then drop the zeros.", "solution": "def op_trimends_dec_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_dec_dropzeros([1, 2, 3, 4]) == [1, 2]\nassert op_trimends_dec_dropzeros([]) == []\nassert op_trimends_dec_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_trimends_dec_dropzeros([5, 5, 5]) == [4]\nassert op_trimends_dec_dropzeros([3, 1, 2]) == []\nassert op_trimends_dec_dropzeros([10]) == []\nassert op_trimends_dec_dropzeros([2, 4, 6]) == [3]\nassert op_trimends_dec_dropzeros([-7, 12, -7]) == [11]"}
{"id": "op_upper_dropshort_lower", "entry_point": "op_upper_dropshort_lower", "primitives": ["upper", "dropshort", "lower"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop strings shorter than three characters, then lowercase each string.", "solution": "def op_upper_dropshort_lower(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_upper_dropshort_lower(['Hello', 'world']) == ['hello', 'world']\nassert op_upper_dropshort_lower([]) == []\nassert op_upper_dropshort_lower(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_upper_dropshort_lower(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_upper_dropshort_lower(['x']) == []\nassert op_upper_dropshort_lower(['abc', 'de', '']) == ['abc']"}
{"id": "op_first3_rev_counteven", "entry_point": "op_first3_rev_counteven", "primitives": ["first3", "rev", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then return how many values are even.", "solution": "def op_first3_rev_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_rev_counteven([1, 2, 3, 4]) == 1\nassert op_first3_rev_counteven([]) == 0\nassert op_first3_rev_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_rev_counteven([5, 5, 5]) == 0\nassert op_first3_rev_counteven([3, 1, 2]) == 1\nassert op_first3_rev_counteven([10]) == 1\nassert op_first3_rev_counteven([2, 4, 6]) == 3\nassert op_first3_rev_counteven([-7, 12, -7]) == 1"}
{"id": "op_gt5_padto3_dropzeros", "entry_point": "op_gt5_padto3_dropzeros", "primitives": ["gt5", "padto3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then drop the zeros.", "solution": "def op_gt5_padto3_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_gt5_padto3_dropzeros([1, 2, 3, 4]) == []\nassert op_gt5_padto3_dropzeros([]) == []\nassert op_gt5_padto3_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_gt5_padto3_dropzeros([5, 5, 5]) == []\nassert op_gt5_padto3_dropzeros([3, 1, 2]) == []\nassert op_gt5_padto3_dropzeros([10]) == [10]\nassert op_gt5_padto3_dropzeros([2, 4, 6]) == [6]\nassert op_gt5_padto3_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_strip_sortalpha_joinc", "entry_point": "op_strip_sortalpha_joinc", "primitives": ["strip", "sortalpha", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort alphabetically, then join them with commas.", "solution": "def op_strip_sortalpha_joinc(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r)\n    return ','.join(r)", "tests": "assert op_strip_sortalpha_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_strip_sortalpha_joinc([]) == ''\nassert op_strip_sortalpha_joinc(['  a ', '', 'BC', 'bc']) == ',BC,a,bc'\nassert op_strip_sortalpha_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_strip_sortalpha_joinc(['x']) == 'x'\nassert op_strip_sortalpha_joinc(['abc', 'de', '']) == ',abc,de'"}
{"id": "op_add10_double_negate", "entry_point": "op_add10_double_negate", "primitives": ["add10", "double", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then double each, then negate each.", "solution": "def op_add10_double_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_double_negate([1, 2, 3, 4]) == [-22, -24, -26, -28]\nassert op_add10_double_negate([]) == []\nassert op_add10_double_negate([-2, -1, 0, 1, 2]) == [-16, -18, -20, -22, -24]\nassert op_add10_double_negate([5, 5, 5]) == [-30, -30, -30]\nassert op_add10_double_negate([3, 1, 2]) == [-26, -22, -24]\nassert op_add10_double_negate([10]) == [-40]\nassert op_add10_double_negate([2, 4, 6]) == [-24, -28, -32]\nassert op_add10_double_negate([-7, 12, -7]) == [-6, -44, -6]"}
{"id": "op_evens_clamp10_padto3", "entry_point": "op_evens_clamp10_padto3", "primitives": ["evens", "clamp10", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_evens_clamp10_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_evens_clamp10_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_evens_clamp10_padto3([]) == [0, 0, 0]\nassert op_evens_clamp10_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_clamp10_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_evens_clamp10_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_evens_clamp10_padto3([10]) == [10, 0, 0]\nassert op_evens_clamp10_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_clamp10_padto3([-7, 12, -7]) == [10, 0, 0]"}
{"id": "op_beforezero_first3_len", "entry_point": "op_beforezero_first3_len", "primitives": ["beforezero", "first3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then return how many remain.", "solution": "def op_beforezero_first3_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return len(r)", "tests": "assert op_beforezero_first3_len([1, 2, 3, 4]) == 3\nassert op_beforezero_first3_len([]) == 0\nassert op_beforezero_first3_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_first3_len([5, 5, 5]) == 3\nassert op_beforezero_first3_len([3, 1, 2]) == 3\nassert op_beforezero_first3_len([10]) == 1\nassert op_beforezero_first3_len([2, 4, 6]) == 3\nassert op_beforezero_first3_len([-7, 12, -7]) == 3"}
{"id": "op_first3_oremptyzero_last3", "entry_point": "op_first3_oremptyzero_last3", "primitives": ["first3", "oremptyzero", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then keep only the last three.", "solution": "def op_first3_oremptyzero_last3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_first3_oremptyzero_last3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_oremptyzero_last3([]) == [0]\nassert op_first3_oremptyzero_last3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_oremptyzero_last3([5, 5, 5]) == [5, 5, 5]\nassert op_first3_oremptyzero_last3([3, 1, 2]) == [3, 1, 2]\nassert op_first3_oremptyzero_last3([10]) == [10]\nassert op_first3_oremptyzero_last3([2, 4, 6]) == [2, 4, 6]\nassert op_first3_oremptyzero_last3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_uniq_sortd_takewhilepos", "entry_point": "op_uniq_sortd_takewhilepos", "primitives": ["uniq", "sortd", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then take values while they are positive.", "solution": "def op_uniq_sortd_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_sortd_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_uniq_sortd_takewhilepos([]) == []\nassert op_uniq_sortd_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_uniq_sortd_takewhilepos([5, 5, 5]) == [5]\nassert op_uniq_sortd_takewhilepos([3, 1, 2]) == [3, 2, 1]\nassert op_uniq_sortd_takewhilepos([10]) == [10]\nassert op_uniq_sortd_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_uniq_sortd_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_odds_beforezero_takewhilepos", "entry_point": "op_odds_beforezero_takewhilepos", "primitives": ["odds", "beforezero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_odds_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_odds_beforezero_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_odds_beforezero_takewhilepos([]) == []\nassert op_odds_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_odds_beforezero_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_odds_beforezero_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_odds_beforezero_takewhilepos([10]) == []\nassert op_odds_beforezero_takewhilepos([2, 4, 6]) == []\nassert op_odds_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sorta_absval_oremptyzero", "entry_point": "op_sorta_absval_oremptyzero", "primitives": ["sorta", "absval", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then if empty, use a single zero.", "solution": "def op_sorta_absval_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_sorta_absval_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_absval_oremptyzero([]) == [0]\nassert op_sorta_absval_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_sorta_absval_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_absval_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_absval_oremptyzero([10]) == [10]\nassert op_sorta_absval_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_absval_oremptyzero([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_prefixup_dropshort_joinc", "entry_point": "op_prefixup_dropshort_joinc", "primitives": ["prefixup", "dropshort", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then drop strings shorter than three characters, then join them with commas.", "solution": "def op_prefixup_dropshort_joinc(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return ','.join(r)", "tests": "assert op_prefixup_dropshort_joinc(['Hello', 'world']) == '#Hello,#world'\nassert op_prefixup_dropshort_joinc([]) == ''\nassert op_prefixup_dropshort_joinc(['  a ', '', 'BC', 'bc']) == '#  a ,#BC,#bc'\nassert op_prefixup_dropshort_joinc(['one', 'one', 'Two']) == '#one,#one,#Two'\nassert op_prefixup_dropshort_joinc(['x']) == ''\nassert op_prefixup_dropshort_joinc(['abc', 'de', '']) == '#abc,#de'"}
{"id": "op_beforezero_first3_uniq", "entry_point": "op_beforezero_first3_uniq", "primitives": ["beforezero", "first3", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_beforezero_first3_uniq(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_beforezero_first3_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_uniq([]) == []\nassert op_beforezero_first3_uniq([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_first3_uniq([5, 5, 5]) == [5]\nassert op_beforezero_first3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_uniq([10]) == [10]\nassert op_beforezero_first3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_odds_dropfirst_square", "entry_point": "op_odds_dropfirst_square", "primitives": ["odds", "dropfirst", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element, then square each.", "solution": "def op_odds_dropfirst_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_odds_dropfirst_square([1, 2, 3, 4]) == [9]\nassert op_odds_dropfirst_square([]) == []\nassert op_odds_dropfirst_square([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropfirst_square([5, 5, 5]) == [25, 25]\nassert op_odds_dropfirst_square([3, 1, 2]) == [1]\nassert op_odds_dropfirst_square([10]) == []\nassert op_odds_dropfirst_square([2, 4, 6]) == []\nassert op_odds_dropfirst_square([-7, 12, -7]) == [49]"}
{"id": "op_dropzeros_dropfirst_dropwhileneg", "entry_point": "op_dropzeros_dropfirst_dropwhileneg", "primitives": ["dropzeros", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the first element, then drop the leading negative values.", "solution": "def op_dropzeros_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropzeros_dropfirst_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropzeros_dropfirst_dropwhileneg([]) == []\nassert op_dropzeros_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst_dropwhileneg([5, 5, 5]) == [5, 5]\nassert op_dropzeros_dropfirst_dropwhileneg([3, 1, 2]) == [1, 2]\nassert op_dropzeros_dropfirst_dropwhileneg([10]) == []\nassert op_dropzeros_dropfirst_dropwhileneg([2, 4, 6]) == [4, 6]\nassert op_dropzeros_dropfirst_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_oremptyzero_dropfirst_first3", "entry_point": "op_oremptyzero_dropfirst_first3", "primitives": ["oremptyzero", "dropfirst", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then keep only the first three.", "solution": "def op_oremptyzero_dropfirst_first3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = r[:3]\n    return r", "tests": "assert op_oremptyzero_dropfirst_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_dropfirst_first3([]) == []\nassert op_oremptyzero_dropfirst_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_oremptyzero_dropfirst_first3([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_dropfirst_first3([3, 1, 2]) == [1, 2]\nassert op_oremptyzero_dropfirst_first3([10]) == []\nassert op_oremptyzero_dropfirst_first3([2, 4, 6]) == [4, 6]\nassert op_oremptyzero_dropfirst_first3([-7, 12, -7]) == [12, -7]"}
{"id": "op_last3_uniq_dropwhileneg", "entry_point": "op_last3_uniq_dropwhileneg", "primitives": ["last3", "uniq", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_last3_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_last3_uniq_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_uniq_dropwhileneg([]) == []\nassert op_last3_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_uniq_dropwhileneg([5, 5, 5]) == [5]\nassert op_last3_uniq_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_last3_uniq_dropwhileneg([10]) == [10]\nassert op_last3_uniq_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_last3_uniq_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_ages_trimends_dropzeros", "entry_point": "op_ages_trimends_dropzeros", "primitives": ["ages", "trimends", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then drop the zeros.", "solution": "def op_ages_trimends_dropzeros(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_ages_trimends_dropzeros([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_dropzeros([]) == []\nassert op_ages_trimends_dropzeros([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_trimends_dropzeros([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sortd_dropwhileneg_last3", "entry_point": "op_sortd_dropwhileneg_last3", "primitives": ["sortd", "dropwhileneg", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the leading negative values, then keep only the last three.", "solution": "def op_sortd_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_sortd_dropwhileneg_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dropwhileneg_last3([]) == []\nassert op_sortd_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_sortd_dropwhileneg_last3([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_dropwhileneg_last3([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_dropwhileneg_last3([10]) == [10]\nassert op_sortd_dropwhileneg_last3([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_dropwhileneg_last3([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_ages_neg_trimends", "entry_point": "op_ages_neg_trimends", "primitives": ["ages", "neg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_ages_neg_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_neg_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_neg_trimends([]) == []\nassert op_ages_neg_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_neg_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_add10_uniq_counteven", "entry_point": "op_add10_uniq_counteven", "primitives": ["add10", "uniq", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_add10_uniq_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_uniq_counteven([1, 2, 3, 4]) == 2\nassert op_add10_uniq_counteven([]) == 0\nassert op_add10_uniq_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_uniq_counteven([5, 5, 5]) == 0\nassert op_add10_uniq_counteven([3, 1, 2]) == 1\nassert op_add10_uniq_counteven([10]) == 1\nassert op_add10_uniq_counteven([2, 4, 6]) == 3\nassert op_add10_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_gt5_beforezero_allpos", "entry_point": "op_gt5_beforezero_allpos", "primitives": ["gt5", "beforezero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep everything before the first zero, then return whether all values are positive.", "solution": "def op_gt5_beforezero_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_beforezero_allpos([1, 2, 3, 4]) == True\nassert op_gt5_beforezero_allpos([]) == True\nassert op_gt5_beforezero_allpos([-2, -1, 0, 1, 2]) == True\nassert op_gt5_beforezero_allpos([5, 5, 5]) == True\nassert op_gt5_beforezero_allpos([3, 1, 2]) == True\nassert op_gt5_beforezero_allpos([10]) == True\nassert op_gt5_beforezero_allpos([2, 4, 6]) == True\nassert op_gt5_beforezero_allpos([-7, 12, -7]) == True"}
{"id": "op_inc_gt5_beforezero", "entry_point": "op_inc_gt5_beforezero", "primitives": ["inc", "gt5", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_inc_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_inc_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_inc_gt5_beforezero([]) == []\nassert op_inc_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_inc_gt5_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_gt5_beforezero([3, 1, 2]) == []\nassert op_inc_gt5_beforezero([10]) == [11]\nassert op_inc_gt5_beforezero([2, 4, 6]) == [7]\nassert op_inc_gt5_beforezero([-7, 12, -7]) == [13]"}
{"id": "op_sortabs_padto3_double", "entry_point": "op_sortabs_padto3_double", "primitives": ["sortabs", "padto3", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then double each.", "solution": "def op_sortabs_padto3_double(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortabs_padto3_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_padto3_double([]) == [0, 0, 0]\nassert op_sortabs_padto3_double([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_sortabs_padto3_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_padto3_double([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_padto3_double([10]) == [20, 0, 0]\nassert op_sortabs_padto3_double([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_padto3_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_dropfirst_last3_clamp10", "entry_point": "op_dropfirst_last3_clamp10", "primitives": ["dropfirst", "last3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then cap each value at 10.", "solution": "def op_dropfirst_last3_clamp10(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropfirst_last3_clamp10([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_last3_clamp10([]) == []\nassert op_dropfirst_last3_clamp10([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropfirst_last3_clamp10([5, 5, 5]) == [5, 5]\nassert op_dropfirst_last3_clamp10([3, 1, 2]) == [1, 2]\nassert op_dropfirst_last3_clamp10([10]) == []\nassert op_dropfirst_last3_clamp10([2, 4, 6]) == [4, 6]\nassert op_dropfirst_last3_clamp10([-7, 12, -7]) == [10, -7]"}
{"id": "op_odds_dropfirst_div3", "entry_point": "op_odds_dropfirst_div3", "primitives": ["odds", "dropfirst", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element, then keep multiples of three.", "solution": "def op_odds_dropfirst_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_dropfirst_div3([1, 2, 3, 4]) == [3]\nassert op_odds_dropfirst_div3([]) == []\nassert op_odds_dropfirst_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_dropfirst_div3([5, 5, 5]) == []\nassert op_odds_dropfirst_div3([3, 1, 2]) == []\nassert op_odds_dropfirst_div3([10]) == []\nassert op_odds_dropfirst_div3([2, 4, 6]) == []\nassert op_odds_dropfirst_div3([-7, 12, -7]) == []"}
{"id": "op_evens_dec_uniq", "entry_point": "op_evens_dec_uniq", "primitives": ["evens", "dec", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then subtract one from each, then drop duplicates keeping first occurrence.", "solution": "def op_evens_dec_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_evens_dec_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_evens_dec_uniq([]) == []\nassert op_evens_dec_uniq([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_evens_dec_uniq([5, 5, 5]) == []\nassert op_evens_dec_uniq([3, 1, 2]) == [1]\nassert op_evens_dec_uniq([10]) == [9]\nassert op_evens_dec_uniq([2, 4, 6]) == [1, 3, 5]\nassert op_evens_dec_uniq([-7, 12, -7]) == [11]"}
{"id": "op_pos_clamp10_gt5", "entry_point": "op_pos_clamp10_gt5", "primitives": ["pos", "clamp10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cap each value at 10, then keep values greater than five.", "solution": "def op_pos_clamp10_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_pos_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_pos_clamp10_gt5([]) == []\nassert op_pos_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_pos_clamp10_gt5([5, 5, 5]) == []\nassert op_pos_clamp10_gt5([3, 1, 2]) == []\nassert op_pos_clamp10_gt5([10]) == [10]\nassert op_pos_clamp10_gt5([2, 4, 6]) == [6]\nassert op_pos_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_div3_first3_counteven", "entry_point": "op_div3_first3_counteven", "primitives": ["div3", "first3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the first three, then return how many values are even.", "solution": "def op_div3_first3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_div3_first3_counteven([1, 2, 3, 4]) == 0\nassert op_div3_first3_counteven([]) == 0\nassert op_div3_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_div3_first3_counteven([5, 5, 5]) == 0\nassert op_div3_first3_counteven([3, 1, 2]) == 0\nassert op_div3_first3_counteven([10]) == 0\nassert op_div3_first3_counteven([2, 4, 6]) == 1\nassert op_div3_first3_counteven([-7, 12, -7]) == 1"}
{"id": "op_clamp10_sortd_counteven", "entry_point": "op_clamp10_sortd_counteven", "primitives": ["clamp10", "sortd", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then return how many values are even.", "solution": "def op_clamp10_sortd_counteven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_clamp10_sortd_counteven([1, 2, 3, 4]) == 2\nassert op_clamp10_sortd_counteven([]) == 0\nassert op_clamp10_sortd_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_clamp10_sortd_counteven([5, 5, 5]) == 0\nassert op_clamp10_sortd_counteven([3, 1, 2]) == 1\nassert op_clamp10_sortd_counteven([10]) == 1\nassert op_clamp10_sortd_counteven([2, 4, 6]) == 3\nassert op_clamp10_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_beforezero_neg_padto3", "entry_point": "op_beforezero_neg_padto3", "primitives": ["beforezero", "neg", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then pad with zeros to at least three elements.", "solution": "def op_beforezero_neg_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_neg_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_beforezero_neg_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([10]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_beforezero_neg_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_uniq_inc_dec", "entry_point": "op_uniq_inc_dec", "primitives": ["uniq", "inc", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add one to each, then subtract one from each.", "solution": "def op_uniq_inc_dec(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_uniq_inc_dec([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_inc_dec([]) == []\nassert op_uniq_inc_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_uniq_inc_dec([5, 5, 5]) == [5]\nassert op_uniq_inc_dec([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_inc_dec([10]) == [10]\nassert op_uniq_inc_dec([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_inc_dec([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dropzeros_dropwhileneg_sum", "entry_point": "op_dropzeros_dropwhileneg_sum", "primitives": ["dropzeros", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then return their sum.", "solution": "def op_dropzeros_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_dropzeros_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_dropzeros_dropwhileneg_sum([]) == 0\nassert op_dropzeros_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 3\nassert op_dropzeros_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_dropzeros_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_dropzeros_dropwhileneg_sum([10]) == 10\nassert op_dropzeros_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_dropzeros_dropwhileneg_sum([-7, 12, -7]) == 5"}
{"id": "op_div3_dropzeros_last3", "entry_point": "op_div3_dropzeros_last3", "primitives": ["div3", "dropzeros", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros, then keep only the last three.", "solution": "def op_div3_dropzeros_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_dropzeros_last3([1, 2, 3, 4]) == [3]\nassert op_div3_dropzeros_last3([]) == []\nassert op_div3_dropzeros_last3([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros_last3([5, 5, 5]) == []\nassert op_div3_dropzeros_last3([3, 1, 2]) == [3]\nassert op_div3_dropzeros_last3([10]) == []\nassert op_div3_dropzeros_last3([2, 4, 6]) == [6]\nassert op_div3_dropzeros_last3([-7, 12, -7]) == [12]"}
{"id": "op_trimends_dropwhileneg_add10", "entry_point": "op_trimends_dropwhileneg_add10", "primitives": ["trimends", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the leading negative values, then add ten to each.", "solution": "def op_trimends_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_dropwhileneg_add10([1, 2, 3, 4]) == [12, 13]\nassert op_trimends_dropwhileneg_add10([]) == []\nassert op_trimends_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [10, 11]\nassert op_trimends_dropwhileneg_add10([5, 5, 5]) == [15]\nassert op_trimends_dropwhileneg_add10([3, 1, 2]) == [11]\nassert op_trimends_dropwhileneg_add10([10]) == []\nassert op_trimends_dropwhileneg_add10([2, 4, 6]) == [14]\nassert op_trimends_dropwhileneg_add10([-7, 12, -7]) == [22]"}
{"id": "op_sortabs_gt5_allpos", "entry_point": "op_sortabs_gt5_allpos", "primitives": ["sortabs", "gt5", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then return whether all values are positive.", "solution": "def op_sortabs_gt5_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_gt5_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_gt5_allpos([]) == True\nassert op_sortabs_gt5_allpos([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_gt5_allpos([5, 5, 5]) == True\nassert op_sortabs_gt5_allpos([3, 1, 2]) == True\nassert op_sortabs_gt5_allpos([10]) == True\nassert op_sortabs_gt5_allpos([2, 4, 6]) == True\nassert op_sortabs_gt5_allpos([-7, 12, -7]) == True"}
{"id": "op_neg_sortabs_padto3", "entry_point": "op_neg_sortabs_padto3", "primitives": ["neg", "sortabs", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_neg_sortabs_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_neg_sortabs_padto3([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([-2, -1, 0, 1, 2]) == [-1, -2, 0]\nassert op_neg_sortabs_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([3, 1, 2]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([10]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_neg_sortabs_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_uniq_evens_trimends", "entry_point": "op_uniq_evens_trimends", "primitives": ["uniq", "evens", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the even numbers, then drop the first and last elements.", "solution": "def op_uniq_evens_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_evens_trimends([1, 2, 3, 4]) == []\nassert op_uniq_evens_trimends([]) == []\nassert op_uniq_evens_trimends([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_evens_trimends([5, 5, 5]) == []\nassert op_uniq_evens_trimends([3, 1, 2]) == []\nassert op_uniq_evens_trimends([10]) == []\nassert op_uniq_evens_trimends([2, 4, 6]) == [4]\nassert op_uniq_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_dropfirst_add10_min", "entry_point": "op_dropfirst_add10_min", "primitives": ["dropfirst", "add10", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_dropfirst_add10_min(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dropfirst_add10_min([1, 2, 3, 4]) == 12\nassert op_dropfirst_add10_min([]) == 0\nassert op_dropfirst_add10_min([-2, -1, 0, 1, 2]) == 9\nassert op_dropfirst_add10_min([5, 5, 5]) == 15\nassert op_dropfirst_add10_min([3, 1, 2]) == 11\nassert op_dropfirst_add10_min([10]) == 0\nassert op_dropfirst_add10_min([2, 4, 6]) == 14\nassert op_dropfirst_add10_min([-7, 12, -7]) == 3"}
{"id": "op_negate_dropfirst_square", "entry_point": "op_negate_dropfirst_square", "primitives": ["negate", "dropfirst", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then square each.", "solution": "def op_negate_dropfirst_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_dropfirst_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_negate_dropfirst_square([]) == []\nassert op_negate_dropfirst_square([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_negate_dropfirst_square([5, 5, 5]) == [25, 25]\nassert op_negate_dropfirst_square([3, 1, 2]) == [1, 4]\nassert op_negate_dropfirst_square([10]) == []\nassert op_negate_dropfirst_square([2, 4, 6]) == [16, 36]\nassert op_negate_dropfirst_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_uniq_negate_pos", "entry_point": "op_uniq_negate_pos", "primitives": ["uniq", "negate", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then keep the positive numbers.", "solution": "def op_uniq_negate_pos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_uniq_negate_pos([1, 2, 3, 4]) == []\nassert op_uniq_negate_pos([]) == []\nassert op_uniq_negate_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_uniq_negate_pos([5, 5, 5]) == []\nassert op_uniq_negate_pos([3, 1, 2]) == []\nassert op_uniq_negate_pos([10]) == []\nassert op_uniq_negate_pos([2, 4, 6]) == []\nassert op_uniq_negate_pos([-7, 12, -7]) == [7]"}
{"id": "op_dec_add10_sum", "entry_point": "op_dec_add10_sum", "primitives": ["dec", "add10", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add ten to each, then return their sum.", "solution": "def op_dec_add10_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return sum(r)", "tests": "assert op_dec_add10_sum([1, 2, 3, 4]) == 46\nassert op_dec_add10_sum([]) == 0\nassert op_dec_add10_sum([-2, -1, 0, 1, 2]) == 45\nassert op_dec_add10_sum([5, 5, 5]) == 42\nassert op_dec_add10_sum([3, 1, 2]) == 33\nassert op_dec_add10_sum([10]) == 19\nassert op_dec_add10_sum([2, 4, 6]) == 39\nassert op_dec_add10_sum([-7, 12, -7]) == 25"}
{"id": "op_uniq_pos_trimends", "entry_point": "op_uniq_pos_trimends", "primitives": ["uniq", "pos", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_uniq_pos_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_pos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_pos_trimends([]) == []\nassert op_uniq_pos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_uniq_pos_trimends([5, 5, 5]) == []\nassert op_uniq_pos_trimends([3, 1, 2]) == [1]\nassert op_uniq_pos_trimends([10]) == []\nassert op_uniq_pos_trimends([2, 4, 6]) == [4]\nassert op_uniq_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_double_dropzeros_issorted", "entry_point": "op_double_dropzeros_issorted", "primitives": ["double", "dropzeros", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_double_dropzeros_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_double_dropzeros_issorted([1, 2, 3, 4]) == True\nassert op_double_dropzeros_issorted([]) == True\nassert op_double_dropzeros_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_dropzeros_issorted([5, 5, 5]) == True\nassert op_double_dropzeros_issorted([3, 1, 2]) == False\nassert op_double_dropzeros_issorted([10]) == True\nassert op_double_dropzeros_issorted([2, 4, 6]) == True\nassert op_double_dropzeros_issorted([-7, 12, -7]) == False"}
{"id": "op_beforezero_inc_counteven", "entry_point": "op_beforezero_inc_counteven", "primitives": ["beforezero", "inc", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then return how many values are even.", "solution": "def op_beforezero_inc_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_inc_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_inc_counteven([]) == 0\nassert op_beforezero_inc_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_inc_counteven([5, 5, 5]) == 3\nassert op_beforezero_inc_counteven([3, 1, 2]) == 2\nassert op_beforezero_inc_counteven([10]) == 0\nassert op_beforezero_inc_counteven([2, 4, 6]) == 0\nassert op_beforezero_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_evens_dropwhileneg_uniq", "entry_point": "op_evens_dropwhileneg_uniq", "primitives": ["evens", "dropwhileneg", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_evens_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_evens_dropwhileneg_uniq([1, 2, 3, 4]) == [2, 4]\nassert op_evens_dropwhileneg_uniq([]) == []\nassert op_evens_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_evens_dropwhileneg_uniq([5, 5, 5]) == []\nassert op_evens_dropwhileneg_uniq([3, 1, 2]) == [2]\nassert op_evens_dropwhileneg_uniq([10]) == [10]\nassert op_evens_dropwhileneg_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_evens_dropwhileneg_uniq([-7, 12, -7]) == [12]"}
{"id": "op_pos_first3_alldistinct", "entry_point": "op_pos_first3_alldistinct", "primitives": ["pos", "first3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep only the first three, then return whether all values are distinct.", "solution": "def op_pos_first3_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return len(r) == len(set(r))", "tests": "assert op_pos_first3_alldistinct([1, 2, 3, 4]) == True\nassert op_pos_first3_alldistinct([]) == True\nassert op_pos_first3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_pos_first3_alldistinct([5, 5, 5]) == False\nassert op_pos_first3_alldistinct([3, 1, 2]) == True\nassert op_pos_first3_alldistinct([10]) == True\nassert op_pos_first3_alldistinct([2, 4, 6]) == True\nassert op_pos_first3_alldistinct([-7, 12, -7]) == True"}
{"id": "op_div3_square_padto3", "entry_point": "op_div3_square_padto3", "primitives": ["div3", "square", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then pad with zeros to at least three elements.", "solution": "def op_div3_square_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_square_padto3([1, 2, 3, 4]) == [9, 0, 0]\nassert op_div3_square_padto3([]) == [0, 0, 0]\nassert op_div3_square_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_square_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_square_padto3([3, 1, 2]) == [9, 0, 0]\nassert op_div3_square_padto3([10]) == [0, 0, 0]\nassert op_div3_square_padto3([2, 4, 6]) == [36, 0, 0]\nassert op_div3_square_padto3([-7, 12, -7]) == [144, 0, 0]"}
{"id": "op_uniq_trimends_first3", "entry_point": "op_uniq_trimends_first3", "primitives": ["uniq", "trimends", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then keep only the first three.", "solution": "def op_uniq_trimends_first3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_uniq_trimends_first3([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_trimends_first3([]) == []\nassert op_uniq_trimends_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_uniq_trimends_first3([5, 5, 5]) == []\nassert op_uniq_trimends_first3([3, 1, 2]) == [1]\nassert op_uniq_trimends_first3([10]) == []\nassert op_uniq_trimends_first3([2, 4, 6]) == [4]\nassert op_uniq_trimends_first3([-7, 12, -7]) == []"}
{"id": "op_ages_dropfirst_double", "entry_point": "op_ages_dropfirst_double", "primitives": ["ages", "dropfirst", "double"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then double each.", "solution": "def op_ages_dropfirst_double(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_ages_dropfirst_double([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [24]\nassert op_ages_dropfirst_double([]) == []\nassert op_ages_dropfirst_double([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [130, 34]\nassert op_ages_dropfirst_double([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_takewhilepos_evens_trimends", "entry_point": "op_takewhilepos_evens_trimends", "primitives": ["takewhilepos", "evens", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the even numbers, then drop the first and last elements.", "solution": "def op_takewhilepos_evens_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_evens_trimends([1, 2, 3, 4]) == []\nassert op_takewhilepos_evens_trimends([]) == []\nassert op_takewhilepos_evens_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_evens_trimends([5, 5, 5]) == []\nassert op_takewhilepos_evens_trimends([3, 1, 2]) == []\nassert op_takewhilepos_evens_trimends([10]) == []\nassert op_takewhilepos_evens_trimends([2, 4, 6]) == [4]\nassert op_takewhilepos_evens_trimends([-7, 12, -7]) == []"}
{"id": "op_sortabs_first3_oremptyzero", "entry_point": "op_sortabs_first3_oremptyzero", "primitives": ["sortabs", "first3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then if empty, use a single zero.", "solution": "def op_sortabs_first3_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortabs_first3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_first3_oremptyzero([]) == [0]\nassert op_sortabs_first3_oremptyzero([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_sortabs_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_first3_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_first3_oremptyzero([10]) == [10]\nassert op_sortabs_first3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_first3_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sorta_takewhilepos_len", "entry_point": "op_sorta_takewhilepos_len", "primitives": ["sorta", "takewhilepos", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then return how many remain.", "solution": "def op_sorta_takewhilepos_len(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_sorta_takewhilepos_len([1, 2, 3, 4]) == 4\nassert op_sorta_takewhilepos_len([]) == 0\nassert op_sorta_takewhilepos_len([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_takewhilepos_len([5, 5, 5]) == 3\nassert op_sorta_takewhilepos_len([3, 1, 2]) == 3\nassert op_sorta_takewhilepos_len([10]) == 1\nassert op_sorta_takewhilepos_len([2, 4, 6]) == 3\nassert op_sorta_takewhilepos_len([-7, 12, -7]) == 0"}
{"id": "op_beforezero_dropfirst_haszero", "entry_point": "op_beforezero_dropfirst_haszero", "primitives": ["beforezero", "dropfirst", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then return whether the list contains a zero.", "solution": "def op_beforezero_dropfirst_haszero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    return 0 in r", "tests": "assert op_beforezero_dropfirst_haszero([1, 2, 3, 4]) == False\nassert op_beforezero_dropfirst_haszero([]) == False\nassert op_beforezero_dropfirst_haszero([-2, -1, 0, 1, 2]) == False\nassert op_beforezero_dropfirst_haszero([5, 5, 5]) == False\nassert op_beforezero_dropfirst_haszero([3, 1, 2]) == False\nassert op_beforezero_dropfirst_haszero([10]) == False\nassert op_beforezero_dropfirst_haszero([2, 4, 6]) == False\nassert op_beforezero_dropfirst_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_absval_div3", "entry_point": "op_dec_absval_div3", "primitives": ["dec", "absval", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then keep multiples of three.", "solution": "def op_dec_absval_div3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dec_absval_div3([1, 2, 3, 4]) == [0, 3]\nassert op_dec_absval_div3([]) == []\nassert op_dec_absval_div3([-2, -1, 0, 1, 2]) == [3, 0]\nassert op_dec_absval_div3([5, 5, 5]) == []\nassert op_dec_absval_div3([3, 1, 2]) == [0]\nassert op_dec_absval_div3([10]) == [9]\nassert op_dec_absval_div3([2, 4, 6]) == [3]\nassert op_dec_absval_div3([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_sortabs_add10", "entry_point": "op_dropwhileneg_sortabs_add10", "primitives": ["dropwhileneg", "sortabs", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then add ten to each.", "solution": "def op_dropwhileneg_sortabs_add10(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dropwhileneg_sortabs_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_sortabs_add10([]) == []\nassert op_dropwhileneg_sortabs_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_sortabs_add10([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_sortabs_add10([3, 1, 2]) == [11, 12, 13]\nassert op_dropwhileneg_sortabs_add10([10]) == [20]\nassert op_dropwhileneg_sortabs_add10([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_sortabs_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_inc_padto3_oremptyzero", "entry_point": "op_inc_padto3_oremptyzero", "primitives": ["inc", "padto3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_inc_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_padto3_oremptyzero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_inc_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_inc_padto3_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_padto3_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_inc_padto3_oremptyzero([10]) == [11, 0, 0]\nassert op_inc_padto3_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_padto3_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_pos_sortd_anyeven", "entry_point": "op_pos_sortd_anyeven", "primitives": ["pos", "sortd", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then sort descending, then return whether any value is even.", "solution": "def op_pos_sortd_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = sorted(r, reverse=True)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_pos_sortd_anyeven([1, 2, 3, 4]) == True\nassert op_pos_sortd_anyeven([]) == False\nassert op_pos_sortd_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_pos_sortd_anyeven([5, 5, 5]) == False\nassert op_pos_sortd_anyeven([3, 1, 2]) == True\nassert op_pos_sortd_anyeven([10]) == True\nassert op_pos_sortd_anyeven([2, 4, 6]) == True\nassert op_pos_sortd_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_takewhilepos_odds", "entry_point": "op_last3_takewhilepos_odds", "primitives": ["last3", "takewhilepos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take values while they are positive, then keep the odd numbers.", "solution": "def op_last3_takewhilepos_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_takewhilepos_odds([1, 2, 3, 4]) == [3]\nassert op_last3_takewhilepos_odds([]) == []\nassert op_last3_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_last3_takewhilepos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_last3_takewhilepos_odds([3, 1, 2]) == [3, 1]\nassert op_last3_takewhilepos_odds([10]) == []\nassert op_last3_takewhilepos_odds([2, 4, 6]) == []\nassert op_last3_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_evens_oremptyzero_max", "entry_point": "op_evens_oremptyzero_max", "primitives": ["evens", "oremptyzero", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_evens_oremptyzero_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_evens_oremptyzero_max([1, 2, 3, 4]) == 4\nassert op_evens_oremptyzero_max([]) == 0\nassert op_evens_oremptyzero_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_oremptyzero_max([5, 5, 5]) == 0\nassert op_evens_oremptyzero_max([3, 1, 2]) == 2\nassert op_evens_oremptyzero_max([10]) == 10\nassert op_evens_oremptyzero_max([2, 4, 6]) == 6\nassert op_evens_oremptyzero_max([-7, 12, -7]) == 12"}
{"id": "op_oremptyzero_dropfirst_odds", "entry_point": "op_oremptyzero_dropfirst_odds", "primitives": ["oremptyzero", "dropfirst", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first element, then keep the odd numbers.", "solution": "def op_oremptyzero_dropfirst_odds(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_oremptyzero_dropfirst_odds([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_dropfirst_odds([]) == []\nassert op_oremptyzero_dropfirst_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_dropfirst_odds([5, 5, 5]) == [5, 5]\nassert op_oremptyzero_dropfirst_odds([3, 1, 2]) == [1]\nassert op_oremptyzero_dropfirst_odds([10]) == []\nassert op_oremptyzero_dropfirst_odds([2, 4, 6]) == []\nassert op_oremptyzero_dropfirst_odds([-7, 12, -7]) == [-7]"}
{"id": "op_absval_last3_beforezero", "entry_point": "op_absval_last3_beforezero", "primitives": ["absval", "last3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then keep everything before the first zero.", "solution": "def op_absval_last3_beforezero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_absval_last3_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_absval_last3_beforezero([]) == []\nassert op_absval_last3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_absval_last3_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_absval_last3_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_absval_last3_beforezero([10]) == [10]\nassert op_absval_last3_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_absval_last3_beforezero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_beforezero_gt5_sorta", "entry_point": "op_beforezero_gt5_sorta", "primitives": ["beforezero", "gt5", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then sort ascending.", "solution": "def op_beforezero_gt5_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_gt5_sorta([1, 2, 3, 4]) == []\nassert op_beforezero_gt5_sorta([]) == []\nassert op_beforezero_gt5_sorta([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5_sorta([5, 5, 5]) == []\nassert op_beforezero_gt5_sorta([3, 1, 2]) == []\nassert op_beforezero_gt5_sorta([10]) == [10]\nassert op_beforezero_gt5_sorta([2, 4, 6]) == [6]\nassert op_beforezero_gt5_sorta([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_square_last3", "entry_point": "op_clamp10_square_last3", "primitives": ["clamp10", "square", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then keep only the last three.", "solution": "def op_clamp10_square_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_square_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_clamp10_square_last3([]) == []\nassert op_clamp10_square_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_clamp10_square_last3([5, 5, 5]) == [25, 25, 25]\nassert op_clamp10_square_last3([3, 1, 2]) == [9, 1, 4]\nassert op_clamp10_square_last3([10]) == [100]\nassert op_clamp10_square_last3([2, 4, 6]) == [4, 16, 36]\nassert op_clamp10_square_last3([-7, 12, -7]) == [49, 100, 49]"}
{"id": "op_sortd_square_dropfirst", "entry_point": "op_sortd_square_dropfirst", "primitives": ["sortd", "square", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then drop the first element.", "solution": "def op_sortd_square_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sortd_square_dropfirst([1, 2, 3, 4]) == [9, 4, 1]\nassert op_sortd_square_dropfirst([]) == []\nassert op_sortd_square_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_sortd_square_dropfirst([5, 5, 5]) == [25, 25]\nassert op_sortd_square_dropfirst([3, 1, 2]) == [4, 1]\nassert op_sortd_square_dropfirst([10]) == []\nassert op_sortd_square_dropfirst([2, 4, 6]) == [16, 4]\nassert op_sortd_square_dropfirst([-7, 12, -7]) == [49, 49]"}
{"id": "op_first3_pos_prod", "entry_point": "op_first3_pos_prod", "primitives": ["first3", "pos", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then return their product.", "solution": "def op_first3_pos_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return __import__('math').prod(r)", "tests": "assert op_first3_pos_prod([1, 2, 3, 4]) == 6\nassert op_first3_pos_prod([]) == 1\nassert op_first3_pos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_first3_pos_prod([5, 5, 5]) == 125\nassert op_first3_pos_prod([3, 1, 2]) == 6\nassert op_first3_pos_prod([10]) == 10\nassert op_first3_pos_prod([2, 4, 6]) == 48\nassert op_first3_pos_prod([-7, 12, -7]) == 12"}
{"id": "op_first3_clamp10_beforezero", "entry_point": "op_first3_clamp10_beforezero", "primitives": ["first3", "clamp10", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then keep everything before the first zero.", "solution": "def op_first3_clamp10_beforezero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_first3_clamp10_beforezero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_clamp10_beforezero([]) == []\nassert op_first3_clamp10_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_first3_clamp10_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_first3_clamp10_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_clamp10_beforezero([10]) == [10]\nassert op_first3_clamp10_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_clamp10_beforezero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_absval_dropwhileneg_anyeven", "entry_point": "op_absval_dropwhileneg_anyeven", "primitives": ["absval", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then return whether any value is even.", "solution": "def op_absval_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_absval_dropwhileneg_anyeven([1, 2, 3, 4]) == True\nassert op_absval_dropwhileneg_anyeven([]) == False\nassert op_absval_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_absval_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_absval_dropwhileneg_anyeven([3, 1, 2]) == True\nassert op_absval_dropwhileneg_anyeven([10]) == True\nassert op_absval_dropwhileneg_anyeven([2, 4, 6]) == True\nassert op_absval_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_dropwhileneg_add10", "entry_point": "op_evens_dropwhileneg_add10", "primitives": ["evens", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the leading negative values, then add ten to each.", "solution": "def op_evens_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_evens_dropwhileneg_add10([1, 2, 3, 4]) == [12, 14]\nassert op_evens_dropwhileneg_add10([]) == []\nassert op_evens_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [10, 12]\nassert op_evens_dropwhileneg_add10([5, 5, 5]) == []\nassert op_evens_dropwhileneg_add10([3, 1, 2]) == [12]\nassert op_evens_dropwhileneg_add10([10]) == [20]\nassert op_evens_dropwhileneg_add10([2, 4, 6]) == [12, 14, 16]\nassert op_evens_dropwhileneg_add10([-7, 12, -7]) == [22]"}
{"id": "op_inc_odds_trimends", "entry_point": "op_inc_odds_trimends", "primitives": ["inc", "odds", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_inc_odds_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_odds_trimends([1, 2, 3, 4]) == []\nassert op_inc_odds_trimends([]) == []\nassert op_inc_odds_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_inc_odds_trimends([5, 5, 5]) == []\nassert op_inc_odds_trimends([3, 1, 2]) == []\nassert op_inc_odds_trimends([10]) == []\nassert op_inc_odds_trimends([2, 4, 6]) == [5]\nassert op_inc_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_add10_last3_gt5", "entry_point": "op_add10_last3_gt5", "primitives": ["add10", "last3", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then keep values greater than five.", "solution": "def op_add10_last3_gt5(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_add10_last3_gt5([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_last3_gt5([]) == []\nassert op_add10_last3_gt5([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_add10_last3_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_add10_last3_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_add10_last3_gt5([10]) == [20]\nassert op_add10_last3_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_add10_last3_gt5([-7, 12, -7]) == [22]"}
{"id": "op_absval_evens_odds", "entry_point": "op_absval_evens_odds", "primitives": ["absval", "evens", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then keep the odd numbers.", "solution": "def op_absval_evens_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_evens_odds([1, 2, 3, 4]) == []\nassert op_absval_evens_odds([]) == []\nassert op_absval_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_absval_evens_odds([5, 5, 5]) == []\nassert op_absval_evens_odds([3, 1, 2]) == []\nassert op_absval_evens_odds([10]) == []\nassert op_absval_evens_odds([2, 4, 6]) == []\nassert op_absval_evens_odds([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_evens_div3", "entry_point": "op_oremptyzero_evens_div3", "primitives": ["oremptyzero", "evens", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then keep multiples of three.", "solution": "def op_oremptyzero_evens_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_evens_div3([1, 2, 3, 4]) == []\nassert op_oremptyzero_evens_div3([]) == [0]\nassert op_oremptyzero_evens_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_evens_div3([5, 5, 5]) == []\nassert op_oremptyzero_evens_div3([3, 1, 2]) == []\nassert op_oremptyzero_evens_div3([10]) == []\nassert op_oremptyzero_evens_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_evens_div3([-7, 12, -7]) == [12]"}
{"id": "op_dec_double_last3", "entry_point": "op_dec_double_last3", "primitives": ["dec", "double", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then double each, then keep only the last three.", "solution": "def op_dec_double_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_double_last3([1, 2, 3, 4]) == [2, 4, 6]\nassert op_dec_double_last3([]) == []\nassert op_dec_double_last3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_dec_double_last3([5, 5, 5]) == [8, 8, 8]\nassert op_dec_double_last3([3, 1, 2]) == [4, 0, 2]\nassert op_dec_double_last3([10]) == [18]\nassert op_dec_double_last3([2, 4, 6]) == [2, 6, 10]\nassert op_dec_double_last3([-7, 12, -7]) == [-16, 22, -16]"}
{"id": "op_inc_first3_rev", "entry_point": "op_inc_first3_rev", "primitives": ["inc", "first3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then reverse the order.", "solution": "def op_inc_first3_rev(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = list(reversed(r))\n    return r", "tests": "assert op_inc_first3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_inc_first3_rev([]) == []\nassert op_inc_first3_rev([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_inc_first3_rev([5, 5, 5]) == [6, 6, 6]\nassert op_inc_first3_rev([3, 1, 2]) == [3, 2, 4]\nassert op_inc_first3_rev([10]) == [11]\nassert op_inc_first3_rev([2, 4, 6]) == [7, 5, 3]\nassert op_inc_first3_rev([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_first3_last3_double", "entry_point": "op_first3_last3_double", "primitives": ["first3", "last3", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then double each.", "solution": "def op_first3_last3_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_last3_double([1, 2, 3, 4]) == [2, 4, 6]\nassert op_first3_last3_double([]) == []\nassert op_first3_last3_double([-2, -1, 0, 1, 2]) == [-4, -2, 0]\nassert op_first3_last3_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_last3_double([3, 1, 2]) == [6, 2, 4]\nassert op_first3_last3_double([10]) == [20]\nassert op_first3_last3_double([2, 4, 6]) == [4, 8, 12]\nassert op_first3_last3_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_last3_beforezero_firsteven", "entry_point": "op_last3_beforezero_firsteven", "primitives": ["last3", "beforezero", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_last3_beforezero_firsteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_last3_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_last3_beforezero_firsteven([]) == 0\nassert op_last3_beforezero_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_last3_beforezero_firsteven([5, 5, 5]) == 0\nassert op_last3_beforezero_firsteven([3, 1, 2]) == 2\nassert op_last3_beforezero_firsteven([10]) == 10\nassert op_last3_beforezero_firsteven([2, 4, 6]) == 2\nassert op_last3_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_absval_takewhilepos_beforezero", "entry_point": "op_absval_takewhilepos_beforezero", "primitives": ["absval", "takewhilepos", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then keep everything before the first zero.", "solution": "def op_absval_takewhilepos_beforezero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_absval_takewhilepos_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_takewhilepos_beforezero([]) == []\nassert op_absval_takewhilepos_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_takewhilepos_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_beforezero([3, 1, 2]) == [3, 1, 2]\nassert op_absval_takewhilepos_beforezero([10]) == [10]\nassert op_absval_takewhilepos_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_absval_takewhilepos_beforezero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_negate_sortd_div3", "entry_point": "op_negate_sortd_div3", "primitives": ["negate", "sortd", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort descending, then keep multiples of three.", "solution": "def op_negate_sortd_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_sortd_div3([1, 2, 3, 4]) == [-3]\nassert op_negate_sortd_div3([]) == []\nassert op_negate_sortd_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_negate_sortd_div3([5, 5, 5]) == []\nassert op_negate_sortd_div3([3, 1, 2]) == [-3]\nassert op_negate_sortd_div3([10]) == []\nassert op_negate_sortd_div3([2, 4, 6]) == [-6]\nassert op_negate_sortd_div3([-7, 12, -7]) == [-12]"}
{"id": "op_uniq_absval_sorta", "entry_point": "op_uniq_absval_sorta", "primitives": ["uniq", "absval", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then sort ascending.", "solution": "def op_uniq_absval_sorta(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_uniq_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_absval_sorta([]) == []\nassert op_uniq_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_uniq_absval_sorta([5, 5, 5]) == [5]\nassert op_uniq_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_absval_sorta([10]) == [10]\nassert op_uniq_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_absval_sorta([-7, 12, -7]) == [7, 12]"}
{"id": "op_ages_div3_beforezero", "entry_point": "op_ages_div3_beforezero", "primitives": ["ages", "div3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_ages_div3_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_div3_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_div3_beforezero([]) == []\nassert op_ages_div3_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_div3_beforezero([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_square_pos_clamp10", "entry_point": "op_square_pos_clamp10", "primitives": ["square", "pos", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then cap each value at 10.", "solution": "def op_square_pos_clamp10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_square_pos_clamp10([1, 2, 3, 4]) == [1, 4, 9, 10]\nassert op_square_pos_clamp10([]) == []\nassert op_square_pos_clamp10([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_square_pos_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_square_pos_clamp10([3, 1, 2]) == [9, 1, 4]\nassert op_square_pos_clamp10([10]) == [10]\nassert op_square_pos_clamp10([2, 4, 6]) == [4, 10, 10]\nassert op_square_pos_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_uniq_sortd_square", "entry_point": "op_uniq_sortd_square", "primitives": ["uniq", "sortd", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort descending, then square each.", "solution": "def op_uniq_sortd_square(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_uniq_sortd_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_uniq_sortd_square([]) == []\nassert op_uniq_sortd_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_uniq_sortd_square([5, 5, 5]) == [25]\nassert op_uniq_sortd_square([3, 1, 2]) == [9, 4, 1]\nassert op_uniq_sortd_square([10]) == [100]\nassert op_uniq_sortd_square([2, 4, 6]) == [36, 16, 4]\nassert op_uniq_sortd_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_trimends_double_oremptyzero", "entry_point": "op_trimends_double_oremptyzero", "primitives": ["trimends", "double", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then if empty, use a single zero.", "solution": "def op_trimends_double_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_double_oremptyzero([1, 2, 3, 4]) == [4, 6]\nassert op_trimends_double_oremptyzero([]) == [0]\nassert op_trimends_double_oremptyzero([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_trimends_double_oremptyzero([5, 5, 5]) == [10]\nassert op_trimends_double_oremptyzero([3, 1, 2]) == [2]\nassert op_trimends_double_oremptyzero([10]) == [0]\nassert op_trimends_double_oremptyzero([2, 4, 6]) == [8]\nassert op_trimends_double_oremptyzero([-7, 12, -7]) == [24]"}
{"id": "op_dec_sortabs_absval", "entry_point": "op_dec_sortabs_absval", "primitives": ["dec", "sortabs", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then take the absolute value of each.", "solution": "def op_dec_sortabs_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_sortabs_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sortabs_absval([]) == []\nassert op_dec_sortabs_absval([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 3]\nassert op_dec_sortabs_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortabs_absval([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sortabs_absval([10]) == [9]\nassert op_dec_sortabs_absval([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sortabs_absval([-7, 12, -7]) == [8, 8, 11]"}
{"id": "op_rev_first3_sortd", "entry_point": "op_rev_first3_sortd", "primitives": ["rev", "first3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then sort descending.", "solution": "def op_rev_first3_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_first3_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_sortd([]) == []\nassert op_rev_first3_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_rev_first3_sortd([10]) == [10]\nassert op_rev_first3_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_inc_takewhilepos", "entry_point": "op_gt5_inc_takewhilepos", "primitives": ["gt5", "inc", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then take values while they are positive.", "solution": "def op_gt5_inc_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_gt5_inc_takewhilepos([1, 2, 3, 4]) == []\nassert op_gt5_inc_takewhilepos([]) == []\nassert op_gt5_inc_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_gt5_inc_takewhilepos([5, 5, 5]) == []\nassert op_gt5_inc_takewhilepos([3, 1, 2]) == []\nassert op_gt5_inc_takewhilepos([10]) == [11]\nassert op_gt5_inc_takewhilepos([2, 4, 6]) == [7]\nassert op_gt5_inc_takewhilepos([-7, 12, -7]) == [13]"}
{"id": "op_clamp10_uniq_sortd", "entry_point": "op_clamp10_uniq_sortd", "primitives": ["clamp10", "uniq", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then sort descending.", "solution": "def op_clamp10_uniq_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_uniq_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_uniq_sortd([]) == []\nassert op_clamp10_uniq_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_uniq_sortd([5, 5, 5]) == [5]\nassert op_clamp10_uniq_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_clamp10_uniq_sortd([10]) == [10]\nassert op_clamp10_uniq_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_uniq_sortd([-7, 12, -7]) == [10, -7]"}
{"id": "op_trimends_inc_dropzeros", "entry_point": "op_trimends_inc_dropzeros", "primitives": ["trimends", "inc", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then drop the zeros.", "solution": "def op_trimends_inc_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_inc_dropzeros([1, 2, 3, 4]) == [3, 4]\nassert op_trimends_inc_dropzeros([]) == []\nassert op_trimends_inc_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_trimends_inc_dropzeros([5, 5, 5]) == [6]\nassert op_trimends_inc_dropzeros([3, 1, 2]) == [2]\nassert op_trimends_inc_dropzeros([10]) == []\nassert op_trimends_inc_dropzeros([2, 4, 6]) == [5]\nassert op_trimends_inc_dropzeros([-7, 12, -7]) == [13]"}
{"id": "op_oremptyzero_beforezero_neg", "entry_point": "op_oremptyzero_beforezero_neg", "primitives": ["oremptyzero", "beforezero", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_oremptyzero_beforezero_neg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_oremptyzero_beforezero_neg([1, 2, 3, 4]) == []\nassert op_oremptyzero_beforezero_neg([]) == []\nassert op_oremptyzero_beforezero_neg([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_oremptyzero_beforezero_neg([5, 5, 5]) == []\nassert op_oremptyzero_beforezero_neg([3, 1, 2]) == []\nassert op_oremptyzero_beforezero_neg([10]) == []\nassert op_oremptyzero_beforezero_neg([2, 4, 6]) == []\nassert op_oremptyzero_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_evens_uniq", "entry_point": "op_sortabs_evens_uniq", "primitives": ["sortabs", "evens", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then drop duplicates keeping first occurrence.", "solution": "def op_sortabs_evens_uniq(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortabs_evens_uniq([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_evens_uniq([]) == []\nassert op_sortabs_evens_uniq([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_evens_uniq([5, 5, 5]) == []\nassert op_sortabs_evens_uniq([3, 1, 2]) == [2]\nassert op_sortabs_evens_uniq([10]) == [10]\nassert op_sortabs_evens_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_evens_uniq([-7, 12, -7]) == [12]"}
{"id": "op_gt5_rev_alldistinct", "entry_point": "op_gt5_rev_alldistinct", "primitives": ["gt5", "rev", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then return whether all values are distinct.", "solution": "def op_gt5_rev_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    return len(r) == len(set(r))", "tests": "assert op_gt5_rev_alldistinct([1, 2, 3, 4]) == True\nassert op_gt5_rev_alldistinct([]) == True\nassert op_gt5_rev_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_gt5_rev_alldistinct([5, 5, 5]) == True\nassert op_gt5_rev_alldistinct([3, 1, 2]) == True\nassert op_gt5_rev_alldistinct([10]) == True\nassert op_gt5_rev_alldistinct([2, 4, 6]) == True\nassert op_gt5_rev_alldistinct([-7, 12, -7]) == True"}
{"id": "op_prefixup_upper_longest", "entry_point": "op_prefixup_upper_longest", "primitives": ["prefixup", "upper", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then uppercase each string, then return the longest string (empty if none).", "solution": "def op_prefixup_upper_longest(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    return max(r, key=len) if r else ''", "tests": "assert op_prefixup_upper_longest(['Hello', 'world']) == '#HELLO'\nassert op_prefixup_upper_longest([]) == ''\nassert op_prefixup_upper_longest(['  a ', '', 'BC', 'bc']) == '#  A '\nassert op_prefixup_upper_longest(['one', 'one', 'Two']) == '#ONE'\nassert op_prefixup_upper_longest(['x']) == '#X'\nassert op_prefixup_upper_longest(['abc', 'de', '']) == '#ABC'"}
{"id": "op_odds_add10_padto3", "entry_point": "op_odds_add10_padto3", "primitives": ["odds", "add10", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then pad with zeros to at least three elements.", "solution": "def op_odds_add10_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_odds_add10_padto3([1, 2, 3, 4]) == [11, 13, 0]\nassert op_odds_add10_padto3([]) == [0, 0, 0]\nassert op_odds_add10_padto3([-2, -1, 0, 1, 2]) == [9, 11, 0]\nassert op_odds_add10_padto3([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10_padto3([3, 1, 2]) == [13, 11, 0]\nassert op_odds_add10_padto3([10]) == [0, 0, 0]\nassert op_odds_add10_padto3([2, 4, 6]) == [0, 0, 0]\nassert op_odds_add10_padto3([-7, 12, -7]) == [3, 3, 0]"}
{"id": "op_dropwhileneg_sortd_last3", "entry_point": "op_dropwhileneg_sortd_last3", "primitives": ["dropwhileneg", "sortd", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending, then keep only the last three.", "solution": "def op_dropwhileneg_sortd_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_sortd_last3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dropwhileneg_sortd_last3([]) == []\nassert op_dropwhileneg_sortd_last3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_dropwhileneg_sortd_last3([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_sortd_last3([3, 1, 2]) == [3, 2, 1]\nassert op_dropwhileneg_sortd_last3([10]) == [10]\nassert op_dropwhileneg_sortd_last3([2, 4, 6]) == [6, 4, 2]\nassert op_dropwhileneg_sortd_last3([-7, 12, -7]) == [12, -7]"}
{"id": "op_add10_trimends_dropfirst", "entry_point": "op_add10_trimends_dropfirst", "primitives": ["add10", "trimends", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then drop the first element.", "solution": "def op_add10_trimends_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = r[1:]\n    return r", "tests": "assert op_add10_trimends_dropfirst([1, 2, 3, 4]) == [13]\nassert op_add10_trimends_dropfirst([]) == []\nassert op_add10_trimends_dropfirst([-2, -1, 0, 1, 2]) == [10, 11]\nassert op_add10_trimends_dropfirst([5, 5, 5]) == []\nassert op_add10_trimends_dropfirst([3, 1, 2]) == []\nassert op_add10_trimends_dropfirst([10]) == []\nassert op_add10_trimends_dropfirst([2, 4, 6]) == []\nassert op_add10_trimends_dropfirst([-7, 12, -7]) == []"}
{"id": "op_clamp10_sorta_trimends", "entry_point": "op_clamp10_sorta_trimends", "primitives": ["clamp10", "sorta", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then drop the first and last elements.", "solution": "def op_clamp10_sorta_trimends(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = r[1:-1]\n    return r", "tests": "assert op_clamp10_sorta_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_clamp10_sorta_trimends([]) == []\nassert op_clamp10_sorta_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_clamp10_sorta_trimends([5, 5, 5]) == [5]\nassert op_clamp10_sorta_trimends([3, 1, 2]) == [2]\nassert op_clamp10_sorta_trimends([10]) == []\nassert op_clamp10_sorta_trimends([2, 4, 6]) == [4]\nassert op_clamp10_sorta_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_add10_trimends_oremptyzero", "entry_point": "op_add10_trimends_oremptyzero", "primitives": ["add10", "trimends", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first and last elements, then if empty, use a single zero.", "solution": "def op_add10_trimends_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_trimends_oremptyzero([1, 2, 3, 4]) == [12, 13]\nassert op_add10_trimends_oremptyzero([]) == [0]\nassert op_add10_trimends_oremptyzero([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_add10_trimends_oremptyzero([5, 5, 5]) == [15]\nassert op_add10_trimends_oremptyzero([3, 1, 2]) == [11]\nassert op_add10_trimends_oremptyzero([10]) == [0]\nassert op_add10_trimends_oremptyzero([2, 4, 6]) == [14]\nassert op_add10_trimends_oremptyzero([-7, 12, -7]) == [22]"}
{"id": "op_odds_trimends_gt5", "entry_point": "op_odds_trimends_gt5", "primitives": ["odds", "trimends", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first and last elements, then keep values greater than five.", "solution": "def op_odds_trimends_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_odds_trimends_gt5([1, 2, 3, 4]) == []\nassert op_odds_trimends_gt5([]) == []\nassert op_odds_trimends_gt5([-2, -1, 0, 1, 2]) == []\nassert op_odds_trimends_gt5([5, 5, 5]) == []\nassert op_odds_trimends_gt5([3, 1, 2]) == []\nassert op_odds_trimends_gt5([10]) == []\nassert op_odds_trimends_gt5([2, 4, 6]) == []\nassert op_odds_trimends_gt5([-7, 12, -7]) == []"}
{"id": "op_sortd_dec_dropfirst", "entry_point": "op_sortd_dec_dropfirst", "primitives": ["sortd", "dec", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each, then drop the first element.", "solution": "def op_sortd_dec_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_sortd_dec_dropfirst([1, 2, 3, 4]) == [2, 1, 0]\nassert op_sortd_dec_dropfirst([]) == []\nassert op_sortd_dec_dropfirst([-2, -1, 0, 1, 2]) == [0, -1, -2, -3]\nassert op_sortd_dec_dropfirst([5, 5, 5]) == [4, 4]\nassert op_sortd_dec_dropfirst([3, 1, 2]) == [1, 0]\nassert op_sortd_dec_dropfirst([10]) == []\nassert op_sortd_dec_dropfirst([2, 4, 6]) == [3, 1]\nassert op_sortd_dec_dropfirst([-7, 12, -7]) == [-8, -8]"}
{"id": "op_beforezero_gt5_pos", "entry_point": "op_beforezero_gt5_pos", "primitives": ["beforezero", "gt5", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then keep the positive numbers.", "solution": "def op_beforezero_gt5_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_gt5_pos([1, 2, 3, 4]) == []\nassert op_beforezero_gt5_pos([]) == []\nassert op_beforezero_gt5_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_gt5_pos([5, 5, 5]) == []\nassert op_beforezero_gt5_pos([3, 1, 2]) == []\nassert op_beforezero_gt5_pos([10]) == [10]\nassert op_beforezero_gt5_pos([2, 4, 6]) == [6]\nassert op_beforezero_gt5_pos([-7, 12, -7]) == [12]"}
{"id": "op_div3_negate_gt5", "entry_point": "op_div3_negate_gt5", "primitives": ["div3", "negate", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then keep values greater than five.", "solution": "def op_div3_negate_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_negate_gt5([1, 2, 3, 4]) == []\nassert op_div3_negate_gt5([]) == []\nassert op_div3_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_negate_gt5([5, 5, 5]) == []\nassert op_div3_negate_gt5([3, 1, 2]) == []\nassert op_div3_negate_gt5([10]) == []\nassert op_div3_negate_gt5([2, 4, 6]) == []\nassert op_div3_negate_gt5([-7, 12, -7]) == []"}
{"id": "op_double_beforezero_uniq", "entry_point": "op_double_beforezero_uniq", "primitives": ["double", "beforezero", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep everything before the first zero, then drop duplicates keeping first occurrence.", "solution": "def op_double_beforezero_uniq(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_double_beforezero_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_beforezero_uniq([]) == []\nassert op_double_beforezero_uniq([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_double_beforezero_uniq([5, 5, 5]) == [10]\nassert op_double_beforezero_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_double_beforezero_uniq([10]) == [20]\nassert op_double_beforezero_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_double_beforezero_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_div3_evens_double", "entry_point": "op_div3_evens_double", "primitives": ["div3", "evens", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the even numbers, then double each.", "solution": "def op_div3_evens_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_evens_double([1, 2, 3, 4]) == []\nassert op_div3_evens_double([]) == []\nassert op_div3_evens_double([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_evens_double([5, 5, 5]) == []\nassert op_div3_evens_double([3, 1, 2]) == []\nassert op_div3_evens_double([10]) == []\nassert op_div3_evens_double([2, 4, 6]) == [12]\nassert op_div3_evens_double([-7, 12, -7]) == [24]"}
{"id": "op_sortd_first3_min", "entry_point": "op_sortd_first3_min", "primitives": ["sortd", "first3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_sortd_first3_min(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_sortd_first3_min([1, 2, 3, 4]) == 2\nassert op_sortd_first3_min([]) == 0\nassert op_sortd_first3_min([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_first3_min([5, 5, 5]) == 5\nassert op_sortd_first3_min([3, 1, 2]) == 1\nassert op_sortd_first3_min([10]) == 10\nassert op_sortd_first3_min([2, 4, 6]) == 2\nassert op_sortd_first3_min([-7, 12, -7]) == -7"}
{"id": "op_dropwhileneg_padto3_double", "entry_point": "op_dropwhileneg_padto3_double", "primitives": ["dropwhileneg", "padto3", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements, then double each.", "solution": "def op_dropwhileneg_padto3_double(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_padto3_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_padto3_double([]) == [0, 0, 0]\nassert op_dropwhileneg_padto3_double([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_dropwhileneg_padto3_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_padto3_double([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_padto3_double([10]) == [20, 0, 0]\nassert op_dropwhileneg_padto3_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_padto3_double([-7, 12, -7]) == [24, -14, 0]"}
{"id": "op_inc_neg_takewhilepos", "entry_point": "op_inc_neg_takewhilepos", "primitives": ["inc", "neg", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then take values while they are positive.", "solution": "def op_inc_neg_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_neg_takewhilepos([1, 2, 3, 4]) == []\nassert op_inc_neg_takewhilepos([]) == []\nassert op_inc_neg_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_neg_takewhilepos([5, 5, 5]) == []\nassert op_inc_neg_takewhilepos([3, 1, 2]) == []\nassert op_inc_neg_takewhilepos([10]) == []\nassert op_inc_neg_takewhilepos([2, 4, 6]) == []\nassert op_inc_neg_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_inc_sortabs_allpos", "entry_point": "op_inc_sortabs_allpos", "primitives": ["inc", "sortabs", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort by absolute value, then return whether all values are positive.", "solution": "def op_inc_sortabs_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_inc_sortabs_allpos([1, 2, 3, 4]) == True\nassert op_inc_sortabs_allpos([]) == True\nassert op_inc_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_sortabs_allpos([5, 5, 5]) == True\nassert op_inc_sortabs_allpos([3, 1, 2]) == True\nassert op_inc_sortabs_allpos([10]) == True\nassert op_inc_sortabs_allpos([2, 4, 6]) == True\nassert op_inc_sortabs_allpos([-7, 12, -7]) == False"}
{"id": "op_add10_sortd_min", "entry_point": "op_add10_sortd_min", "primitives": ["add10", "sortd", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort descending, then return the minimum (0 if empty).", "solution": "def op_add10_sortd_min(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_add10_sortd_min([1, 2, 3, 4]) == 11\nassert op_add10_sortd_min([]) == 0\nassert op_add10_sortd_min([-2, -1, 0, 1, 2]) == 8\nassert op_add10_sortd_min([5, 5, 5]) == 15\nassert op_add10_sortd_min([3, 1, 2]) == 11\nassert op_add10_sortd_min([10]) == 20\nassert op_add10_sortd_min([2, 4, 6]) == 12\nassert op_add10_sortd_min([-7, 12, -7]) == 3"}
{"id": "op_add10_odds_rev", "entry_point": "op_add10_odds_rev", "primitives": ["add10", "odds", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then reverse the order.", "solution": "def op_add10_odds_rev(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_add10_odds_rev([1, 2, 3, 4]) == [13, 11]\nassert op_add10_odds_rev([]) == []\nassert op_add10_odds_rev([-2, -1, 0, 1, 2]) == [11, 9]\nassert op_add10_odds_rev([5, 5, 5]) == [15, 15, 15]\nassert op_add10_odds_rev([3, 1, 2]) == [11, 13]\nassert op_add10_odds_rev([10]) == []\nassert op_add10_odds_rev([2, 4, 6]) == []\nassert op_add10_odds_rev([-7, 12, -7]) == [3, 3]"}
{"id": "op_oremptyzero_odds_uniq", "entry_point": "op_oremptyzero_odds_uniq", "primitives": ["oremptyzero", "odds", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_odds_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_odds_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_oremptyzero_odds_uniq([]) == []\nassert op_oremptyzero_odds_uniq([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_oremptyzero_odds_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_odds_uniq([3, 1, 2]) == [3, 1]\nassert op_oremptyzero_odds_uniq([10]) == []\nassert op_oremptyzero_odds_uniq([2, 4, 6]) == []\nassert op_oremptyzero_odds_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_oremptyzero_dropwhileneg_sum", "entry_point": "op_oremptyzero_dropwhileneg_sum", "primitives": ["oremptyzero", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then return their sum.", "solution": "def op_oremptyzero_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_oremptyzero_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_oremptyzero_dropwhileneg_sum([]) == 0\nassert op_oremptyzero_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 3\nassert op_oremptyzero_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_oremptyzero_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_oremptyzero_dropwhileneg_sum([10]) == 10\nassert op_oremptyzero_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_oremptyzero_dropwhileneg_sum([-7, 12, -7]) == 5"}
{"id": "op_rev_first3_padto3", "entry_point": "op_rev_first3_padto3", "primitives": ["rev", "first3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_rev_first3_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_first3_padto3([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_padto3([]) == [0, 0, 0]\nassert op_rev_first3_padto3([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_rev_first3_padto3([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3_padto3([10]) == [10, 0, 0]\nassert op_rev_first3_padto3([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_rev_last3_takewhilepos", "entry_point": "op_rev_last3_takewhilepos", "primitives": ["rev", "last3", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then take values while they are positive.", "solution": "def op_rev_last3_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_last3_takewhilepos([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_last3_takewhilepos([]) == []\nassert op_rev_last3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_rev_last3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_last3_takewhilepos([10]) == [10]\nassert op_rev_last3_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_last3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropfirst_pos_trimends", "entry_point": "op_dropfirst_pos_trimends", "primitives": ["dropfirst", "pos", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then drop the first and last elements.", "solution": "def op_dropfirst_pos_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_pos_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_pos_trimends([]) == []\nassert op_dropfirst_pos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_pos_trimends([5, 5, 5]) == []\nassert op_dropfirst_pos_trimends([3, 1, 2]) == []\nassert op_dropfirst_pos_trimends([10]) == []\nassert op_dropfirst_pos_trimends([2, 4, 6]) == []\nassert op_dropfirst_pos_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_square_dec", "entry_point": "op_sorta_square_dec", "primitives": ["sorta", "square", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each, then subtract one from each.", "solution": "def op_sorta_square_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_square_dec([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_sorta_square_dec([]) == []\nassert op_sorta_square_dec([-2, -1, 0, 1, 2]) == [3, 0, -1, 0, 3]\nassert op_sorta_square_dec([5, 5, 5]) == [24, 24, 24]\nassert op_sorta_square_dec([3, 1, 2]) == [0, 3, 8]\nassert op_sorta_square_dec([10]) == [99]\nassert op_sorta_square_dec([2, 4, 6]) == [3, 15, 35]\nassert op_sorta_square_dec([-7, 12, -7]) == [48, 48, 143]"}
{"id": "op_gt5_neg_clamp10", "entry_point": "op_gt5_neg_clamp10", "primitives": ["gt5", "neg", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then cap each value at 10.", "solution": "def op_gt5_neg_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_gt5_neg_clamp10([1, 2, 3, 4]) == []\nassert op_gt5_neg_clamp10([]) == []\nassert op_gt5_neg_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg_clamp10([5, 5, 5]) == []\nassert op_gt5_neg_clamp10([3, 1, 2]) == []\nassert op_gt5_neg_clamp10([10]) == []\nassert op_gt5_neg_clamp10([2, 4, 6]) == []\nassert op_gt5_neg_clamp10([-7, 12, -7]) == []"}
{"id": "op_evens_div3_dec", "entry_point": "op_evens_div3_dec", "primitives": ["evens", "div3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then subtract one from each.", "solution": "def op_evens_div3_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_evens_div3_dec([1, 2, 3, 4]) == []\nassert op_evens_div3_dec([]) == []\nassert op_evens_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_evens_div3_dec([5, 5, 5]) == []\nassert op_evens_div3_dec([3, 1, 2]) == []\nassert op_evens_div3_dec([10]) == []\nassert op_evens_div3_dec([2, 4, 6]) == [5]\nassert op_evens_div3_dec([-7, 12, -7]) == [11]"}
{"id": "op_gt5_negate_sum", "entry_point": "op_gt5_negate_sum", "primitives": ["gt5", "negate", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then negate each, then return their sum.", "solution": "def op_gt5_negate_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_gt5_negate_sum([1, 2, 3, 4]) == 0\nassert op_gt5_negate_sum([]) == 0\nassert op_gt5_negate_sum([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_negate_sum([5, 5, 5]) == 0\nassert op_gt5_negate_sum([3, 1, 2]) == 0\nassert op_gt5_negate_sum([10]) == -10\nassert op_gt5_negate_sum([2, 4, 6]) == -6\nassert op_gt5_negate_sum([-7, 12, -7]) == -12"}
{"id": "op_uniq_gt5_issorted", "entry_point": "op_uniq_gt5_issorted", "primitives": ["uniq", "gt5", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_uniq_gt5_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_uniq_gt5_issorted([1, 2, 3, 4]) == True\nassert op_uniq_gt5_issorted([]) == True\nassert op_uniq_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_uniq_gt5_issorted([5, 5, 5]) == True\nassert op_uniq_gt5_issorted([3, 1, 2]) == True\nassert op_uniq_gt5_issorted([10]) == True\nassert op_uniq_gt5_issorted([2, 4, 6]) == True\nassert op_uniq_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_dropwhileneg_square", "entry_point": "op_oremptyzero_dropwhileneg_square", "primitives": ["oremptyzero", "dropwhileneg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then square each.", "solution": "def op_oremptyzero_dropwhileneg_square(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_oremptyzero_dropwhileneg_square([]) == [0]\nassert op_oremptyzero_dropwhileneg_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_oremptyzero_dropwhileneg_square([5, 5, 5]) == [25, 25, 25]\nassert op_oremptyzero_dropwhileneg_square([3, 1, 2]) == [9, 1, 4]\nassert op_oremptyzero_dropwhileneg_square([10]) == [100]\nassert op_oremptyzero_dropwhileneg_square([2, 4, 6]) == [4, 16, 36]\nassert op_oremptyzero_dropwhileneg_square([-7, 12, -7]) == [144, 49]"}
{"id": "op_beforezero_first3_anyeven", "entry_point": "op_beforezero_first3_anyeven", "primitives": ["beforezero", "first3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then return whether any value is even.", "solution": "def op_beforezero_first3_anyeven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_beforezero_first3_anyeven([1, 2, 3, 4]) == True\nassert op_beforezero_first3_anyeven([]) == False\nassert op_beforezero_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_first3_anyeven([5, 5, 5]) == False\nassert op_beforezero_first3_anyeven([3, 1, 2]) == True\nassert op_beforezero_first3_anyeven([10]) == True\nassert op_beforezero_first3_anyeven([2, 4, 6]) == True\nassert op_beforezero_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_inc_div3_prod", "entry_point": "op_inc_div3_prod", "primitives": ["inc", "div3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep multiples of three, then return their product.", "solution": "def op_inc_div3_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_inc_div3_prod([1, 2, 3, 4]) == 3\nassert op_inc_div3_prod([]) == 1\nassert op_inc_div3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_inc_div3_prod([5, 5, 5]) == 216\nassert op_inc_div3_prod([3, 1, 2]) == 3\nassert op_inc_div3_prod([10]) == 1\nassert op_inc_div3_prod([2, 4, 6]) == 3\nassert op_inc_div3_prod([-7, 12, -7]) == 36"}
{"id": "op_sortalpha_sortlen_uniqs", "entry_point": "op_sortalpha_sortlen_uniqs", "primitives": ["sortalpha", "sortlen", "uniqs"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then sort by length, shortest first, then drop duplicate strings keeping the first.", "solution": "def op_sortalpha_sortlen_uniqs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=len)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortalpha_sortlen_uniqs(['Hello', 'world']) == ['Hello', 'world']\nassert op_sortalpha_sortlen_uniqs([]) == []\nassert op_sortalpha_sortlen_uniqs(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'bc', '  a ']\nassert op_sortalpha_sortlen_uniqs(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_sortalpha_sortlen_uniqs(['x']) == ['x']\nassert op_sortalpha_sortlen_uniqs(['abc', 'de', '']) == ['', 'de', 'abc']"}
{"id": "op_odds_dropfirst_absval", "entry_point": "op_odds_dropfirst_absval", "primitives": ["odds", "dropfirst", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first element, then take the absolute value of each.", "solution": "def op_odds_dropfirst_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_dropfirst_absval([1, 2, 3, 4]) == [3]\nassert op_odds_dropfirst_absval([]) == []\nassert op_odds_dropfirst_absval([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_dropfirst_absval([5, 5, 5]) == [5, 5]\nassert op_odds_dropfirst_absval([3, 1, 2]) == [1]\nassert op_odds_dropfirst_absval([10]) == []\nassert op_odds_dropfirst_absval([2, 4, 6]) == []\nassert op_odds_dropfirst_absval([-7, 12, -7]) == [7]"}
{"id": "op_ages_square_inc", "entry_point": "op_ages_square_inc", "primitives": ["ages", "square", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then add one to each.", "solution": "def op_ages_square_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_square_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1297, 145]\nassert op_ages_square_inc([]) == []\nassert op_ages_square_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [325, 4226, 290]\nassert op_ages_square_inc([{'name': 'Fi', 'age': 41}]) == [1682]"}
{"id": "op_uniq_beforezero_add10", "entry_point": "op_uniq_beforezero_add10", "primitives": ["uniq", "beforezero", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep everything before the first zero, then add ten to each.", "solution": "def op_uniq_beforezero_add10(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_uniq_beforezero_add10([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_uniq_beforezero_add10([]) == []\nassert op_uniq_beforezero_add10([-2, -1, 0, 1, 2]) == [8, 9]\nassert op_uniq_beforezero_add10([5, 5, 5]) == [15]\nassert op_uniq_beforezero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_uniq_beforezero_add10([10]) == [20]\nassert op_uniq_beforezero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_uniq_beforezero_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_odds_uniq_square", "entry_point": "op_odds_uniq_square", "primitives": ["odds", "uniq", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then square each.", "solution": "def op_odds_uniq_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_odds_uniq_square([1, 2, 3, 4]) == [1, 9]\nassert op_odds_uniq_square([]) == []\nassert op_odds_uniq_square([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_uniq_square([5, 5, 5]) == [25]\nassert op_odds_uniq_square([3, 1, 2]) == [9, 1]\nassert op_odds_uniq_square([10]) == []\nassert op_odds_uniq_square([2, 4, 6]) == []\nassert op_odds_uniq_square([-7, 12, -7]) == [49]"}
{"id": "op_beforezero_padto3_dropzeros", "entry_point": "op_beforezero_padto3_dropzeros", "primitives": ["beforezero", "padto3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then pad with zeros to at least three elements, then drop the zeros.", "solution": "def op_beforezero_padto3_dropzeros(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_beforezero_padto3_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_padto3_dropzeros([]) == []\nassert op_beforezero_padto3_dropzeros([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_padto3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_padto3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_padto3_dropzeros([10]) == [10]\nassert op_beforezero_padto3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_padto3_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_first3_double_len", "entry_point": "op_first3_double_len", "primitives": ["first3", "double", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then double each, then return how many remain.", "solution": "def op_first3_double_len(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x * 2 for x in r]\n    return len(r)", "tests": "assert op_first3_double_len([1, 2, 3, 4]) == 3\nassert op_first3_double_len([]) == 0\nassert op_first3_double_len([-2, -1, 0, 1, 2]) == 3\nassert op_first3_double_len([5, 5, 5]) == 3\nassert op_first3_double_len([3, 1, 2]) == 3\nassert op_first3_double_len([10]) == 1\nassert op_first3_double_len([2, 4, 6]) == 3\nassert op_first3_double_len([-7, 12, -7]) == 3"}
{"id": "op_sortlen_sortalpha_joinc", "entry_point": "op_sortlen_sortalpha_joinc", "primitives": ["sortlen", "sortalpha", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then sort alphabetically, then join them with commas.", "solution": "def op_sortlen_sortalpha_joinc(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = sorted(r)\n    return ','.join(r)", "tests": "assert op_sortlen_sortalpha_joinc(['Hello', 'world']) == 'Hello,world'\nassert op_sortlen_sortalpha_joinc([]) == ''\nassert op_sortlen_sortalpha_joinc(['  a ', '', 'BC', 'bc']) == ',  a ,BC,bc'\nassert op_sortlen_sortalpha_joinc(['one', 'one', 'Two']) == 'Two,one,one'\nassert op_sortlen_sortalpha_joinc(['x']) == 'x'\nassert op_sortlen_sortalpha_joinc(['abc', 'de', '']) == ',abc,de'"}
{"id": "op_dec_sortabs_prod", "entry_point": "op_dec_sortabs_prod", "primitives": ["dec", "sortabs", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then return their product.", "solution": "def op_dec_sortabs_prod(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return __import__('math').prod(r)", "tests": "assert op_dec_sortabs_prod([1, 2, 3, 4]) == 0\nassert op_dec_sortabs_prod([]) == 1\nassert op_dec_sortabs_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dec_sortabs_prod([5, 5, 5]) == 64\nassert op_dec_sortabs_prod([3, 1, 2]) == 0\nassert op_dec_sortabs_prod([10]) == 9\nassert op_dec_sortabs_prod([2, 4, 6]) == 15\nassert op_dec_sortabs_prod([-7, 12, -7]) == 704"}
{"id": "op_evens_first3_prod", "entry_point": "op_evens_first3_prod", "primitives": ["evens", "first3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep only the first three, then return their product.", "solution": "def op_evens_first3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return __import__('math').prod(r)", "tests": "assert op_evens_first3_prod([1, 2, 3, 4]) == 8\nassert op_evens_first3_prod([]) == 1\nassert op_evens_first3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_evens_first3_prod([5, 5, 5]) == 1\nassert op_evens_first3_prod([3, 1, 2]) == 2\nassert op_evens_first3_prod([10]) == 10\nassert op_evens_first3_prod([2, 4, 6]) == 48\nassert op_evens_first3_prod([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_add10_anyeven", "entry_point": "op_dropwhileneg_add10_anyeven", "primitives": ["dropwhileneg", "add10", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then return whether any value is even.", "solution": "def op_dropwhileneg_add10_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_add10_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_add10_anyeven([]) == False\nassert op_dropwhileneg_add10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_add10_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_add10_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_add10_anyeven([10]) == True\nassert op_dropwhileneg_add10_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_add10_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_square_alldistinct", "entry_point": "op_dropwhileneg_square_alldistinct", "primitives": ["dropwhileneg", "square", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then return whether all values are distinct.", "solution": "def op_dropwhileneg_square_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_square_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_square_alldistinct([]) == True\nassert op_dropwhileneg_square_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_square_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_square_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_square_alldistinct([10]) == True\nassert op_dropwhileneg_square_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_square_alldistinct([-7, 12, -7]) == True"}
{"id": "op_sortabs_evens_oremptyzero", "entry_point": "op_sortabs_evens_oremptyzero", "primitives": ["sortabs", "evens", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then if empty, use a single zero.", "solution": "def op_sortabs_evens_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortabs_evens_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_evens_oremptyzero([]) == [0]\nassert op_sortabs_evens_oremptyzero([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_evens_oremptyzero([5, 5, 5]) == [0]\nassert op_sortabs_evens_oremptyzero([3, 1, 2]) == [2]\nassert op_sortabs_evens_oremptyzero([10]) == [10]\nassert op_sortabs_evens_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_evens_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_negate_dropwhileneg_min", "entry_point": "op_negate_dropwhileneg_min", "primitives": ["negate", "dropwhileneg", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then return the minimum (0 if empty).", "solution": "def op_negate_dropwhileneg_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return min(r) if r else 0", "tests": "assert op_negate_dropwhileneg_min([1, 2, 3, 4]) == 0\nassert op_negate_dropwhileneg_min([]) == 0\nassert op_negate_dropwhileneg_min([-2, -1, 0, 1, 2]) == -2\nassert op_negate_dropwhileneg_min([5, 5, 5]) == 0\nassert op_negate_dropwhileneg_min([3, 1, 2]) == 0\nassert op_negate_dropwhileneg_min([10]) == 0\nassert op_negate_dropwhileneg_min([2, 4, 6]) == 0\nassert op_negate_dropwhileneg_min([-7, 12, -7]) == -12"}
{"id": "op_trimends_uniq_dropzeros", "entry_point": "op_trimends_uniq_dropzeros", "primitives": ["trimends", "uniq", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_trimends_uniq_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_uniq_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_uniq_dropzeros([]) == []\nassert op_trimends_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_trimends_uniq_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_uniq_dropzeros([10]) == []\nassert op_trimends_uniq_dropzeros([2, 4, 6]) == [4]\nassert op_trimends_uniq_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_square_dropzeros_sum", "entry_point": "op_square_dropzeros_sum", "primitives": ["square", "dropzeros", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the zeros, then return their sum.", "solution": "def op_square_dropzeros_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_square_dropzeros_sum([1, 2, 3, 4]) == 30\nassert op_square_dropzeros_sum([]) == 0\nassert op_square_dropzeros_sum([-2, -1, 0, 1, 2]) == 10\nassert op_square_dropzeros_sum([5, 5, 5]) == 75\nassert op_square_dropzeros_sum([3, 1, 2]) == 14\nassert op_square_dropzeros_sum([10]) == 100\nassert op_square_dropzeros_sum([2, 4, 6]) == 56\nassert op_square_dropzeros_sum([-7, 12, -7]) == 242"}
{"id": "op_clamp10_inc_anyeven", "entry_point": "op_clamp10_inc_anyeven", "primitives": ["clamp10", "inc", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then return whether any value is even.", "solution": "def op_clamp10_inc_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_inc_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_inc_anyeven([]) == False\nassert op_clamp10_inc_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_inc_anyeven([5, 5, 5]) == True\nassert op_clamp10_inc_anyeven([3, 1, 2]) == True\nassert op_clamp10_inc_anyeven([10]) == False\nassert op_clamp10_inc_anyeven([2, 4, 6]) == False\nassert op_clamp10_inc_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_div3_neg", "entry_point": "op_evens_div3_neg", "primitives": ["evens", "div3", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then keep the negative numbers.", "solution": "def op_evens_div3_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_evens_div3_neg([1, 2, 3, 4]) == []\nassert op_evens_div3_neg([]) == []\nassert op_evens_div3_neg([-2, -1, 0, 1, 2]) == []\nassert op_evens_div3_neg([5, 5, 5]) == []\nassert op_evens_div3_neg([3, 1, 2]) == []\nassert op_evens_div3_neg([10]) == []\nassert op_evens_div3_neg([2, 4, 6]) == []\nassert op_evens_div3_neg([-7, 12, -7]) == []"}
{"id": "op_beforezero_first3_clamp10", "entry_point": "op_beforezero_first3_clamp10", "primitives": ["beforezero", "first3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then cap each value at 10.", "solution": "def op_beforezero_first3_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_first3_clamp10([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_clamp10([]) == []\nassert op_beforezero_first3_clamp10([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_beforezero_first3_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_clamp10([10]) == [10]\nassert op_beforezero_first3_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_clamp10([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_div3_padto3_prod", "entry_point": "op_div3_padto3_prod", "primitives": ["div3", "padto3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then return their product.", "solution": "def op_div3_padto3_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_div3_padto3_prod([1, 2, 3, 4]) == 0\nassert op_div3_padto3_prod([]) == 0\nassert op_div3_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_div3_padto3_prod([5, 5, 5]) == 0\nassert op_div3_padto3_prod([3, 1, 2]) == 0\nassert op_div3_padto3_prod([10]) == 0\nassert op_div3_padto3_prod([2, 4, 6]) == 0\nassert op_div3_padto3_prod([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_sortd_beforezero", "entry_point": "op_oremptyzero_sortd_beforezero", "primitives": ["oremptyzero", "sortd", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending, then keep everything before the first zero.", "solution": "def op_oremptyzero_sortd_beforezero(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_oremptyzero_sortd_beforezero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_oremptyzero_sortd_beforezero([]) == []\nassert op_oremptyzero_sortd_beforezero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_oremptyzero_sortd_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_sortd_beforezero([3, 1, 2]) == [3, 2, 1]\nassert op_oremptyzero_sortd_beforezero([10]) == [10]\nassert op_oremptyzero_sortd_beforezero([2, 4, 6]) == [6, 4, 2]\nassert op_oremptyzero_sortd_beforezero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_dropwhileneg_first3_anyeven", "entry_point": "op_dropwhileneg_first3_anyeven", "primitives": ["dropwhileneg", "first3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then return whether any value is even.", "solution": "def op_dropwhileneg_first3_anyeven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropwhileneg_first3_anyeven([1, 2, 3, 4]) == True\nassert op_dropwhileneg_first3_anyeven([]) == False\nassert op_dropwhileneg_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_first3_anyeven([5, 5, 5]) == False\nassert op_dropwhileneg_first3_anyeven([3, 1, 2]) == True\nassert op_dropwhileneg_first3_anyeven([10]) == True\nassert op_dropwhileneg_first3_anyeven([2, 4, 6]) == True\nassert op_dropwhileneg_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_oremptyzero_sorta_issorted", "entry_point": "op_oremptyzero_sorta_issorted", "primitives": ["oremptyzero", "sorta", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_sorta_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_oremptyzero_sorta_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_sorta_issorted([]) == True\nassert op_oremptyzero_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_sorta_issorted([5, 5, 5]) == True\nassert op_oremptyzero_sorta_issorted([3, 1, 2]) == True\nassert op_oremptyzero_sorta_issorted([10]) == True\nassert op_oremptyzero_sorta_issorted([2, 4, 6]) == True\nassert op_oremptyzero_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_odds_pos_first3", "entry_point": "op_odds_pos_first3", "primitives": ["odds", "pos", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the positive numbers, then keep only the first three.", "solution": "def op_odds_pos_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    r = r[:3]\n    return r", "tests": "assert op_odds_pos_first3([1, 2, 3, 4]) == [1, 3]\nassert op_odds_pos_first3([]) == []\nassert op_odds_pos_first3([-2, -1, 0, 1, 2]) == [1]\nassert op_odds_pos_first3([5, 5, 5]) == [5, 5, 5]\nassert op_odds_pos_first3([3, 1, 2]) == [3, 1]\nassert op_odds_pos_first3([10]) == []\nassert op_odds_pos_first3([2, 4, 6]) == []\nassert op_odds_pos_first3([-7, 12, -7]) == []"}
{"id": "op_evens_padto3_counteven", "entry_point": "op_evens_padto3_counteven", "primitives": ["evens", "padto3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_evens_padto3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_padto3_counteven([1, 2, 3, 4]) == 3\nassert op_evens_padto3_counteven([]) == 3\nassert op_evens_padto3_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_padto3_counteven([5, 5, 5]) == 3\nassert op_evens_padto3_counteven([3, 1, 2]) == 3\nassert op_evens_padto3_counteven([10]) == 3\nassert op_evens_padto3_counteven([2, 4, 6]) == 3\nassert op_evens_padto3_counteven([-7, 12, -7]) == 3"}
{"id": "op_rev_absval_takewhilepos", "entry_point": "op_rev_absval_takewhilepos", "primitives": ["rev", "absval", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take the absolute value of each, then take values while they are positive.", "solution": "def op_rev_absval_takewhilepos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_rev_absval_takewhilepos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_absval_takewhilepos([]) == []\nassert op_rev_absval_takewhilepos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_absval_takewhilepos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_absval_takewhilepos([10]) == [10]\nassert op_rev_absval_takewhilepos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_absval_takewhilepos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_evens_add10_beforezero", "entry_point": "op_evens_add10_beforezero", "primitives": ["evens", "add10", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then keep everything before the first zero.", "solution": "def op_evens_add10_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_evens_add10_beforezero([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10_beforezero([]) == []\nassert op_evens_add10_beforezero([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10_beforezero([5, 5, 5]) == []\nassert op_evens_add10_beforezero([3, 1, 2]) == [12]\nassert op_evens_add10_beforezero([10]) == [20]\nassert op_evens_add10_beforezero([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10_beforezero([-7, 12, -7]) == [22]"}
{"id": "op_neg_inc_dropwhileneg", "entry_point": "op_neg_inc_dropwhileneg", "primitives": ["neg", "inc", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then drop the leading negative values.", "solution": "def op_neg_inc_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_inc_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_inc_dropwhileneg([]) == []\nassert op_neg_inc_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_neg_inc_dropwhileneg([5, 5, 5]) == []\nassert op_neg_inc_dropwhileneg([3, 1, 2]) == []\nassert op_neg_inc_dropwhileneg([10]) == []\nassert op_neg_inc_dropwhileneg([2, 4, 6]) == []\nassert op_neg_inc_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_prefixup_lower_anyempty", "entry_point": "op_prefixup_lower_anyempty", "primitives": ["prefixup", "lower", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then lowercase each string, then return whether any string is empty.", "solution": "def op_prefixup_lower_anyempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.lower() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_prefixup_lower_anyempty(['Hello', 'world']) == False\nassert op_prefixup_lower_anyempty([]) == False\nassert op_prefixup_lower_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_prefixup_lower_anyempty(['one', 'one', 'Two']) == False\nassert op_prefixup_lower_anyempty(['x']) == False\nassert op_prefixup_lower_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dec_dropzeros_rev", "entry_point": "op_dec_dropzeros_rev", "primitives": ["dec", "dropzeros", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the zeros, then reverse the order.", "solution": "def op_dec_dropzeros_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_dropzeros_rev([1, 2, 3, 4]) == [3, 2, 1]\nassert op_dec_dropzeros_rev([]) == []\nassert op_dec_dropzeros_rev([-2, -1, 0, 1, 2]) == [1, -1, -2, -3]\nassert op_dec_dropzeros_rev([5, 5, 5]) == [4, 4, 4]\nassert op_dec_dropzeros_rev([3, 1, 2]) == [1, 2]\nassert op_dec_dropzeros_rev([10]) == [9]\nassert op_dec_dropzeros_rev([2, 4, 6]) == [5, 3, 1]\nassert op_dec_dropzeros_rev([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_beforezero_trimends_allpos", "entry_point": "op_beforezero_trimends_allpos", "primitives": ["beforezero", "trimends", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_beforezero_trimends_allpos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_beforezero_trimends_allpos([1, 2, 3, 4]) == True\nassert op_beforezero_trimends_allpos([]) == True\nassert op_beforezero_trimends_allpos([-2, -1, 0, 1, 2]) == True\nassert op_beforezero_trimends_allpos([5, 5, 5]) == True\nassert op_beforezero_trimends_allpos([3, 1, 2]) == True\nassert op_beforezero_trimends_allpos([10]) == True\nassert op_beforezero_trimends_allpos([2, 4, 6]) == True\nassert op_beforezero_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_trimends_last3_neg", "entry_point": "op_trimends_last3_neg", "primitives": ["trimends", "last3", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then keep the negative numbers.", "solution": "def op_trimends_last3_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_last3_neg([1, 2, 3, 4]) == []\nassert op_trimends_last3_neg([]) == []\nassert op_trimends_last3_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_last3_neg([5, 5, 5]) == []\nassert op_trimends_last3_neg([3, 1, 2]) == []\nassert op_trimends_last3_neg([10]) == []\nassert op_trimends_last3_neg([2, 4, 6]) == []\nassert op_trimends_last3_neg([-7, 12, -7]) == []"}
{"id": "op_ages_inc_sorta", "entry_point": "op_ages_inc_sorta", "primitives": ["ages", "inc", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add one to each, then sort ascending.", "solution": "def op_ages_inc_sorta(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_ages_inc_sorta([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [13, 37]\nassert op_ages_inc_sorta([]) == []\nassert op_ages_inc_sorta([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 19, 66]\nassert op_ages_inc_sorta([{'name': 'Fi', 'age': 41}]) == [42]"}
{"id": "op_sortd_pos_div3", "entry_point": "op_sortd_pos_div3", "primitives": ["sortd", "pos", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then keep multiples of three.", "solution": "def op_sortd_pos_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_pos_div3([1, 2, 3, 4]) == [3]\nassert op_sortd_pos_div3([]) == []\nassert op_sortd_pos_div3([-2, -1, 0, 1, 2]) == []\nassert op_sortd_pos_div3([5, 5, 5]) == []\nassert op_sortd_pos_div3([3, 1, 2]) == [3]\nassert op_sortd_pos_div3([10]) == []\nassert op_sortd_pos_div3([2, 4, 6]) == [6]\nassert op_sortd_pos_div3([-7, 12, -7]) == [12]"}
{"id": "op_sortd_square_uniq", "entry_point": "op_sortd_square_uniq", "primitives": ["sortd", "square", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then square each, then drop duplicates keeping first occurrence.", "solution": "def op_sortd_square_uniq(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortd_square_uniq([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_sortd_square_uniq([]) == []\nassert op_sortd_square_uniq([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_sortd_square_uniq([5, 5, 5]) == [25]\nassert op_sortd_square_uniq([3, 1, 2]) == [9, 4, 1]\nassert op_sortd_square_uniq([10]) == [100]\nassert op_sortd_square_uniq([2, 4, 6]) == [36, 16, 4]\nassert op_sortd_square_uniq([-7, 12, -7]) == [144, 49]"}
{"id": "op_trimends_square_rev", "entry_point": "op_trimends_square_rev", "primitives": ["trimends", "square", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then reverse the order.", "solution": "def op_trimends_square_rev(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_trimends_square_rev([1, 2, 3, 4]) == [9, 4]\nassert op_trimends_square_rev([]) == []\nassert op_trimends_square_rev([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_square_rev([5, 5, 5]) == [25]\nassert op_trimends_square_rev([3, 1, 2]) == [1]\nassert op_trimends_square_rev([10]) == []\nassert op_trimends_square_rev([2, 4, 6]) == [16]\nassert op_trimends_square_rev([-7, 12, -7]) == [144]"}
{"id": "op_sortabs_oremptyzero_pos", "entry_point": "op_sortabs_oremptyzero_pos", "primitives": ["sortabs", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_sortabs_oremptyzero_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_oremptyzero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_oremptyzero_pos([]) == []\nassert op_sortabs_oremptyzero_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortabs_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_oremptyzero_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_oremptyzero_pos([10]) == [10]\nassert op_sortabs_oremptyzero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_sorta_sortd_inc", "entry_point": "op_sorta_sortd_inc", "primitives": ["sorta", "sortd", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then add one to each.", "solution": "def op_sorta_sortd_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_sortd_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sorta_sortd_inc([]) == []\nassert op_sorta_sortd_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sorta_sortd_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_sortd_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sorta_sortd_inc([10]) == [11]\nassert op_sorta_sortd_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sorta_sortd_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_clamp10_uniq_dropfirst", "entry_point": "op_clamp10_uniq_dropfirst", "primitives": ["clamp10", "uniq", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then drop the first element.", "solution": "def op_clamp10_uniq_dropfirst(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return r", "tests": "assert op_clamp10_uniq_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_clamp10_uniq_dropfirst([]) == []\nassert op_clamp10_uniq_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_clamp10_uniq_dropfirst([5, 5, 5]) == []\nassert op_clamp10_uniq_dropfirst([3, 1, 2]) == [1, 2]\nassert op_clamp10_uniq_dropfirst([10]) == []\nassert op_clamp10_uniq_dropfirst([2, 4, 6]) == [4, 6]\nassert op_clamp10_uniq_dropfirst([-7, 12, -7]) == [10]"}
{"id": "op_takewhilepos_square_uniq", "entry_point": "op_takewhilepos_square_uniq", "primitives": ["takewhilepos", "square", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_square_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_square_uniq([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_square_uniq([]) == []\nassert op_takewhilepos_square_uniq([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_uniq([5, 5, 5]) == [25]\nassert op_takewhilepos_square_uniq([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_square_uniq([10]) == [100]\nassert op_takewhilepos_square_uniq([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_square_uniq([-7, 12, -7]) == []"}
{"id": "op_ages_beforezero_min", "entry_point": "op_ages_beforezero_min", "primitives": ["ages", "beforezero", "min"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then return the minimum (0 if empty).", "solution": "def op_ages_beforezero_min(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return min(r) if r else 0", "tests": "assert op_ages_beforezero_min([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_beforezero_min([]) == 0\nassert op_ages_beforezero_min([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 17\nassert op_ages_beforezero_min([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_upper_dropshort_prefixup", "entry_point": "op_upper_dropshort_prefixup", "primitives": ["upper", "dropshort", "prefixup"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then drop strings shorter than three characters, then prefix each with a hash.", "solution": "def op_upper_dropshort_prefixup(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_upper_dropshort_prefixup(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_upper_dropshort_prefixup([]) == []\nassert op_upper_dropshort_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ']\nassert op_upper_dropshort_prefixup(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_upper_dropshort_prefixup(['x']) == []\nassert op_upper_dropshort_prefixup(['abc', 'de', '']) == ['#ABC']"}
{"id": "op_trimends_negate_counteven", "entry_point": "op_trimends_negate_counteven", "primitives": ["trimends", "negate", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then return how many values are even.", "solution": "def op_trimends_negate_counteven(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_trimends_negate_counteven([1, 2, 3, 4]) == 1\nassert op_trimends_negate_counteven([]) == 0\nassert op_trimends_negate_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_negate_counteven([5, 5, 5]) == 0\nassert op_trimends_negate_counteven([3, 1, 2]) == 0\nassert op_trimends_negate_counteven([10]) == 0\nassert op_trimends_negate_counteven([2, 4, 6]) == 1\nassert op_trimends_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_div3_counteven", "entry_point": "op_dropzeros_div3_counteven", "primitives": ["dropzeros", "div3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then return how many values are even.", "solution": "def op_dropzeros_div3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_div3_counteven([1, 2, 3, 4]) == 0\nassert op_dropzeros_div3_counteven([]) == 0\nassert op_dropzeros_div3_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropzeros_div3_counteven([5, 5, 5]) == 0\nassert op_dropzeros_div3_counteven([3, 1, 2]) == 0\nassert op_dropzeros_div3_counteven([10]) == 0\nassert op_dropzeros_div3_counteven([2, 4, 6]) == 1\nassert op_dropzeros_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_beforezero_square_evens", "entry_point": "op_beforezero_square_evens", "primitives": ["beforezero", "square", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then square each, then keep the even numbers.", "solution": "def op_beforezero_square_evens(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_beforezero_square_evens([1, 2, 3, 4]) == [4, 16]\nassert op_beforezero_square_evens([]) == []\nassert op_beforezero_square_evens([-2, -1, 0, 1, 2]) == [4]\nassert op_beforezero_square_evens([5, 5, 5]) == []\nassert op_beforezero_square_evens([3, 1, 2]) == [4]\nassert op_beforezero_square_evens([10]) == [100]\nassert op_beforezero_square_evens([2, 4, 6]) == [4, 16, 36]\nassert op_beforezero_square_evens([-7, 12, -7]) == [144]"}
{"id": "op_negate_oremptyzero_double", "entry_point": "op_negate_oremptyzero_double", "primitives": ["negate", "oremptyzero", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then double each.", "solution": "def op_negate_oremptyzero_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_oremptyzero_double([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_negate_oremptyzero_double([]) == [0]\nassert op_negate_oremptyzero_double([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_negate_oremptyzero_double([5, 5, 5]) == [-10, -10, -10]\nassert op_negate_oremptyzero_double([3, 1, 2]) == [-6, -2, -4]\nassert op_negate_oremptyzero_double([10]) == [-20]\nassert op_negate_oremptyzero_double([2, 4, 6]) == [-4, -8, -12]\nassert op_negate_oremptyzero_double([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_add10_neg_clamp10", "entry_point": "op_add10_neg_clamp10", "primitives": ["add10", "neg", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the negative numbers, then cap each value at 10.", "solution": "def op_add10_neg_clamp10(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_add10_neg_clamp10([1, 2, 3, 4]) == []\nassert op_add10_neg_clamp10([]) == []\nassert op_add10_neg_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_add10_neg_clamp10([5, 5, 5]) == []\nassert op_add10_neg_clamp10([3, 1, 2]) == []\nassert op_add10_neg_clamp10([10]) == []\nassert op_add10_neg_clamp10([2, 4, 6]) == []\nassert op_add10_neg_clamp10([-7, 12, -7]) == []"}
{"id": "op_last3_square_sum", "entry_point": "op_last3_square_sum", "primitives": ["last3", "square", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then square each, then return their sum.", "solution": "def op_last3_square_sum(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * x for x in r]\n    return sum(r)", "tests": "assert op_last3_square_sum([1, 2, 3, 4]) == 29\nassert op_last3_square_sum([]) == 0\nassert op_last3_square_sum([-2, -1, 0, 1, 2]) == 5\nassert op_last3_square_sum([5, 5, 5]) == 75\nassert op_last3_square_sum([3, 1, 2]) == 14\nassert op_last3_square_sum([10]) == 100\nassert op_last3_square_sum([2, 4, 6]) == 56\nassert op_last3_square_sum([-7, 12, -7]) == 242"}
{"id": "op_dec_neg_uniq", "entry_point": "op_dec_neg_uniq", "primitives": ["dec", "neg", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then drop duplicates keeping first occurrence.", "solution": "def op_dec_neg_uniq(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dec_neg_uniq([1, 2, 3, 4]) == []\nassert op_dec_neg_uniq([]) == []\nassert op_dec_neg_uniq([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_neg_uniq([5, 5, 5]) == []\nassert op_dec_neg_uniq([3, 1, 2]) == []\nassert op_dec_neg_uniq([10]) == []\nassert op_dec_neg_uniq([2, 4, 6]) == []\nassert op_dec_neg_uniq([-7, 12, -7]) == [-8]"}
{"id": "op_sorta_last3_absval", "entry_point": "op_sorta_last3_absval", "primitives": ["sorta", "last3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep only the last three, then take the absolute value of each.", "solution": "def op_sorta_last3_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_last3_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sorta_last3_absval([]) == []\nassert op_sorta_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_sorta_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_last3_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_last3_absval([10]) == [10]\nassert op_sorta_last3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_last3_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_evens_padto3_len", "entry_point": "op_evens_padto3_len", "primitives": ["evens", "padto3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_evens_padto3_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_evens_padto3_len([1, 2, 3, 4]) == 3\nassert op_evens_padto3_len([]) == 3\nassert op_evens_padto3_len([-2, -1, 0, 1, 2]) == 3\nassert op_evens_padto3_len([5, 5, 5]) == 3\nassert op_evens_padto3_len([3, 1, 2]) == 3\nassert op_evens_padto3_len([10]) == 3\nassert op_evens_padto3_len([2, 4, 6]) == 3\nassert op_evens_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_double_dropwhileneg_negate", "entry_point": "op_double_dropwhileneg_negate", "primitives": ["double", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then negate each.", "solution": "def op_double_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_dropwhileneg_negate([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_dropwhileneg_negate([]) == []\nassert op_double_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_double_dropwhileneg_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_double_dropwhileneg_negate([3, 1, 2]) == [-6, -2, -4]\nassert op_double_dropwhileneg_negate([10]) == [-20]\nassert op_double_dropwhileneg_negate([2, 4, 6]) == [-4, -8, -12]\nassert op_double_dropwhileneg_negate([-7, 12, -7]) == [-24, 14]"}
{"id": "op_dec_dropwhileneg_allpos", "entry_point": "op_dec_dropwhileneg_allpos", "primitives": ["dec", "dropwhileneg", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then return whether all values are positive.", "solution": "def op_dec_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_dropwhileneg_allpos([1, 2, 3, 4]) == False\nassert op_dec_dropwhileneg_allpos([]) == True\nassert op_dec_dropwhileneg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_dropwhileneg_allpos([5, 5, 5]) == True\nassert op_dec_dropwhileneg_allpos([3, 1, 2]) == False\nassert op_dec_dropwhileneg_allpos([10]) == True\nassert op_dec_dropwhileneg_allpos([2, 4, 6]) == True\nassert op_dec_dropwhileneg_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_gt5_trimends", "entry_point": "op_last3_gt5_trimends", "primitives": ["last3", "gt5", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep values greater than five, then drop the first and last elements.", "solution": "def op_last3_gt5_trimends(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_last3_gt5_trimends([1, 2, 3, 4]) == []\nassert op_last3_gt5_trimends([]) == []\nassert op_last3_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_last3_gt5_trimends([5, 5, 5]) == []\nassert op_last3_gt5_trimends([3, 1, 2]) == []\nassert op_last3_gt5_trimends([10]) == []\nassert op_last3_gt5_trimends([2, 4, 6]) == []\nassert op_last3_gt5_trimends([-7, 12, -7]) == []"}
{"id": "op_uniq_sortabs_issorted", "entry_point": "op_uniq_sortabs_issorted", "primitives": ["uniq", "sortabs", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value, then return whether the list is sorted ascending.", "solution": "def op_uniq_sortabs_issorted(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    return r == sorted(r)", "tests": "assert op_uniq_sortabs_issorted([1, 2, 3, 4]) == True\nassert op_uniq_sortabs_issorted([]) == True\nassert op_uniq_sortabs_issorted([-2, -1, 0, 1, 2]) == False\nassert op_uniq_sortabs_issorted([5, 5, 5]) == True\nassert op_uniq_sortabs_issorted([3, 1, 2]) == True\nassert op_uniq_sortabs_issorted([10]) == True\nassert op_uniq_sortabs_issorted([2, 4, 6]) == True\nassert op_uniq_sortabs_issorted([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_add10_absval", "entry_point": "op_dropwhileneg_add10_absval", "primitives": ["dropwhileneg", "add10", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then add ten to each, then take the absolute value of each.", "solution": "def op_dropwhileneg_add10_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_add10_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropwhileneg_add10_absval([]) == []\nassert op_dropwhileneg_add10_absval([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_dropwhileneg_add10_absval([5, 5, 5]) == [15, 15, 15]\nassert op_dropwhileneg_add10_absval([3, 1, 2]) == [13, 11, 12]\nassert op_dropwhileneg_add10_absval([10]) == [20]\nassert op_dropwhileneg_add10_absval([2, 4, 6]) == [12, 14, 16]\nassert op_dropwhileneg_add10_absval([-7, 12, -7]) == [22, 3]"}
{"id": "op_double_oremptyzero_dropzeros", "entry_point": "op_double_oremptyzero_dropzeros", "primitives": ["double", "oremptyzero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then drop the zeros.", "solution": "def op_double_oremptyzero_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_oremptyzero_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_dropzeros([]) == []\nassert op_double_oremptyzero_dropzeros([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_double_oremptyzero_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_dropzeros([10]) == [20]\nassert op_double_oremptyzero_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_dropzeros([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_oremptyzero_pos_alldistinct", "entry_point": "op_oremptyzero_pos_alldistinct", "primitives": ["oremptyzero", "pos", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then return whether all values are distinct.", "solution": "def op_oremptyzero_pos_alldistinct(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return len(r) == len(set(r))", "tests": "assert op_oremptyzero_pos_alldistinct([1, 2, 3, 4]) == True\nassert op_oremptyzero_pos_alldistinct([]) == True\nassert op_oremptyzero_pos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_pos_alldistinct([5, 5, 5]) == False\nassert op_oremptyzero_pos_alldistinct([3, 1, 2]) == True\nassert op_oremptyzero_pos_alldistinct([10]) == True\nassert op_oremptyzero_pos_alldistinct([2, 4, 6]) == True\nassert op_oremptyzero_pos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_last3_dropzeros_sortd", "entry_point": "op_last3_dropzeros_sortd", "primitives": ["last3", "dropzeros", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the zeros, then sort descending.", "solution": "def op_last3_dropzeros_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_dropzeros_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_dropzeros_sortd([]) == []\nassert op_last3_dropzeros_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_last3_dropzeros_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_dropzeros_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_dropzeros_sortd([10]) == [10]\nassert op_last3_dropzeros_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_dropzeros_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_trimends_double_negate", "entry_point": "op_trimends_double_negate", "primitives": ["trimends", "double", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then negate each.", "solution": "def op_trimends_double_negate(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_trimends_double_negate([1, 2, 3, 4]) == [-4, -6]\nassert op_trimends_double_negate([]) == []\nassert op_trimends_double_negate([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_trimends_double_negate([5, 5, 5]) == [-10]\nassert op_trimends_double_negate([3, 1, 2]) == [-2]\nassert op_trimends_double_negate([10]) == []\nassert op_trimends_double_negate([2, 4, 6]) == [-8]\nassert op_trimends_double_negate([-7, 12, -7]) == [-24]"}
{"id": "op_inc_oremptyzero_trimends", "entry_point": "op_inc_oremptyzero_trimends", "primitives": ["inc", "oremptyzero", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_inc_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_oremptyzero_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_inc_oremptyzero_trimends([]) == []\nassert op_inc_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_oremptyzero_trimends([5, 5, 5]) == [6]\nassert op_inc_oremptyzero_trimends([3, 1, 2]) == [2]\nassert op_inc_oremptyzero_trimends([10]) == []\nassert op_inc_oremptyzero_trimends([2, 4, 6]) == [5]\nassert op_inc_oremptyzero_trimends([-7, 12, -7]) == [13]"}
{"id": "op_absval_div3_padto3", "entry_point": "op_absval_div3_padto3", "primitives": ["absval", "div3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then pad with zeros to at least three elements.", "solution": "def op_absval_div3_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_div3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_absval_div3_padto3([]) == [0, 0, 0]\nassert op_absval_div3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_absval_div3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_absval_div3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_absval_div3_padto3([10]) == [0, 0, 0]\nassert op_absval_div3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_absval_div3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_ages_trimends_sortabs", "entry_point": "op_ages_trimends_sortabs", "primitives": ["ages", "trimends", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then sort by absolute value.", "solution": "def op_ages_trimends_sortabs(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_ages_trimends_sortabs([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_sortabs([]) == []\nassert op_ages_trimends_sortabs([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65]\nassert op_ages_trimends_sortabs([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_clamp10_rev_sum", "entry_point": "op_clamp10_rev_sum", "primitives": ["clamp10", "rev", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then return their sum.", "solution": "def op_clamp10_rev_sum(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    return sum(r)", "tests": "assert op_clamp10_rev_sum([1, 2, 3, 4]) == 10\nassert op_clamp10_rev_sum([]) == 0\nassert op_clamp10_rev_sum([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_rev_sum([5, 5, 5]) == 15\nassert op_clamp10_rev_sum([3, 1, 2]) == 6\nassert op_clamp10_rev_sum([10]) == 10\nassert op_clamp10_rev_sum([2, 4, 6]) == 12\nassert op_clamp10_rev_sum([-7, 12, -7]) == -4"}
{"id": "op_dropfirst_evens_square", "entry_point": "op_dropfirst_evens_square", "primitives": ["dropfirst", "evens", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the even numbers, then square each.", "solution": "def op_dropfirst_evens_square(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x % 2 == 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropfirst_evens_square([1, 2, 3, 4]) == [4, 16]\nassert op_dropfirst_evens_square([]) == []\nassert op_dropfirst_evens_square([-2, -1, 0, 1, 2]) == [0, 4]\nassert op_dropfirst_evens_square([5, 5, 5]) == []\nassert op_dropfirst_evens_square([3, 1, 2]) == [4]\nassert op_dropfirst_evens_square([10]) == []\nassert op_dropfirst_evens_square([2, 4, 6]) == [16, 36]\nassert op_dropfirst_evens_square([-7, 12, -7]) == [144]"}
{"id": "op_odds_dropzeros_add10", "entry_point": "op_odds_dropzeros_add10", "primitives": ["odds", "dropzeros", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the zeros, then add ten to each.", "solution": "def op_odds_dropzeros_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_odds_dropzeros_add10([1, 2, 3, 4]) == [11, 13]\nassert op_odds_dropzeros_add10([]) == []\nassert op_odds_dropzeros_add10([-2, -1, 0, 1, 2]) == [9, 11]\nassert op_odds_dropzeros_add10([5, 5, 5]) == [15, 15, 15]\nassert op_odds_dropzeros_add10([3, 1, 2]) == [13, 11]\nassert op_odds_dropzeros_add10([10]) == []\nassert op_odds_dropzeros_add10([2, 4, 6]) == []\nassert op_odds_dropzeros_add10([-7, 12, -7]) == [3, 3]"}
{"id": "op_square_dropfirst_dropwhileneg", "entry_point": "op_square_dropfirst_dropwhileneg", "primitives": ["square", "dropfirst", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first element, then drop the leading negative values.", "solution": "def op_square_dropfirst_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_dropfirst_dropwhileneg([1, 2, 3, 4]) == [4, 9, 16]\nassert op_square_dropfirst_dropwhileneg([]) == []\nassert op_square_dropfirst_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 0, 1, 4]\nassert op_square_dropfirst_dropwhileneg([5, 5, 5]) == [25, 25]\nassert op_square_dropfirst_dropwhileneg([3, 1, 2]) == [1, 4]\nassert op_square_dropfirst_dropwhileneg([10]) == []\nassert op_square_dropfirst_dropwhileneg([2, 4, 6]) == [16, 36]\nassert op_square_dropfirst_dropwhileneg([-7, 12, -7]) == [144, 49]"}
{"id": "op_negate_gt5_square", "entry_point": "op_negate_gt5_square", "primitives": ["negate", "gt5", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep values greater than five, then square each.", "solution": "def op_negate_gt5_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_gt5_square([1, 2, 3, 4]) == []\nassert op_negate_gt5_square([]) == []\nassert op_negate_gt5_square([-2, -1, 0, 1, 2]) == []\nassert op_negate_gt5_square([5, 5, 5]) == []\nassert op_negate_gt5_square([3, 1, 2]) == []\nassert op_negate_gt5_square([10]) == []\nassert op_negate_gt5_square([2, 4, 6]) == []\nassert op_negate_gt5_square([-7, 12, -7]) == [49, 49]"}
{"id": "op_div3_square_add10", "entry_point": "op_div3_square_add10", "primitives": ["div3", "square", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then add ten to each.", "solution": "def op_div3_square_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_div3_square_add10([1, 2, 3, 4]) == [19]\nassert op_div3_square_add10([]) == []\nassert op_div3_square_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_div3_square_add10([5, 5, 5]) == []\nassert op_div3_square_add10([3, 1, 2]) == [19]\nassert op_div3_square_add10([10]) == []\nassert op_div3_square_add10([2, 4, 6]) == [46]\nassert op_div3_square_add10([-7, 12, -7]) == [154]"}
{"id": "op_sortd_oremptyzero_trimends", "entry_point": "op_sortd_oremptyzero_trimends", "primitives": ["sortd", "oremptyzero", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_sortd_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_sortd_oremptyzero_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_sortd_oremptyzero_trimends([]) == []\nassert op_sortd_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortd_oremptyzero_trimends([5, 5, 5]) == [5]\nassert op_sortd_oremptyzero_trimends([3, 1, 2]) == [2]\nassert op_sortd_oremptyzero_trimends([10]) == []\nassert op_sortd_oremptyzero_trimends([2, 4, 6]) == [4]\nassert op_sortd_oremptyzero_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_sorta_padto3_takewhilepos", "entry_point": "op_sorta_padto3_takewhilepos", "primitives": ["sorta", "padto3", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then take values while they are positive.", "solution": "def op_sorta_padto3_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sorta_padto3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_padto3_takewhilepos([]) == []\nassert op_sorta_padto3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sorta_padto3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_padto3_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_padto3_takewhilepos([10]) == [10]\nassert op_sorta_padto3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_padto3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_add10_padto3_dropfirst", "entry_point": "op_add10_padto3_dropfirst", "primitives": ["add10", "padto3", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_add10_padto3_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_add10_padto3_dropfirst([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_padto3_dropfirst([]) == [0, 0]\nassert op_add10_padto3_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_padto3_dropfirst([5, 5, 5]) == [15, 15]\nassert op_add10_padto3_dropfirst([3, 1, 2]) == [11, 12]\nassert op_add10_padto3_dropfirst([10]) == [0, 0]\nassert op_add10_padto3_dropfirst([2, 4, 6]) == [14, 16]\nassert op_add10_padto3_dropfirst([-7, 12, -7]) == [22, 3]"}
{"id": "op_sortd_beforezero_neg", "entry_point": "op_sortd_beforezero_neg", "primitives": ["sortd", "beforezero", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then keep the negative numbers.", "solution": "def op_sortd_beforezero_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_beforezero_neg([1, 2, 3, 4]) == []\nassert op_sortd_beforezero_neg([]) == []\nassert op_sortd_beforezero_neg([-2, -1, 0, 1, 2]) == []\nassert op_sortd_beforezero_neg([5, 5, 5]) == []\nassert op_sortd_beforezero_neg([3, 1, 2]) == []\nassert op_sortd_beforezero_neg([10]) == []\nassert op_sortd_beforezero_neg([2, 4, 6]) == []\nassert op_sortd_beforezero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_square_takewhilepos_odds", "entry_point": "op_square_takewhilepos_odds", "primitives": ["square", "takewhilepos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then keep the odd numbers.", "solution": "def op_square_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_takewhilepos_odds([1, 2, 3, 4]) == [1, 9]\nassert op_square_takewhilepos_odds([]) == []\nassert op_square_takewhilepos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_square_takewhilepos_odds([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_odds([3, 1, 2]) == [9, 1]\nassert op_square_takewhilepos_odds([10]) == []\nassert op_square_takewhilepos_odds([2, 4, 6]) == []\nassert op_square_takewhilepos_odds([-7, 12, -7]) == [49, 49]"}
{"id": "op_sortabs_padto3_evens", "entry_point": "op_sortabs_padto3_evens", "primitives": ["sortabs", "padto3", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then keep the even numbers.", "solution": "def op_sortabs_padto3_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_padto3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_padto3_evens([]) == [0, 0, 0]\nassert op_sortabs_padto3_evens([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_padto3_evens([5, 5, 5]) == []\nassert op_sortabs_padto3_evens([3, 1, 2]) == [2]\nassert op_sortabs_padto3_evens([10]) == [10, 0, 0]\nassert op_sortabs_padto3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_padto3_evens([-7, 12, -7]) == [12]"}
{"id": "op_absval_first3_dec", "entry_point": "op_absval_first3_dec", "primitives": ["absval", "first3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then subtract one from each.", "solution": "def op_absval_first3_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_first3_dec([1, 2, 3, 4]) == [0, 1, 2]\nassert op_absval_first3_dec([]) == []\nassert op_absval_first3_dec([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_absval_first3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_first3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_absval_first3_dec([10]) == [9]\nassert op_absval_first3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_absval_first3_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_gt5_clamp10_anyeven", "entry_point": "op_gt5_clamp10_anyeven", "primitives": ["gt5", "clamp10", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then cap each value at 10, then return whether any value is even.", "solution": "def op_gt5_clamp10_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [min(x, 10) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_clamp10_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_clamp10_anyeven([]) == False\nassert op_gt5_clamp10_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_clamp10_anyeven([5, 5, 5]) == False\nassert op_gt5_clamp10_anyeven([3, 1, 2]) == False\nassert op_gt5_clamp10_anyeven([10]) == True\nassert op_gt5_clamp10_anyeven([2, 4, 6]) == True\nassert op_gt5_clamp10_anyeven([-7, 12, -7]) == True"}
{"id": "op_last3_inc_alldistinct", "entry_point": "op_last3_inc_alldistinct", "primitives": ["last3", "inc", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then return whether all values are distinct.", "solution": "def op_last3_inc_alldistinct(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_last3_inc_alldistinct([1, 2, 3, 4]) == True\nassert op_last3_inc_alldistinct([]) == True\nassert op_last3_inc_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_last3_inc_alldistinct([5, 5, 5]) == False\nassert op_last3_inc_alldistinct([3, 1, 2]) == True\nassert op_last3_inc_alldistinct([10]) == True\nassert op_last3_inc_alldistinct([2, 4, 6]) == True\nassert op_last3_inc_alldistinct([-7, 12, -7]) == False"}
{"id": "op_absval_odds_dropfirst", "entry_point": "op_absval_odds_dropfirst", "primitives": ["absval", "odds", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers, then drop the first element.", "solution": "def op_absval_odds_dropfirst(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_absval_odds_dropfirst([1, 2, 3, 4]) == [3]\nassert op_absval_odds_dropfirst([]) == []\nassert op_absval_odds_dropfirst([-2, -1, 0, 1, 2]) == [1]\nassert op_absval_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_absval_odds_dropfirst([3, 1, 2]) == [1]\nassert op_absval_odds_dropfirst([10]) == []\nassert op_absval_odds_dropfirst([2, 4, 6]) == []\nassert op_absval_odds_dropfirst([-7, 12, -7]) == [7]"}
{"id": "op_negate_div3_dec", "entry_point": "op_negate_div3_dec", "primitives": ["negate", "div3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep multiples of three, then subtract one from each.", "solution": "def op_negate_div3_dec(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_negate_div3_dec([1, 2, 3, 4]) == [-4]\nassert op_negate_div3_dec([]) == []\nassert op_negate_div3_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_negate_div3_dec([5, 5, 5]) == []\nassert op_negate_div3_dec([3, 1, 2]) == [-4]\nassert op_negate_div3_dec([10]) == []\nassert op_negate_div3_dec([2, 4, 6]) == [-7]\nassert op_negate_div3_dec([-7, 12, -7]) == [-13]"}
{"id": "op_dropfirst_sorta_sortabs", "entry_point": "op_dropfirst_sorta_sortabs", "primitives": ["dropfirst", "sorta", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then sort by absolute value.", "solution": "def op_dropfirst_sorta_sortabs(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropfirst_sorta_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sorta_sortabs([]) == []\nassert op_dropfirst_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, 2]\nassert op_dropfirst_sorta_sortabs([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sorta_sortabs([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sorta_sortabs([10]) == []\nassert op_dropfirst_sorta_sortabs([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sorta_sortabs([-7, 12, -7]) == [-7, 12]"}
{"id": "op_dec_dropwhileneg_haszero", "entry_point": "op_dec_dropwhileneg_haszero", "primitives": ["dec", "dropwhileneg", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_dec_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_dec_dropwhileneg_haszero([1, 2, 3, 4]) == True\nassert op_dec_dropwhileneg_haszero([]) == False\nassert op_dec_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dec_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_dec_dropwhileneg_haszero([3, 1, 2]) == True\nassert op_dec_dropwhileneg_haszero([10]) == False\nassert op_dec_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_dec_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_sortd_pos", "entry_point": "op_dropfirst_sortd_pos", "primitives": ["dropfirst", "sortd", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then keep the positive numbers.", "solution": "def op_dropfirst_sortd_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_sortd_pos([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_sortd_pos([]) == []\nassert op_dropfirst_sortd_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_dropfirst_sortd_pos([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortd_pos([3, 1, 2]) == [2, 1]\nassert op_dropfirst_sortd_pos([10]) == []\nassert op_dropfirst_sortd_pos([2, 4, 6]) == [6, 4]\nassert op_dropfirst_sortd_pos([-7, 12, -7]) == [12]"}
{"id": "op_uniq_dec_prod", "entry_point": "op_uniq_dec_prod", "primitives": ["uniq", "dec", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then subtract one from each, then return their product.", "solution": "def op_uniq_dec_prod(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_uniq_dec_prod([1, 2, 3, 4]) == 0\nassert op_uniq_dec_prod([]) == 1\nassert op_uniq_dec_prod([-2, -1, 0, 1, 2]) == 0\nassert op_uniq_dec_prod([5, 5, 5]) == 4\nassert op_uniq_dec_prod([3, 1, 2]) == 0\nassert op_uniq_dec_prod([10]) == 9\nassert op_uniq_dec_prod([2, 4, 6]) == 15\nassert op_uniq_dec_prod([-7, 12, -7]) == -88"}
{"id": "op_last3_beforezero_dropzeros", "entry_point": "op_last3_beforezero_dropzeros", "primitives": ["last3", "beforezero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then drop the zeros.", "solution": "def op_last3_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_last3_beforezero_dropzeros([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_beforezero_dropzeros([]) == []\nassert op_last3_beforezero_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_last3_beforezero_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_last3_beforezero_dropzeros([10]) == [10]\nassert op_last3_beforezero_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_last3_beforezero_dropzeros([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_add10_oremptyzero_firsteven", "entry_point": "op_add10_oremptyzero_firsteven", "primitives": ["add10", "oremptyzero", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then if empty, use a single zero, then return the first even value (0 if none).", "solution": "def op_add10_oremptyzero_firsteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_add10_oremptyzero_firsteven([1, 2, 3, 4]) == 12\nassert op_add10_oremptyzero_firsteven([]) == 0\nassert op_add10_oremptyzero_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_add10_oremptyzero_firsteven([5, 5, 5]) == 0\nassert op_add10_oremptyzero_firsteven([3, 1, 2]) == 12\nassert op_add10_oremptyzero_firsteven([10]) == 20\nassert op_add10_oremptyzero_firsteven([2, 4, 6]) == 12\nassert op_add10_oremptyzero_firsteven([-7, 12, -7]) == 22"}
{"id": "op_neg_rev_max", "entry_point": "op_neg_rev_max", "primitives": ["neg", "rev", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then return the maximum (0 if empty).", "solution": "def op_neg_rev_max(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return max(r) if r else 0", "tests": "assert op_neg_rev_max([1, 2, 3, 4]) == 0\nassert op_neg_rev_max([]) == 0\nassert op_neg_rev_max([-2, -1, 0, 1, 2]) == -1\nassert op_neg_rev_max([5, 5, 5]) == 0\nassert op_neg_rev_max([3, 1, 2]) == 0\nassert op_neg_rev_max([10]) == 0\nassert op_neg_rev_max([2, 4, 6]) == 0\nassert op_neg_rev_max([-7, 12, -7]) == -7"}
{"id": "op_last3_sortabs_square", "entry_point": "op_last3_sortabs_square", "primitives": ["last3", "sortabs", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then square each.", "solution": "def op_last3_sortabs_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_sortabs_square([1, 2, 3, 4]) == [4, 9, 16]\nassert op_last3_sortabs_square([]) == []\nassert op_last3_sortabs_square([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_last3_sortabs_square([5, 5, 5]) == [25, 25, 25]\nassert op_last3_sortabs_square([3, 1, 2]) == [1, 4, 9]\nassert op_last3_sortabs_square([10]) == [100]\nassert op_last3_sortabs_square([2, 4, 6]) == [4, 16, 36]\nassert op_last3_sortabs_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dec_padto3_alldistinct", "entry_point": "op_dec_padto3_alldistinct", "primitives": ["dec", "padto3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then return whether all values are distinct.", "solution": "def op_dec_padto3_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r) == len(set(r))", "tests": "assert op_dec_padto3_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_padto3_alldistinct([]) == False\nassert op_dec_padto3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_padto3_alldistinct([5, 5, 5]) == False\nassert op_dec_padto3_alldistinct([3, 1, 2]) == True\nassert op_dec_padto3_alldistinct([10]) == False\nassert op_dec_padto3_alldistinct([2, 4, 6]) == True\nassert op_dec_padto3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_ages_absval_max", "entry_point": "op_ages_absval_max", "primitives": ["ages", "absval", "max"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_ages_absval_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_ages_absval_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_absval_max([]) == 0\nassert op_ages_absval_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_absval_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_absval_first3_oremptyzero", "entry_point": "op_absval_first3_oremptyzero", "primitives": ["absval", "first3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then if empty, use a single zero.", "solution": "def op_absval_first3_oremptyzero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_absval_first3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_absval_first3_oremptyzero([]) == [0]\nassert op_absval_first3_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_absval_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_absval_first3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_absval_first3_oremptyzero([10]) == [10]\nassert op_absval_first3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_absval_first3_oremptyzero([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_uniq_negate", "entry_point": "op_double_uniq_negate", "primitives": ["double", "uniq", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_double_uniq_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_uniq_negate([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_uniq_negate([]) == []\nassert op_double_uniq_negate([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_uniq_negate([5, 5, 5]) == [-10]\nassert op_double_uniq_negate([3, 1, 2]) == [-6, -2, -4]\nassert op_double_uniq_negate([10]) == [-20]\nassert op_double_uniq_negate([2, 4, 6]) == [-4, -8, -12]\nassert op_double_uniq_negate([-7, 12, -7]) == [14, -24]"}
{"id": "op_square_padto3_sortd", "entry_point": "op_square_padto3_sortd", "primitives": ["square", "padto3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_square_padto3_sortd(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_square_padto3_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_padto3_sortd([]) == [0, 0, 0]\nassert op_square_padto3_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_square_padto3_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_square_padto3_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_square_padto3_sortd([10]) == [100, 0, 0]\nassert op_square_padto3_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_square_padto3_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_negate_evens_sorta", "entry_point": "op_negate_evens_sorta", "primitives": ["negate", "evens", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the even numbers, then sort ascending.", "solution": "def op_negate_evens_sorta(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_negate_evens_sorta([1, 2, 3, 4]) == [-4, -2]\nassert op_negate_evens_sorta([]) == []\nassert op_negate_evens_sorta([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_negate_evens_sorta([5, 5, 5]) == []\nassert op_negate_evens_sorta([3, 1, 2]) == [-2]\nassert op_negate_evens_sorta([10]) == [-10]\nassert op_negate_evens_sorta([2, 4, 6]) == [-6, -4, -2]\nassert op_negate_evens_sorta([-7, 12, -7]) == [-12]"}
{"id": "op_trimends_oremptyzero_dropfirst", "entry_point": "op_trimends_oremptyzero_dropfirst", "primitives": ["trimends", "oremptyzero", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then drop the first element.", "solution": "def op_trimends_oremptyzero_dropfirst(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    r = r[1:]\n    return r", "tests": "assert op_trimends_oremptyzero_dropfirst([1, 2, 3, 4]) == [3]\nassert op_trimends_oremptyzero_dropfirst([]) == []\nassert op_trimends_oremptyzero_dropfirst([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_oremptyzero_dropfirst([5, 5, 5]) == []\nassert op_trimends_oremptyzero_dropfirst([3, 1, 2]) == []\nassert op_trimends_oremptyzero_dropfirst([10]) == []\nassert op_trimends_oremptyzero_dropfirst([2, 4, 6]) == []\nassert op_trimends_oremptyzero_dropfirst([-7, 12, -7]) == []"}
{"id": "op_sorta_dropwhileneg_trimends", "entry_point": "op_sorta_dropwhileneg_trimends", "primitives": ["sorta", "dropwhileneg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_sorta_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_dropwhileneg_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_sorta_dropwhileneg_trimends([]) == []\nassert op_sorta_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_sorta_dropwhileneg_trimends([5, 5, 5]) == [5]\nassert op_sorta_dropwhileneg_trimends([3, 1, 2]) == [2]\nassert op_sorta_dropwhileneg_trimends([10]) == []\nassert op_sorta_dropwhileneg_trimends([2, 4, 6]) == [4]\nassert op_sorta_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_square_dec_inc", "entry_point": "op_square_dec_inc", "primitives": ["square", "dec", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each, then add one to each.", "solution": "def op_square_dec_inc(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_square_dec_inc([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_dec_inc([]) == []\nassert op_square_dec_inc([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_dec_inc([5, 5, 5]) == [25, 25, 25]\nassert op_square_dec_inc([3, 1, 2]) == [9, 1, 4]\nassert op_square_dec_inc([10]) == [100]\nassert op_square_dec_inc([2, 4, 6]) == [4, 16, 36]\nassert op_square_dec_inc([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_evens_sortabs_allpos", "entry_point": "op_evens_sortabs_allpos", "primitives": ["evens", "sortabs", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort by absolute value, then return whether all values are positive.", "solution": "def op_evens_sortabs_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_evens_sortabs_allpos([1, 2, 3, 4]) == True\nassert op_evens_sortabs_allpos([]) == True\nassert op_evens_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_sortabs_allpos([5, 5, 5]) == True\nassert op_evens_sortabs_allpos([3, 1, 2]) == True\nassert op_evens_sortabs_allpos([10]) == True\nassert op_evens_sortabs_allpos([2, 4, 6]) == True\nassert op_evens_sortabs_allpos([-7, 12, -7]) == True"}
{"id": "op_sorta_oremptyzero_pos", "entry_point": "op_sorta_oremptyzero_pos", "primitives": ["sorta", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_sorta_oremptyzero_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_oremptyzero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sorta_oremptyzero_pos([]) == []\nassert op_sorta_oremptyzero_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sorta_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_oremptyzero_pos([3, 1, 2]) == [1, 2, 3]\nassert op_sorta_oremptyzero_pos([10]) == [10]\nassert op_sorta_oremptyzero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_div3_oremptyzero", "entry_point": "op_dropzeros_div3_oremptyzero", "primitives": ["dropzeros", "div3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then if empty, use a single zero.", "solution": "def op_dropzeros_div3_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_div3_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_oremptyzero([]) == [0]\nassert op_dropzeros_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_dropzeros_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_dropzeros_div3_oremptyzero([3, 1, 2]) == [3]\nassert op_dropzeros_div3_oremptyzero([10]) == [0]\nassert op_dropzeros_div3_oremptyzero([2, 4, 6]) == [6]\nassert op_dropzeros_div3_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_odds_rev_firsteven", "entry_point": "op_odds_rev_firsteven", "primitives": ["odds", "rev", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then reverse the order, then return the first even value (0 if none).", "solution": "def op_odds_rev_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_odds_rev_firsteven([1, 2, 3, 4]) == 0\nassert op_odds_rev_firsteven([]) == 0\nassert op_odds_rev_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_odds_rev_firsteven([5, 5, 5]) == 0\nassert op_odds_rev_firsteven([3, 1, 2]) == 0\nassert op_odds_rev_firsteven([10]) == 0\nassert op_odds_rev_firsteven([2, 4, 6]) == 0\nassert op_odds_rev_firsteven([-7, 12, -7]) == 0"}
{"id": "op_sortabs_sorta_beforezero", "entry_point": "op_sortabs_sorta_beforezero", "primitives": ["sortabs", "sorta", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then keep everything before the first zero.", "solution": "def op_sortabs_sorta_beforezero(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_sortabs_sorta_beforezero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_sorta_beforezero([]) == []\nassert op_sortabs_sorta_beforezero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_sortabs_sorta_beforezero([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta_beforezero([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_sorta_beforezero([10]) == [10]\nassert op_sortabs_sorta_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_sorta_beforezero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_negate_dropwhileneg_dropzeros", "entry_point": "op_negate_dropwhileneg_dropzeros", "primitives": ["negate", "dropwhileneg", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then drop the zeros.", "solution": "def op_negate_dropwhileneg_dropzeros(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_negate_dropwhileneg_dropzeros([1, 2, 3, 4]) == []\nassert op_negate_dropwhileneg_dropzeros([]) == []\nassert op_negate_dropwhileneg_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_negate_dropwhileneg_dropzeros([5, 5, 5]) == []\nassert op_negate_dropwhileneg_dropzeros([3, 1, 2]) == []\nassert op_negate_dropwhileneg_dropzeros([10]) == []\nassert op_negate_dropwhileneg_dropzeros([2, 4, 6]) == []\nassert op_negate_dropwhileneg_dropzeros([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_inc_absval_trimends", "entry_point": "op_inc_absval_trimends", "primitives": ["inc", "absval", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_inc_absval_trimends(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_inc_absval_trimends([1, 2, 3, 4]) == [3, 4]\nassert op_inc_absval_trimends([]) == []\nassert op_inc_absval_trimends([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_absval_trimends([5, 5, 5]) == [6]\nassert op_inc_absval_trimends([3, 1, 2]) == [2]\nassert op_inc_absval_trimends([10]) == []\nassert op_inc_absval_trimends([2, 4, 6]) == [5]\nassert op_inc_absval_trimends([-7, 12, -7]) == [13]"}
{"id": "op_inc_trimends_dropzeros", "entry_point": "op_inc_trimends_dropzeros", "primitives": ["inc", "trimends", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then drop the zeros.", "solution": "def op_inc_trimends_dropzeros(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_inc_trimends_dropzeros([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends_dropzeros([]) == []\nassert op_inc_trimends_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_inc_trimends_dropzeros([5, 5, 5]) == [6]\nassert op_inc_trimends_dropzeros([3, 1, 2]) == [2]\nassert op_inc_trimends_dropzeros([10]) == []\nassert op_inc_trimends_dropzeros([2, 4, 6]) == [5]\nassert op_inc_trimends_dropzeros([-7, 12, -7]) == [13]"}
{"id": "op_dropfirst_clamp10_alldistinct", "entry_point": "op_dropfirst_clamp10_alldistinct", "primitives": ["dropfirst", "clamp10", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then return whether all values are distinct.", "solution": "def op_dropfirst_clamp10_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_clamp10_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_clamp10_alldistinct([]) == True\nassert op_dropfirst_clamp10_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_clamp10_alldistinct([5, 5, 5]) == False\nassert op_dropfirst_clamp10_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_clamp10_alldistinct([10]) == True\nassert op_dropfirst_clamp10_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_clamp10_alldistinct([-7, 12, -7]) == True"}
{"id": "op_rev_dropzeros_sortd", "entry_point": "op_rev_dropzeros_sortd", "primitives": ["rev", "dropzeros", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the zeros, then sort descending.", "solution": "def op_rev_dropzeros_sortd(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_rev_dropzeros_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_dropzeros_sortd([]) == []\nassert op_rev_dropzeros_sortd([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_rev_dropzeros_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_rev_dropzeros_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_rev_dropzeros_sortd([10]) == [10]\nassert op_rev_dropzeros_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_rev_dropzeros_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_trimends_double_square", "entry_point": "op_trimends_double_square", "primitives": ["trimends", "double", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then double each, then square each.", "solution": "def op_trimends_double_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_double_square([1, 2, 3, 4]) == [16, 36]\nassert op_trimends_double_square([]) == []\nassert op_trimends_double_square([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_trimends_double_square([5, 5, 5]) == [100]\nassert op_trimends_double_square([3, 1, 2]) == [4]\nassert op_trimends_double_square([10]) == []\nassert op_trimends_double_square([2, 4, 6]) == [64]\nassert op_trimends_double_square([-7, 12, -7]) == [576]"}
{"id": "op_takewhilepos_dropwhileneg_neg", "entry_point": "op_takewhilepos_dropwhileneg_neg", "primitives": ["takewhilepos", "dropwhileneg", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_takewhilepos_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_takewhilepos_dropwhileneg_neg([]) == []\nassert op_takewhilepos_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_neg([5, 5, 5]) == []\nassert op_takewhilepos_dropwhileneg_neg([3, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_neg([10]) == []\nassert op_takewhilepos_dropwhileneg_neg([2, 4, 6]) == []\nassert op_takewhilepos_dropwhileneg_neg([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_sortabs_negate", "entry_point": "op_takewhilepos_sortabs_negate", "primitives": ["takewhilepos", "sortabs", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then negate each.", "solution": "def op_takewhilepos_sortabs_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_sortabs_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_takewhilepos_sortabs_negate([]) == []\nassert op_takewhilepos_sortabs_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_takewhilepos_sortabs_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_takewhilepos_sortabs_negate([10]) == [-10]\nassert op_takewhilepos_sortabs_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_takewhilepos_sortabs_negate([-7, 12, -7]) == []"}
{"id": "op_sortd_evens_max", "entry_point": "op_sortd_evens_max", "primitives": ["sortd", "evens", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_sortd_evens_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_sortd_evens_max([1, 2, 3, 4]) == 4\nassert op_sortd_evens_max([]) == 0\nassert op_sortd_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_sortd_evens_max([5, 5, 5]) == 0\nassert op_sortd_evens_max([3, 1, 2]) == 2\nassert op_sortd_evens_max([10]) == 10\nassert op_sortd_evens_max([2, 4, 6]) == 6\nassert op_sortd_evens_max([-7, 12, -7]) == 12"}
{"id": "op_first3_div3_dropwhileneg", "entry_point": "op_first3_div3_dropwhileneg", "primitives": ["first3", "div3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep multiples of three, then drop the leading negative values.", "solution": "def op_first3_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_div3_dropwhileneg([1, 2, 3, 4]) == [3]\nassert op_first3_div3_dropwhileneg([]) == []\nassert op_first3_div3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_div3_dropwhileneg([5, 5, 5]) == []\nassert op_first3_div3_dropwhileneg([3, 1, 2]) == [3]\nassert op_first3_div3_dropwhileneg([10]) == []\nassert op_first3_div3_dropwhileneg([2, 4, 6]) == [6]\nassert op_first3_div3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_uniqs_sortalpha_dropshort", "entry_point": "op_uniqs_sortalpha_dropshort", "primitives": ["uniqs", "sortalpha", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically, then drop strings shorter than three characters.", "solution": "def op_uniqs_sortalpha_dropshort(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_uniqs_sortalpha_dropshort(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_sortalpha_dropshort([]) == []\nassert op_uniqs_sortalpha_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_uniqs_sortalpha_dropshort(['one', 'one', 'Two']) == ['Two', 'one']\nassert op_uniqs_sortalpha_dropshort(['x']) == []\nassert op_uniqs_sortalpha_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_div3_beforezero_trimends", "entry_point": "op_div3_beforezero_trimends", "primitives": ["div3", "beforezero", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then drop the first and last elements.", "solution": "def op_div3_beforezero_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    return r", "tests": "assert op_div3_beforezero_trimends([1, 2, 3, 4]) == []\nassert op_div3_beforezero_trimends([]) == []\nassert op_div3_beforezero_trimends([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_trimends([5, 5, 5]) == []\nassert op_div3_beforezero_trimends([3, 1, 2]) == []\nassert op_div3_beforezero_trimends([10]) == []\nassert op_div3_beforezero_trimends([2, 4, 6]) == []\nassert op_div3_beforezero_trimends([-7, 12, -7]) == []"}
{"id": "op_negate_square_sortd", "entry_point": "op_negate_square_sortd", "primitives": ["negate", "square", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then sort descending.", "solution": "def op_negate_square_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_negate_square_sortd([]) == []\nassert op_negate_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_negate_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_negate_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_negate_square_sortd([10]) == [100]\nassert op_negate_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_negate_square_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_negate_takewhilepos_pos", "entry_point": "op_negate_takewhilepos_pos", "primitives": ["negate", "takewhilepos", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then keep the positive numbers.", "solution": "def op_negate_takewhilepos_pos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_negate_takewhilepos_pos([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos_pos([]) == []\nassert op_negate_takewhilepos_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_takewhilepos_pos([5, 5, 5]) == []\nassert op_negate_takewhilepos_pos([3, 1, 2]) == []\nassert op_negate_takewhilepos_pos([10]) == []\nassert op_negate_takewhilepos_pos([2, 4, 6]) == []\nassert op_negate_takewhilepos_pos([-7, 12, -7]) == [7]"}
{"id": "op_sortd_trimends_oremptyzero", "entry_point": "op_sortd_trimends_oremptyzero", "primitives": ["sortd", "trimends", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then if empty, use a single zero.", "solution": "def op_sortd_trimends_oremptyzero(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    r = r if r else [0]\n    return r", "tests": "assert op_sortd_trimends_oremptyzero([1, 2, 3, 4]) == [3, 2]\nassert op_sortd_trimends_oremptyzero([]) == [0]\nassert op_sortd_trimends_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_sortd_trimends_oremptyzero([5, 5, 5]) == [5]\nassert op_sortd_trimends_oremptyzero([3, 1, 2]) == [2]\nassert op_sortd_trimends_oremptyzero([10]) == [0]\nassert op_sortd_trimends_oremptyzero([2, 4, 6]) == [4]\nassert op_sortd_trimends_oremptyzero([-7, 12, -7]) == [-7]"}
{"id": "op_inc_add10_allpos", "entry_point": "op_inc_add10_allpos", "primitives": ["inc", "add10", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return whether all values are positive.", "solution": "def op_inc_add10_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_add10_allpos([1, 2, 3, 4]) == True\nassert op_inc_add10_allpos([]) == True\nassert op_inc_add10_allpos([-2, -1, 0, 1, 2]) == True\nassert op_inc_add10_allpos([5, 5, 5]) == True\nassert op_inc_add10_allpos([3, 1, 2]) == True\nassert op_inc_add10_allpos([10]) == True\nassert op_inc_add10_allpos([2, 4, 6]) == True\nassert op_inc_add10_allpos([-7, 12, -7]) == True"}
{"id": "op_trimends_add10_issorted", "entry_point": "op_trimends_add10_issorted", "primitives": ["trimends", "add10", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add ten to each, then return whether the list is sorted ascending.", "solution": "def op_trimends_add10_issorted(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r == sorted(r)", "tests": "assert op_trimends_add10_issorted([1, 2, 3, 4]) == True\nassert op_trimends_add10_issorted([]) == True\nassert op_trimends_add10_issorted([-2, -1, 0, 1, 2]) == True\nassert op_trimends_add10_issorted([5, 5, 5]) == True\nassert op_trimends_add10_issorted([3, 1, 2]) == True\nassert op_trimends_add10_issorted([10]) == True\nassert op_trimends_add10_issorted([2, 4, 6]) == True\nassert op_trimends_add10_issorted([-7, 12, -7]) == True"}
{"id": "op_negate_sorta_allpos", "entry_point": "op_negate_sorta_allpos", "primitives": ["negate", "sorta", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then sort ascending, then return whether all values are positive.", "solution": "def op_negate_sorta_allpos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = sorted(r)\n    return all(x > 0 for x in r)", "tests": "assert op_negate_sorta_allpos([1, 2, 3, 4]) == False\nassert op_negate_sorta_allpos([]) == True\nassert op_negate_sorta_allpos([-2, -1, 0, 1, 2]) == False\nassert op_negate_sorta_allpos([5, 5, 5]) == False\nassert op_negate_sorta_allpos([3, 1, 2]) == False\nassert op_negate_sorta_allpos([10]) == False\nassert op_negate_sorta_allpos([2, 4, 6]) == False\nassert op_negate_sorta_allpos([-7, 12, -7]) == False"}
{"id": "op_square_sortabs_haszero", "entry_point": "op_square_sortabs_haszero", "primitives": ["square", "sortabs", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then return whether the list contains a zero.", "solution": "def op_square_sortabs_haszero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_square_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_square_sortabs_haszero([]) == False\nassert op_square_sortabs_haszero([-2, -1, 0, 1, 2]) == True\nassert op_square_sortabs_haszero([5, 5, 5]) == False\nassert op_square_sortabs_haszero([3, 1, 2]) == False\nassert op_square_sortabs_haszero([10]) == False\nassert op_square_sortabs_haszero([2, 4, 6]) == False\nassert op_square_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_evens_clamp10", "entry_point": "op_odds_evens_clamp10", "primitives": ["odds", "evens", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then cap each value at 10.", "solution": "def op_odds_evens_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_odds_evens_clamp10([1, 2, 3, 4]) == []\nassert op_odds_evens_clamp10([]) == []\nassert op_odds_evens_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_odds_evens_clamp10([5, 5, 5]) == []\nassert op_odds_evens_clamp10([3, 1, 2]) == []\nassert op_odds_evens_clamp10([10]) == []\nassert op_odds_evens_clamp10([2, 4, 6]) == []\nassert op_odds_evens_clamp10([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_evens_allpos", "entry_point": "op_oremptyzero_evens_allpos", "primitives": ["oremptyzero", "evens", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then return whether all values are positive.", "solution": "def op_oremptyzero_evens_allpos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_oremptyzero_evens_allpos([1, 2, 3, 4]) == True\nassert op_oremptyzero_evens_allpos([]) == False\nassert op_oremptyzero_evens_allpos([-2, -1, 0, 1, 2]) == False\nassert op_oremptyzero_evens_allpos([5, 5, 5]) == True\nassert op_oremptyzero_evens_allpos([3, 1, 2]) == True\nassert op_oremptyzero_evens_allpos([10]) == True\nassert op_oremptyzero_evens_allpos([2, 4, 6]) == True\nassert op_oremptyzero_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_sortd_trimends_evens", "entry_point": "op_sortd_trimends_evens", "primitives": ["sortd", "trimends", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then keep the even numbers.", "solution": "def op_sortd_trimends_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_trimends_evens([1, 2, 3, 4]) == [2]\nassert op_sortd_trimends_evens([]) == []\nassert op_sortd_trimends_evens([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_trimends_evens([5, 5, 5]) == []\nassert op_sortd_trimends_evens([3, 1, 2]) == [2]\nassert op_sortd_trimends_evens([10]) == []\nassert op_sortd_trimends_evens([2, 4, 6]) == [4]\nassert op_sortd_trimends_evens([-7, 12, -7]) == []"}
{"id": "op_sortlen_uniqs_maxlen", "entry_point": "op_sortlen_uniqs_maxlen", "primitives": ["sortlen", "uniqs", "maxlen"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then drop duplicate strings keeping the first, then return the length of the longest string (0 if none).", "solution": "def op_sortlen_uniqs_maxlen(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = list(dict.fromkeys(r))\n    return max((len(s) for s in r), default=0)", "tests": "assert op_sortlen_uniqs_maxlen(['Hello', 'world']) == 5\nassert op_sortlen_uniqs_maxlen([]) == 0\nassert op_sortlen_uniqs_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_sortlen_uniqs_maxlen(['one', 'one', 'Two']) == 3\nassert op_sortlen_uniqs_maxlen(['x']) == 1\nassert op_sortlen_uniqs_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_uniq_absval_trimends", "entry_point": "op_uniq_absval_trimends", "primitives": ["uniq", "absval", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then drop the first and last elements.", "solution": "def op_uniq_absval_trimends(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_uniq_absval_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_absval_trimends([]) == []\nassert op_uniq_absval_trimends([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_uniq_absval_trimends([5, 5, 5]) == []\nassert op_uniq_absval_trimends([3, 1, 2]) == [1]\nassert op_uniq_absval_trimends([10]) == []\nassert op_uniq_absval_trimends([2, 4, 6]) == [4]\nassert op_uniq_absval_trimends([-7, 12, -7]) == []"}
{"id": "op_uniq_padto3_len", "entry_point": "op_uniq_padto3_len", "primitives": ["uniq", "padto3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_uniq_padto3_len(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_uniq_padto3_len([1, 2, 3, 4]) == 4\nassert op_uniq_padto3_len([]) == 3\nassert op_uniq_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_uniq_padto3_len([5, 5, 5]) == 3\nassert op_uniq_padto3_len([3, 1, 2]) == 3\nassert op_uniq_padto3_len([10]) == 3\nassert op_uniq_padto3_len([2, 4, 6]) == 3\nassert op_uniq_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_dec_takewhilepos_double", "entry_point": "op_dec_takewhilepos_double", "primitives": ["dec", "takewhilepos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take values while they are positive, then double each.", "solution": "def op_dec_takewhilepos_double(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dec_takewhilepos_double([1, 2, 3, 4]) == []\nassert op_dec_takewhilepos_double([]) == []\nassert op_dec_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_dec_takewhilepos_double([5, 5, 5]) == [8, 8, 8]\nassert op_dec_takewhilepos_double([3, 1, 2]) == [4]\nassert op_dec_takewhilepos_double([10]) == [18]\nassert op_dec_takewhilepos_double([2, 4, 6]) == [2, 6, 10]\nassert op_dec_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_trimends_negate_clamp10", "entry_point": "op_trimends_negate_clamp10", "primitives": ["trimends", "negate", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then cap each value at 10.", "solution": "def op_trimends_negate_clamp10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_trimends_negate_clamp10([1, 2, 3, 4]) == [-2, -3]\nassert op_trimends_negate_clamp10([]) == []\nassert op_trimends_negate_clamp10([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_negate_clamp10([5, 5, 5]) == [-5]\nassert op_trimends_negate_clamp10([3, 1, 2]) == [-1]\nassert op_trimends_negate_clamp10([10]) == []\nassert op_trimends_negate_clamp10([2, 4, 6]) == [-4]\nassert op_trimends_negate_clamp10([-7, 12, -7]) == [-12]"}
{"id": "op_sorta_uniq_negate", "entry_point": "op_sorta_uniq_negate", "primitives": ["sorta", "uniq", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop duplicates keeping first occurrence, then negate each.", "solution": "def op_sorta_uniq_negate(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    return r", "tests": "assert op_sorta_uniq_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_uniq_negate([]) == []\nassert op_sorta_uniq_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_uniq_negate([5, 5, 5]) == [-5]\nassert op_sorta_uniq_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_uniq_negate([10]) == [-10]\nassert op_sorta_uniq_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_uniq_negate([-7, 12, -7]) == [7, -12]"}
{"id": "op_inc_double_absval", "entry_point": "op_inc_double_absval", "primitives": ["inc", "double", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then take the absolute value of each.", "solution": "def op_inc_double_absval(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_inc_double_absval([1, 2, 3, 4]) == [4, 6, 8, 10]\nassert op_inc_double_absval([]) == []\nassert op_inc_double_absval([-2, -1, 0, 1, 2]) == [2, 0, 2, 4, 6]\nassert op_inc_double_absval([5, 5, 5]) == [12, 12, 12]\nassert op_inc_double_absval([3, 1, 2]) == [8, 4, 6]\nassert op_inc_double_absval([10]) == [22]\nassert op_inc_double_absval([2, 4, 6]) == [6, 10, 14]\nassert op_inc_double_absval([-7, 12, -7]) == [12, 26, 12]"}
{"id": "op_evens_absval_max", "entry_point": "op_evens_absval_max", "primitives": ["evens", "absval", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take the absolute value of each, then return the maximum (0 if empty).", "solution": "def op_evens_absval_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [abs(x) for x in r]\n    return max(r) if r else 0", "tests": "assert op_evens_absval_max([1, 2, 3, 4]) == 4\nassert op_evens_absval_max([]) == 0\nassert op_evens_absval_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_absval_max([5, 5, 5]) == 0\nassert op_evens_absval_max([3, 1, 2]) == 2\nassert op_evens_absval_max([10]) == 10\nassert op_evens_absval_max([2, 4, 6]) == 6\nassert op_evens_absval_max([-7, 12, -7]) == 12"}
{"id": "op_div3_uniq_absval", "entry_point": "op_div3_uniq_absval", "primitives": ["div3", "uniq", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_div3_uniq_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_uniq_absval([1, 2, 3, 4]) == [3]\nassert op_div3_uniq_absval([]) == []\nassert op_div3_uniq_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_uniq_absval([5, 5, 5]) == []\nassert op_div3_uniq_absval([3, 1, 2]) == [3]\nassert op_div3_uniq_absval([10]) == []\nassert op_div3_uniq_absval([2, 4, 6]) == [6]\nassert op_div3_uniq_absval([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_clamp10_div3", "entry_point": "op_dropzeros_clamp10_div3", "primitives": ["dropzeros", "clamp10", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cap each value at 10, then keep multiples of three.", "solution": "def op_dropzeros_clamp10_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropzeros_clamp10_div3([1, 2, 3, 4]) == [3]\nassert op_dropzeros_clamp10_div3([]) == []\nassert op_dropzeros_clamp10_div3([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_clamp10_div3([5, 5, 5]) == []\nassert op_dropzeros_clamp10_div3([3, 1, 2]) == [3]\nassert op_dropzeros_clamp10_div3([10]) == []\nassert op_dropzeros_clamp10_div3([2, 4, 6]) == [6]\nassert op_dropzeros_clamp10_div3([-7, 12, -7]) == []"}
{"id": "op_trimends_sorta_square", "entry_point": "op_trimends_sorta_square", "primitives": ["trimends", "sorta", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then sort ascending, then square each.", "solution": "def op_trimends_sorta_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = sorted(r)\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_sorta_square([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_sorta_square([]) == []\nassert op_trimends_sorta_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_sorta_square([5, 5, 5]) == [25]\nassert op_trimends_sorta_square([3, 1, 2]) == [1]\nassert op_trimends_sorta_square([10]) == []\nassert op_trimends_sorta_square([2, 4, 6]) == [16]\nassert op_trimends_sorta_square([-7, 12, -7]) == [144]"}
{"id": "op_dec_padto3_odds", "entry_point": "op_dec_padto3_odds", "primitives": ["dec", "padto3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_dec_padto3_odds(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dec_padto3_odds([1, 2, 3, 4]) == [1, 3]\nassert op_dec_padto3_odds([]) == []\nassert op_dec_padto3_odds([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_dec_padto3_odds([5, 5, 5]) == []\nassert op_dec_padto3_odds([3, 1, 2]) == [1]\nassert op_dec_padto3_odds([10]) == [9]\nassert op_dec_padto3_odds([2, 4, 6]) == [1, 3, 5]\nassert op_dec_padto3_odds([-7, 12, -7]) == [11]"}
{"id": "op_clamp10_absval_len", "entry_point": "op_clamp10_absval_len", "primitives": ["clamp10", "absval", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then take the absolute value of each, then return how many remain.", "solution": "def op_clamp10_absval_len(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [abs(x) for x in r]\n    return len(r)", "tests": "assert op_clamp10_absval_len([1, 2, 3, 4]) == 4\nassert op_clamp10_absval_len([]) == 0\nassert op_clamp10_absval_len([-2, -1, 0, 1, 2]) == 5\nassert op_clamp10_absval_len([5, 5, 5]) == 3\nassert op_clamp10_absval_len([3, 1, 2]) == 3\nassert op_clamp10_absval_len([10]) == 1\nassert op_clamp10_absval_len([2, 4, 6]) == 3\nassert op_clamp10_absval_len([-7, 12, -7]) == 3"}
{"id": "op_evens_takewhilepos_oremptyzero", "entry_point": "op_evens_takewhilepos_oremptyzero", "primitives": ["evens", "takewhilepos", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then if empty, use a single zero.", "solution": "def op_evens_takewhilepos_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    return r", "tests": "assert op_evens_takewhilepos_oremptyzero([1, 2, 3, 4]) == [2, 4]\nassert op_evens_takewhilepos_oremptyzero([]) == [0]\nassert op_evens_takewhilepos_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_takewhilepos_oremptyzero([5, 5, 5]) == [0]\nassert op_evens_takewhilepos_oremptyzero([3, 1, 2]) == [2]\nassert op_evens_takewhilepos_oremptyzero([10]) == [10]\nassert op_evens_takewhilepos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_evens_takewhilepos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_uniq_trimends_takewhilepos", "entry_point": "op_uniq_trimends_takewhilepos", "primitives": ["uniq", "trimends", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then take values while they are positive.", "solution": "def op_uniq_trimends_takewhilepos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_uniq_trimends_takewhilepos([1, 2, 3, 4]) == [2, 3]\nassert op_uniq_trimends_takewhilepos([]) == []\nassert op_uniq_trimends_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_uniq_trimends_takewhilepos([5, 5, 5]) == []\nassert op_uniq_trimends_takewhilepos([3, 1, 2]) == [1]\nassert op_uniq_trimends_takewhilepos([10]) == []\nassert op_uniq_trimends_takewhilepos([2, 4, 6]) == [4]\nassert op_uniq_trimends_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_evens_takewhilepos_double", "entry_point": "op_evens_takewhilepos_double", "primitives": ["evens", "takewhilepos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then take values while they are positive, then double each.", "solution": "def op_evens_takewhilepos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_evens_takewhilepos_double([1, 2, 3, 4]) == [4, 8]\nassert op_evens_takewhilepos_double([]) == []\nassert op_evens_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_evens_takewhilepos_double([5, 5, 5]) == []\nassert op_evens_takewhilepos_double([3, 1, 2]) == [4]\nassert op_evens_takewhilepos_double([10]) == [20]\nassert op_evens_takewhilepos_double([2, 4, 6]) == [4, 8, 12]\nassert op_evens_takewhilepos_double([-7, 12, -7]) == [24]"}
{"id": "op_div3_padto3_odds", "entry_point": "op_div3_padto3_odds", "primitives": ["div3", "padto3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_div3_padto3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_padto3_odds([1, 2, 3, 4]) == [3]\nassert op_div3_padto3_odds([]) == []\nassert op_div3_padto3_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_padto3_odds([5, 5, 5]) == []\nassert op_div3_padto3_odds([3, 1, 2]) == [3]\nassert op_div3_padto3_odds([10]) == []\nassert op_div3_padto3_odds([2, 4, 6]) == []\nassert op_div3_padto3_odds([-7, 12, -7]) == []"}
{"id": "op_ages_clamp10_sum", "entry_point": "op_ages_clamp10_sum", "primitives": ["ages", "clamp10", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then return their sum.", "solution": "def op_ages_clamp10_sum(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_ages_clamp10_sum([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 20\nassert op_ages_clamp10_sum([]) == 0\nassert op_ages_clamp10_sum([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 30\nassert op_ages_clamp10_sum([{'name': 'Fi', 'age': 41}]) == 10"}
{"id": "op_dropfirst_dec_takewhilepos", "entry_point": "op_dropfirst_dec_takewhilepos", "primitives": ["dropfirst", "dec", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then take values while they are positive.", "solution": "def op_dropfirst_dec_takewhilepos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropfirst_dec_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropfirst_dec_takewhilepos([]) == []\nassert op_dropfirst_dec_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_dec_takewhilepos([5, 5, 5]) == [4, 4]\nassert op_dropfirst_dec_takewhilepos([3, 1, 2]) == []\nassert op_dropfirst_dec_takewhilepos([10]) == []\nassert op_dropfirst_dec_takewhilepos([2, 4, 6]) == [3, 5]\nassert op_dropfirst_dec_takewhilepos([-7, 12, -7]) == [11]"}
{"id": "op_dropfirst_padto3_rev", "entry_point": "op_dropfirst_padto3_rev", "primitives": ["dropfirst", "padto3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then reverse the order.", "solution": "def op_dropfirst_padto3_rev(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_dropfirst_padto3_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_dropfirst_padto3_rev([]) == [0, 0, 0]\nassert op_dropfirst_padto3_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_dropfirst_padto3_rev([5, 5, 5]) == [0, 5, 5]\nassert op_dropfirst_padto3_rev([3, 1, 2]) == [0, 2, 1]\nassert op_dropfirst_padto3_rev([10]) == [0, 0, 0]\nassert op_dropfirst_padto3_rev([2, 4, 6]) == [0, 6, 4]\nassert op_dropfirst_padto3_rev([-7, 12, -7]) == [0, -7, 12]"}
{"id": "op_clamp10_neg_oremptyzero", "entry_point": "op_clamp10_neg_oremptyzero", "primitives": ["clamp10", "neg", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_clamp10_neg_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_clamp10_neg_oremptyzero([]) == [0]\nassert op_clamp10_neg_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_clamp10_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_clamp10_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_clamp10_neg_oremptyzero([10]) == [0]\nassert op_clamp10_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_clamp10_neg_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_negate_odds", "entry_point": "op_beforezero_negate_odds", "primitives": ["beforezero", "negate", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then keep the odd numbers.", "solution": "def op_beforezero_negate_odds(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_beforezero_negate_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_beforezero_negate_odds([]) == []\nassert op_beforezero_negate_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_beforezero_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_beforezero_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_beforezero_negate_odds([10]) == []\nassert op_beforezero_negate_odds([2, 4, 6]) == []\nassert op_beforezero_negate_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_double_div3", "entry_point": "op_ages_double_div3", "primitives": ["ages", "double", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then double each, then keep multiples of three.", "solution": "def op_ages_double_div3(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_ages_double_div3([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [72, 24]\nassert op_ages_double_div3([]) == []\nassert op_ages_double_div3([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [36]\nassert op_ages_double_div3([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_first3_rev_sortd", "entry_point": "op_first3_rev_sortd", "primitives": ["first3", "rev", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then sort descending.", "solution": "def op_first3_rev_sortd(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_first3_rev_sortd([1, 2, 3, 4]) == [3, 2, 1]\nassert op_first3_rev_sortd([]) == []\nassert op_first3_rev_sortd([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_first3_rev_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_first3_rev_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_first3_rev_sortd([10]) == [10]\nassert op_first3_rev_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_first3_rev_sortd([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_takewhilepos_pos_rev", "entry_point": "op_takewhilepos_pos_rev", "primitives": ["takewhilepos", "pos", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then reverse the order.", "solution": "def op_takewhilepos_pos_rev(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_takewhilepos_pos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_pos_rev([]) == []\nassert op_takewhilepos_pos_rev([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_pos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_pos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_takewhilepos_pos_rev([10]) == [10]\nassert op_takewhilepos_pos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_pos_rev([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_sortabs_firsteven", "entry_point": "op_oremptyzero_sortabs_firsteven", "primitives": ["oremptyzero", "sortabs", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_oremptyzero_sortabs_firsteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_oremptyzero_sortabs_firsteven([1, 2, 3, 4]) == 2\nassert op_oremptyzero_sortabs_firsteven([]) == 0\nassert op_oremptyzero_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_sortabs_firsteven([5, 5, 5]) == 0\nassert op_oremptyzero_sortabs_firsteven([3, 1, 2]) == 2\nassert op_oremptyzero_sortabs_firsteven([10]) == 10\nassert op_oremptyzero_sortabs_firsteven([2, 4, 6]) == 2\nassert op_oremptyzero_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_div3_clamp10", "entry_point": "op_dropzeros_div3_clamp10", "primitives": ["dropzeros", "div3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep multiples of three, then cap each value at 10.", "solution": "def op_dropzeros_div3_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_dropzeros_div3_clamp10([]) == []\nassert op_dropzeros_div3_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_div3_clamp10([5, 5, 5]) == []\nassert op_dropzeros_div3_clamp10([3, 1, 2]) == [3]\nassert op_dropzeros_div3_clamp10([10]) == []\nassert op_dropzeros_div3_clamp10([2, 4, 6]) == [6]\nassert op_dropzeros_div3_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_padto3_last3_sortabs", "entry_point": "op_padto3_last3_sortabs", "primitives": ["padto3", "last3", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then sort by absolute value.", "solution": "def op_padto3_last3_sortabs(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_padto3_last3_sortabs([1, 2, 3, 4]) == [2, 3, 4]\nassert op_padto3_last3_sortabs([]) == [0, 0, 0]\nassert op_padto3_last3_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_padto3_last3_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_last3_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_last3_sortabs([10]) == [0, 0, 10]\nassert op_padto3_last3_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_last3_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_beforezero_sorta_dec", "entry_point": "op_beforezero_sorta_dec", "primitives": ["beforezero", "sorta", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then subtract one from each.", "solution": "def op_beforezero_sorta_dec(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_beforezero_sorta_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_beforezero_sorta_dec([]) == []\nassert op_beforezero_sorta_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_beforezero_sorta_dec([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_sorta_dec([3, 1, 2]) == [0, 1, 2]\nassert op_beforezero_sorta_dec([10]) == [9]\nassert op_beforezero_sorta_dec([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_sorta_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_inc_padto3_sortabs", "entry_point": "op_inc_padto3_sortabs", "primitives": ["inc", "padto3", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then pad with zeros to at least three elements, then sort by absolute value.", "solution": "def op_inc_padto3_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_padto3_sortabs([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_padto3_sortabs([]) == [0, 0, 0]\nassert op_inc_padto3_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, 2, 3]\nassert op_inc_padto3_sortabs([5, 5, 5]) == [6, 6, 6]\nassert op_inc_padto3_sortabs([3, 1, 2]) == [2, 3, 4]\nassert op_inc_padto3_sortabs([10]) == [0, 0, 11]\nassert op_inc_padto3_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_inc_padto3_sortabs([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_takewhilepos_square_negate", "entry_point": "op_takewhilepos_square_negate", "primitives": ["takewhilepos", "square", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then negate each.", "solution": "def op_takewhilepos_square_negate(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_takewhilepos_square_negate([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_takewhilepos_square_negate([]) == []\nassert op_takewhilepos_square_negate([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_square_negate([5, 5, 5]) == [-25, -25, -25]\nassert op_takewhilepos_square_negate([3, 1, 2]) == [-9, -1, -4]\nassert op_takewhilepos_square_negate([10]) == [-100]\nassert op_takewhilepos_square_negate([2, 4, 6]) == [-4, -16, -36]\nassert op_takewhilepos_square_negate([-7, 12, -7]) == []"}
{"id": "op_sortabs_dropzeros_allpos", "entry_point": "op_sortabs_dropzeros_allpos", "primitives": ["sortabs", "dropzeros", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the zeros, then return whether all values are positive.", "solution": "def op_sortabs_dropzeros_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_dropzeros_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_dropzeros_allpos([]) == True\nassert op_sortabs_dropzeros_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_dropzeros_allpos([5, 5, 5]) == True\nassert op_sortabs_dropzeros_allpos([3, 1, 2]) == True\nassert op_sortabs_dropzeros_allpos([10]) == True\nassert op_sortabs_dropzeros_allpos([2, 4, 6]) == True\nassert op_sortabs_dropzeros_allpos([-7, 12, -7]) == False"}
{"id": "op_double_rev_dropwhileneg", "entry_point": "op_double_rev_dropwhileneg", "primitives": ["double", "rev", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then reverse the order, then drop the leading negative values.", "solution": "def op_double_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_rev_dropwhileneg([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_rev_dropwhileneg([]) == []\nassert op_double_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_rev_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_double_rev_dropwhileneg([3, 1, 2]) == [4, 2, 6]\nassert op_double_rev_dropwhileneg([10]) == [20]\nassert op_double_rev_dropwhileneg([2, 4, 6]) == [12, 8, 4]\nassert op_double_rev_dropwhileneg([-7, 12, -7]) == [24, -14]"}
{"id": "op_pos_dec_absval", "entry_point": "op_pos_dec_absval", "primitives": ["pos", "dec", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then take the absolute value of each.", "solution": "def op_pos_dec_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_dec_absval([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_pos_dec_absval([]) == []\nassert op_pos_dec_absval([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_dec_absval([5, 5, 5]) == [4, 4, 4]\nassert op_pos_dec_absval([3, 1, 2]) == [2, 0, 1]\nassert op_pos_dec_absval([10]) == [9]\nassert op_pos_dec_absval([2, 4, 6]) == [1, 3, 5]\nassert op_pos_dec_absval([-7, 12, -7]) == [11]"}
{"id": "op_sortabs_beforezero_issorted", "entry_point": "op_sortabs_beforezero_issorted", "primitives": ["sortabs", "beforezero", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep everything before the first zero, then return whether the list is sorted ascending.", "solution": "def op_sortabs_beforezero_issorted(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:r.index(0)] if 0 in r else r\n    return r == sorted(r)", "tests": "assert op_sortabs_beforezero_issorted([1, 2, 3, 4]) == True\nassert op_sortabs_beforezero_issorted([]) == True\nassert op_sortabs_beforezero_issorted([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_beforezero_issorted([5, 5, 5]) == True\nassert op_sortabs_beforezero_issorted([3, 1, 2]) == True\nassert op_sortabs_beforezero_issorted([10]) == True\nassert op_sortabs_beforezero_issorted([2, 4, 6]) == True\nassert op_sortabs_beforezero_issorted([-7, 12, -7]) == True"}
{"id": "op_add10_double_absval", "entry_point": "op_add10_double_absval", "primitives": ["add10", "double", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then double each, then take the absolute value of each.", "solution": "def op_add10_double_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_double_absval([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_add10_double_absval([]) == []\nassert op_add10_double_absval([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_add10_double_absval([5, 5, 5]) == [30, 30, 30]\nassert op_add10_double_absval([3, 1, 2]) == [26, 22, 24]\nassert op_add10_double_absval([10]) == [40]\nassert op_add10_double_absval([2, 4, 6]) == [24, 28, 32]\nassert op_add10_double_absval([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_rev_oremptyzero_pos", "entry_point": "op_rev_oremptyzero_pos", "primitives": ["rev", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_rev_oremptyzero_pos(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_rev_oremptyzero_pos([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_pos([]) == []\nassert op_rev_oremptyzero_pos([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_pos([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_pos([10]) == [10]\nassert op_rev_oremptyzero_pos([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_neg_div3_beforezero", "entry_point": "op_neg_div3_beforezero", "primitives": ["neg", "div3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep multiples of three, then keep everything before the first zero.", "solution": "def op_neg_div3_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_neg_div3_beforezero([1, 2, 3, 4]) == []\nassert op_neg_div3_beforezero([]) == []\nassert op_neg_div3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_neg_div3_beforezero([5, 5, 5]) == []\nassert op_neg_div3_beforezero([3, 1, 2]) == []\nassert op_neg_div3_beforezero([10]) == []\nassert op_neg_div3_beforezero([2, 4, 6]) == []\nassert op_neg_div3_beforezero([-7, 12, -7]) == []"}
{"id": "op_evens_odds_sorta", "entry_point": "op_evens_odds_sorta", "primitives": ["evens", "odds", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the odd numbers, then sort ascending.", "solution": "def op_evens_odds_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r)\n    return r", "tests": "assert op_evens_odds_sorta([1, 2, 3, 4]) == []\nassert op_evens_odds_sorta([]) == []\nassert op_evens_odds_sorta([-2, -1, 0, 1, 2]) == []\nassert op_evens_odds_sorta([5, 5, 5]) == []\nassert op_evens_odds_sorta([3, 1, 2]) == []\nassert op_evens_odds_sorta([10]) == []\nassert op_evens_odds_sorta([2, 4, 6]) == []\nassert op_evens_odds_sorta([-7, 12, -7]) == []"}
{"id": "op_ages_odds_uniq", "entry_point": "op_ages_odds_uniq", "primitives": ["ages", "odds", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the odd numbers, then drop duplicates keeping first occurrence.", "solution": "def op_ages_odds_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_odds_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_odds_uniq([]) == []\nassert op_ages_odds_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 17]\nassert op_ages_odds_uniq([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_dropzeros_rev_min", "entry_point": "op_dropzeros_rev_min", "primitives": ["dropzeros", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_dropzeros_rev_min(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_dropzeros_rev_min([1, 2, 3, 4]) == 1\nassert op_dropzeros_rev_min([]) == 0\nassert op_dropzeros_rev_min([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_rev_min([5, 5, 5]) == 5\nassert op_dropzeros_rev_min([3, 1, 2]) == 1\nassert op_dropzeros_rev_min([10]) == 10\nassert op_dropzeros_rev_min([2, 4, 6]) == 2\nassert op_dropzeros_rev_min([-7, 12, -7]) == -7"}
{"id": "op_padto3_double_min", "entry_point": "op_padto3_double_min", "primitives": ["padto3", "double", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then return the minimum (0 if empty).", "solution": "def op_padto3_double_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_padto3_double_min([1, 2, 3, 4]) == 2\nassert op_padto3_double_min([]) == 0\nassert op_padto3_double_min([-2, -1, 0, 1, 2]) == -4\nassert op_padto3_double_min([5, 5, 5]) == 10\nassert op_padto3_double_min([3, 1, 2]) == 2\nassert op_padto3_double_min([10]) == 0\nassert op_padto3_double_min([2, 4, 6]) == 4\nassert op_padto3_double_min([-7, 12, -7]) == -14"}
{"id": "op_negate_inc_oremptyzero", "entry_point": "op_negate_inc_oremptyzero", "primitives": ["negate", "inc", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then if empty, use a single zero.", "solution": "def op_negate_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_inc_oremptyzero([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_negate_inc_oremptyzero([]) == [0]\nassert op_negate_inc_oremptyzero([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_negate_inc_oremptyzero([5, 5, 5]) == [-4, -4, -4]\nassert op_negate_inc_oremptyzero([3, 1, 2]) == [-2, 0, -1]\nassert op_negate_inc_oremptyzero([10]) == [-9]\nassert op_negate_inc_oremptyzero([2, 4, 6]) == [-1, -3, -5]\nassert op_negate_inc_oremptyzero([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_trimends_oremptyzero_allpos", "entry_point": "op_trimends_oremptyzero_allpos", "primitives": ["trimends", "oremptyzero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_trimends_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_trimends_oremptyzero_allpos([]) == False\nassert op_trimends_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_oremptyzero_allpos([5, 5, 5]) == True\nassert op_trimends_oremptyzero_allpos([3, 1, 2]) == True\nassert op_trimends_oremptyzero_allpos([10]) == False\nassert op_trimends_oremptyzero_allpos([2, 4, 6]) == True\nassert op_trimends_oremptyzero_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_uniq_sum", "entry_point": "op_dec_uniq_sum", "primitives": ["dec", "uniq", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop duplicates keeping first occurrence, then return their sum.", "solution": "def op_dec_uniq_sum(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return sum(r)", "tests": "assert op_dec_uniq_sum([1, 2, 3, 4]) == 6\nassert op_dec_uniq_sum([]) == 0\nassert op_dec_uniq_sum([-2, -1, 0, 1, 2]) == -5\nassert op_dec_uniq_sum([5, 5, 5]) == 4\nassert op_dec_uniq_sum([3, 1, 2]) == 3\nassert op_dec_uniq_sum([10]) == 9\nassert op_dec_uniq_sum([2, 4, 6]) == 9\nassert op_dec_uniq_sum([-7, 12, -7]) == 3"}
{"id": "op_dec_negate_gt5", "entry_point": "op_dec_negate_gt5", "primitives": ["dec", "negate", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then keep values greater than five.", "solution": "def op_dec_negate_gt5(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dec_negate_gt5([1, 2, 3, 4]) == []\nassert op_dec_negate_gt5([]) == []\nassert op_dec_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dec_negate_gt5([5, 5, 5]) == []\nassert op_dec_negate_gt5([3, 1, 2]) == []\nassert op_dec_negate_gt5([10]) == []\nassert op_dec_negate_gt5([2, 4, 6]) == []\nassert op_dec_negate_gt5([-7, 12, -7]) == [8, 8]"}
{"id": "op_inc_double_add10", "entry_point": "op_inc_double_add10", "primitives": ["inc", "double", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then add ten to each.", "solution": "def op_inc_double_add10(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_inc_double_add10([1, 2, 3, 4]) == [14, 16, 18, 20]\nassert op_inc_double_add10([]) == []\nassert op_inc_double_add10([-2, -1, 0, 1, 2]) == [8, 10, 12, 14, 16]\nassert op_inc_double_add10([5, 5, 5]) == [22, 22, 22]\nassert op_inc_double_add10([3, 1, 2]) == [18, 14, 16]\nassert op_inc_double_add10([10]) == [32]\nassert op_inc_double_add10([2, 4, 6]) == [16, 20, 24]\nassert op_inc_double_add10([-7, 12, -7]) == [-2, 36, -2]"}
{"id": "op_rev_oremptyzero_dec", "entry_point": "op_rev_oremptyzero_dec", "primitives": ["rev", "oremptyzero", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then subtract one from each.", "solution": "def op_rev_oremptyzero_dec(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_rev_oremptyzero_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_rev_oremptyzero_dec([]) == [-1]\nassert op_rev_oremptyzero_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_rev_oremptyzero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_rev_oremptyzero_dec([3, 1, 2]) == [1, 0, 2]\nassert op_rev_oremptyzero_dec([10]) == [9]\nassert op_rev_oremptyzero_dec([2, 4, 6]) == [5, 3, 1]\nassert op_rev_oremptyzero_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropzeros_odds_len", "entry_point": "op_dropzeros_odds_len", "primitives": ["dropzeros", "odds", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then return how many remain.", "solution": "def op_dropzeros_odds_len(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_dropzeros_odds_len([1, 2, 3, 4]) == 2\nassert op_dropzeros_odds_len([]) == 0\nassert op_dropzeros_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_odds_len([5, 5, 5]) == 3\nassert op_dropzeros_odds_len([3, 1, 2]) == 2\nassert op_dropzeros_odds_len([10]) == 0\nassert op_dropzeros_odds_len([2, 4, 6]) == 0\nassert op_dropzeros_odds_len([-7, 12, -7]) == 2"}
{"id": "op_sortabs_last3_allpos", "entry_point": "op_sortabs_last3_allpos", "primitives": ["sortabs", "last3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the last three, then return whether all values are positive.", "solution": "def op_sortabs_last3_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_last3_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_last3_allpos([]) == True\nassert op_sortabs_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_last3_allpos([5, 5, 5]) == True\nassert op_sortabs_last3_allpos([3, 1, 2]) == True\nassert op_sortabs_last3_allpos([10]) == True\nassert op_sortabs_last3_allpos([2, 4, 6]) == True\nassert op_sortabs_last3_allpos([-7, 12, -7]) == False"}
{"id": "op_sortd_dec_rev", "entry_point": "op_sortd_dec_rev", "primitives": ["sortd", "dec", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then subtract one from each, then reverse the order.", "solution": "def op_sortd_dec_rev(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x - 1 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortd_dec_rev([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sortd_dec_rev([]) == []\nassert op_sortd_dec_rev([-2, -1, 0, 1, 2]) == [-3, -2, -1, 0, 1]\nassert op_sortd_dec_rev([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_dec_rev([3, 1, 2]) == [0, 1, 2]\nassert op_sortd_dec_rev([10]) == [9]\nassert op_sortd_dec_rev([2, 4, 6]) == [1, 3, 5]\nassert op_sortd_dec_rev([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_lower_dropshort_anyempty", "entry_point": "op_lower_dropshort_anyempty", "primitives": ["lower", "dropshort", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop strings shorter than three characters, then return whether any string is empty.", "solution": "def op_lower_dropshort_anyempty(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return any(s == '' for s in r)", "tests": "assert op_lower_dropshort_anyempty(['Hello', 'world']) == False\nassert op_lower_dropshort_anyempty([]) == False\nassert op_lower_dropshort_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_lower_dropshort_anyempty(['one', 'one', 'Two']) == False\nassert op_lower_dropshort_anyempty(['x']) == False\nassert op_lower_dropshort_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dec_beforezero_takewhilepos", "entry_point": "op_dec_beforezero_takewhilepos", "primitives": ["dec", "beforezero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_dec_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dec_beforezero_takewhilepos([1, 2, 3, 4]) == []\nassert op_dec_beforezero_takewhilepos([]) == []\nassert op_dec_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dec_beforezero_takewhilepos([5, 5, 5]) == [4, 4, 4]\nassert op_dec_beforezero_takewhilepos([3, 1, 2]) == [2]\nassert op_dec_beforezero_takewhilepos([10]) == [9]\nassert op_dec_beforezero_takewhilepos([2, 4, 6]) == [1, 3, 5]\nassert op_dec_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dec_oremptyzero_min", "entry_point": "op_dec_oremptyzero_min", "primitives": ["dec", "oremptyzero", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_dec_oremptyzero_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_dec_oremptyzero_min([1, 2, 3, 4]) == 0\nassert op_dec_oremptyzero_min([]) == 0\nassert op_dec_oremptyzero_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_oremptyzero_min([5, 5, 5]) == 4\nassert op_dec_oremptyzero_min([3, 1, 2]) == 0\nassert op_dec_oremptyzero_min([10]) == 9\nassert op_dec_oremptyzero_min([2, 4, 6]) == 1\nassert op_dec_oremptyzero_min([-7, 12, -7]) == -8"}
{"id": "op_negate_odds_dropfirst", "entry_point": "op_negate_odds_dropfirst", "primitives": ["negate", "odds", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the odd numbers, then drop the first element.", "solution": "def op_negate_odds_dropfirst(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_negate_odds_dropfirst([1, 2, 3, 4]) == [-3]\nassert op_negate_odds_dropfirst([]) == []\nassert op_negate_odds_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_negate_odds_dropfirst([5, 5, 5]) == [-5, -5]\nassert op_negate_odds_dropfirst([3, 1, 2]) == [-1]\nassert op_negate_odds_dropfirst([10]) == []\nassert op_negate_odds_dropfirst([2, 4, 6]) == []\nassert op_negate_odds_dropfirst([-7, 12, -7]) == [7]"}
{"id": "op_clamp10_dec_dropwhileneg", "entry_point": "op_clamp10_dec_dropwhileneg", "primitives": ["clamp10", "dec", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then subtract one from each, then drop the leading negative values.", "solution": "def op_clamp10_dec_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_dec_dropwhileneg([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_clamp10_dec_dropwhileneg([]) == []\nassert op_clamp10_dec_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_clamp10_dec_dropwhileneg([5, 5, 5]) == [4, 4, 4]\nassert op_clamp10_dec_dropwhileneg([3, 1, 2]) == [2, 0, 1]\nassert op_clamp10_dec_dropwhileneg([10]) == [9]\nassert op_clamp10_dec_dropwhileneg([2, 4, 6]) == [1, 3, 5]\nassert op_clamp10_dec_dropwhileneg([-7, 12, -7]) == [9, -8]"}
{"id": "op_add10_dropfirst_square", "entry_point": "op_add10_dropfirst_square", "primitives": ["add10", "dropfirst", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then square each.", "solution": "def op_add10_dropfirst_square(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_add10_dropfirst_square([1, 2, 3, 4]) == [144, 169, 196]\nassert op_add10_dropfirst_square([]) == []\nassert op_add10_dropfirst_square([-2, -1, 0, 1, 2]) == [81, 100, 121, 144]\nassert op_add10_dropfirst_square([5, 5, 5]) == [225, 225]\nassert op_add10_dropfirst_square([3, 1, 2]) == [121, 144]\nassert op_add10_dropfirst_square([10]) == []\nassert op_add10_dropfirst_square([2, 4, 6]) == [196, 256]\nassert op_add10_dropfirst_square([-7, 12, -7]) == [484, 9]"}
{"id": "op_evens_padto3_last3", "entry_point": "op_evens_padto3_last3", "primitives": ["evens", "padto3", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then pad with zeros to at least three elements, then keep only the last three.", "solution": "def op_evens_padto3_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    return r", "tests": "assert op_evens_padto3_last3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_evens_padto3_last3([]) == [0, 0, 0]\nassert op_evens_padto3_last3([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_evens_padto3_last3([5, 5, 5]) == [0, 0, 0]\nassert op_evens_padto3_last3([3, 1, 2]) == [2, 0, 0]\nassert op_evens_padto3_last3([10]) == [10, 0, 0]\nassert op_evens_padto3_last3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_padto3_last3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_takewhilepos_padto3_div3", "entry_point": "op_takewhilepos_padto3_div3", "primitives": ["takewhilepos", "padto3", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then keep multiples of three.", "solution": "def op_takewhilepos_padto3_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_padto3_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_padto3_div3([]) == [0, 0, 0]\nassert op_takewhilepos_padto3_div3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_padto3_div3([5, 5, 5]) == []\nassert op_takewhilepos_padto3_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_padto3_div3([10]) == [0, 0]\nassert op_takewhilepos_padto3_div3([2, 4, 6]) == [6]\nassert op_takewhilepos_padto3_div3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_first3_dropfirst_beforezero", "entry_point": "op_first3_dropfirst_beforezero", "primitives": ["first3", "dropfirst", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first element, then keep everything before the first zero.", "solution": "def op_first3_dropfirst_beforezero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_first3_dropfirst_beforezero([1, 2, 3, 4]) == [2, 3]\nassert op_first3_dropfirst_beforezero([]) == []\nassert op_first3_dropfirst_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_first3_dropfirst_beforezero([5, 5, 5]) == [5, 5]\nassert op_first3_dropfirst_beforezero([3, 1, 2]) == [1, 2]\nassert op_first3_dropfirst_beforezero([10]) == []\nassert op_first3_dropfirst_beforezero([2, 4, 6]) == [4, 6]\nassert op_first3_dropfirst_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_div3_neg_prod", "entry_point": "op_div3_neg_prod", "primitives": ["div3", "neg", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the negative numbers, then return their product.", "solution": "def op_div3_neg_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_div3_neg_prod([1, 2, 3, 4]) == 1\nassert op_div3_neg_prod([]) == 1\nassert op_div3_neg_prod([-2, -1, 0, 1, 2]) == 1\nassert op_div3_neg_prod([5, 5, 5]) == 1\nassert op_div3_neg_prod([3, 1, 2]) == 1\nassert op_div3_neg_prod([10]) == 1\nassert op_div3_neg_prod([2, 4, 6]) == 1\nassert op_div3_neg_prod([-7, 12, -7]) == 1"}
{"id": "op_beforezero_neg_sortd", "entry_point": "op_beforezero_neg_sortd", "primitives": ["beforezero", "neg", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then sort descending.", "solution": "def op_beforezero_neg_sortd(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_beforezero_neg_sortd([1, 2, 3, 4]) == []\nassert op_beforezero_neg_sortd([]) == []\nassert op_beforezero_neg_sortd([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_neg_sortd([5, 5, 5]) == []\nassert op_beforezero_neg_sortd([3, 1, 2]) == []\nassert op_beforezero_neg_sortd([10]) == []\nassert op_beforezero_neg_sortd([2, 4, 6]) == []\nassert op_beforezero_neg_sortd([-7, 12, -7]) == [-7, -7]"}
{"id": "op_takewhilepos_square_firsteven", "entry_point": "op_takewhilepos_square_firsteven", "primitives": ["takewhilepos", "square", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then square each, then return the first even value (0 if none).", "solution": "def op_takewhilepos_square_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_square_firsteven([1, 2, 3, 4]) == 4\nassert op_takewhilepos_square_firsteven([]) == 0\nassert op_takewhilepos_square_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_square_firsteven([5, 5, 5]) == 0\nassert op_takewhilepos_square_firsteven([3, 1, 2]) == 4\nassert op_takewhilepos_square_firsteven([10]) == 100\nassert op_takewhilepos_square_firsteven([2, 4, 6]) == 4\nassert op_takewhilepos_square_firsteven([-7, 12, -7]) == 0"}
{"id": "op_div3_takewhilepos_add10", "entry_point": "op_div3_takewhilepos_add10", "primitives": ["div3", "takewhilepos", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then add ten to each.", "solution": "def op_div3_takewhilepos_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_div3_takewhilepos_add10([1, 2, 3, 4]) == [13]\nassert op_div3_takewhilepos_add10([]) == []\nassert op_div3_takewhilepos_add10([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_add10([5, 5, 5]) == []\nassert op_div3_takewhilepos_add10([3, 1, 2]) == [13]\nassert op_div3_takewhilepos_add10([10]) == []\nassert op_div3_takewhilepos_add10([2, 4, 6]) == [16]\nassert op_div3_takewhilepos_add10([-7, 12, -7]) == [22]"}
{"id": "op_odds_double_div3", "entry_point": "op_odds_double_div3", "primitives": ["odds", "double", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then double each, then keep multiples of three.", "solution": "def op_odds_double_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_odds_double_div3([1, 2, 3, 4]) == [6]\nassert op_odds_double_div3([]) == []\nassert op_odds_double_div3([-2, -1, 0, 1, 2]) == []\nassert op_odds_double_div3([5, 5, 5]) == []\nassert op_odds_double_div3([3, 1, 2]) == [6]\nassert op_odds_double_div3([10]) == []\nassert op_odds_double_div3([2, 4, 6]) == []\nassert op_odds_double_div3([-7, 12, -7]) == []"}
{"id": "op_uniq_clamp10_dropwhileneg", "entry_point": "op_uniq_clamp10_dropwhileneg", "primitives": ["uniq", "clamp10", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then drop the leading negative values.", "solution": "def op_uniq_clamp10_dropwhileneg(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_uniq_clamp10_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_clamp10_dropwhileneg([]) == []\nassert op_uniq_clamp10_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_clamp10_dropwhileneg([5, 5, 5]) == [5]\nassert op_uniq_clamp10_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_clamp10_dropwhileneg([10]) == [10]\nassert op_uniq_clamp10_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_clamp10_dropwhileneg([-7, 12, -7]) == [10]"}
{"id": "op_clamp10_inc_add10", "entry_point": "op_clamp10_inc_add10", "primitives": ["clamp10", "inc", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then add one to each, then add ten to each.", "solution": "def op_clamp10_inc_add10(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_clamp10_inc_add10([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_clamp10_inc_add10([]) == []\nassert op_clamp10_inc_add10([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_clamp10_inc_add10([5, 5, 5]) == [16, 16, 16]\nassert op_clamp10_inc_add10([3, 1, 2]) == [14, 12, 13]\nassert op_clamp10_inc_add10([10]) == [21]\nassert op_clamp10_inc_add10([2, 4, 6]) == [13, 15, 17]\nassert op_clamp10_inc_add10([-7, 12, -7]) == [4, 21, 4]"}
{"id": "op_last3_absval_add10", "entry_point": "op_last3_absval_add10", "primitives": ["last3", "absval", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then add ten to each.", "solution": "def op_last3_absval_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_absval_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_absval_add10([]) == []\nassert op_last3_absval_add10([-2, -1, 0, 1, 2]) == [10, 11, 12]\nassert op_last3_absval_add10([5, 5, 5]) == [15, 15, 15]\nassert op_last3_absval_add10([3, 1, 2]) == [13, 11, 12]\nassert op_last3_absval_add10([10]) == [20]\nassert op_last3_absval_add10([2, 4, 6]) == [12, 14, 16]\nassert op_last3_absval_add10([-7, 12, -7]) == [17, 22, 17]"}
{"id": "op_dropwhileneg_negate_sum", "entry_point": "op_dropwhileneg_negate_sum", "primitives": ["dropwhileneg", "negate", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then return their sum.", "solution": "def op_dropwhileneg_negate_sum(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_dropwhileneg_negate_sum([1, 2, 3, 4]) == -10\nassert op_dropwhileneg_negate_sum([]) == 0\nassert op_dropwhileneg_negate_sum([-2, -1, 0, 1, 2]) == -3\nassert op_dropwhileneg_negate_sum([5, 5, 5]) == -15\nassert op_dropwhileneg_negate_sum([3, 1, 2]) == -6\nassert op_dropwhileneg_negate_sum([10]) == -10\nassert op_dropwhileneg_negate_sum([2, 4, 6]) == -12\nassert op_dropwhileneg_negate_sum([-7, 12, -7]) == -5"}
{"id": "op_absval_beforezero_sortd", "entry_point": "op_absval_beforezero_sortd", "primitives": ["absval", "beforezero", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then sort descending.", "solution": "def op_absval_beforezero_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_beforezero_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_beforezero_sortd([]) == []\nassert op_absval_beforezero_sortd([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_absval_beforezero_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_absval_beforezero_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_absval_beforezero_sortd([10]) == [10]\nassert op_absval_beforezero_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_absval_beforezero_sortd([-7, 12, -7]) == [12, 7, 7]"}
{"id": "op_last3_sortabs_takewhilepos", "entry_point": "op_last3_sortabs_takewhilepos", "primitives": ["last3", "sortabs", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort by absolute value, then take values while they are positive.", "solution": "def op_last3_sortabs_takewhilepos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_last3_sortabs_takewhilepos([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sortabs_takewhilepos([]) == []\nassert op_last3_sortabs_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_last3_sortabs_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_last3_sortabs_takewhilepos([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sortabs_takewhilepos([10]) == [10]\nassert op_last3_sortabs_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sortabs_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_odds_evens_allpos", "entry_point": "op_odds_evens_allpos", "primitives": ["odds", "evens", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the even numbers, then return whether all values are positive.", "solution": "def op_odds_evens_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 2 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_odds_evens_allpos([1, 2, 3, 4]) == True\nassert op_odds_evens_allpos([]) == True\nassert op_odds_evens_allpos([-2, -1, 0, 1, 2]) == True\nassert op_odds_evens_allpos([5, 5, 5]) == True\nassert op_odds_evens_allpos([3, 1, 2]) == True\nassert op_odds_evens_allpos([10]) == True\nassert op_odds_evens_allpos([2, 4, 6]) == True\nassert op_odds_evens_allpos([-7, 12, -7]) == True"}
{"id": "op_dec_first3_counteven", "entry_point": "op_dec_first3_counteven", "primitives": ["dec", "first3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then return how many values are even.", "solution": "def op_dec_first3_counteven(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dec_first3_counteven([1, 2, 3, 4]) == 2\nassert op_dec_first3_counteven([]) == 0\nassert op_dec_first3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_dec_first3_counteven([5, 5, 5]) == 3\nassert op_dec_first3_counteven([3, 1, 2]) == 2\nassert op_dec_first3_counteven([10]) == 0\nassert op_dec_first3_counteven([2, 4, 6]) == 0\nassert op_dec_first3_counteven([-7, 12, -7]) == 2"}
{"id": "op_gt5_sorta_div3", "entry_point": "op_gt5_sorta_div3", "primitives": ["gt5", "sorta", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort ascending, then keep multiples of three.", "solution": "def op_gt5_sorta_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_gt5_sorta_div3([1, 2, 3, 4]) == []\nassert op_gt5_sorta_div3([]) == []\nassert op_gt5_sorta_div3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sorta_div3([5, 5, 5]) == []\nassert op_gt5_sorta_div3([3, 1, 2]) == []\nassert op_gt5_sorta_div3([10]) == []\nassert op_gt5_sorta_div3([2, 4, 6]) == [6]\nassert op_gt5_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_uniq_sortabs_oremptyzero", "entry_point": "op_uniq_sortabs_oremptyzero", "primitives": ["uniq", "sortabs", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_uniq_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_sortabs_oremptyzero([]) == [0]\nassert op_uniq_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_uniq_sortabs_oremptyzero([5, 5, 5]) == [5]\nassert op_uniq_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_uniq_sortabs_oremptyzero([10]) == [10]\nassert op_uniq_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_sortabs_oremptyzero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_div3_add10_square", "entry_point": "op_div3_add10_square", "primitives": ["div3", "add10", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then add ten to each, then square each.", "solution": "def op_div3_add10_square(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_div3_add10_square([1, 2, 3, 4]) == [169]\nassert op_div3_add10_square([]) == []\nassert op_div3_add10_square([-2, -1, 0, 1, 2]) == [100]\nassert op_div3_add10_square([5, 5, 5]) == []\nassert op_div3_add10_square([3, 1, 2]) == [169]\nassert op_div3_add10_square([10]) == []\nassert op_div3_add10_square([2, 4, 6]) == [256]\nassert op_div3_add10_square([-7, 12, -7]) == [484]"}
{"id": "op_sortabs_sorta_rev", "entry_point": "op_sortabs_sorta_rev", "primitives": ["sortabs", "sorta", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then sort ascending, then reverse the order.", "solution": "def op_sortabs_sorta_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = sorted(r)\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_sorta_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortabs_sorta_rev([]) == []\nassert op_sortabs_sorta_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sortabs_sorta_rev([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_sorta_rev([3, 1, 2]) == [3, 2, 1]\nassert op_sortabs_sorta_rev([10]) == [10]\nassert op_sortabs_sorta_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_sorta_rev([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_trimends_clamp10_oremptyzero", "entry_point": "op_trimends_clamp10_oremptyzero", "primitives": ["trimends", "clamp10", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cap each value at 10, then if empty, use a single zero.", "solution": "def op_trimends_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_trimends_clamp10_oremptyzero([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_clamp10_oremptyzero([]) == [0]\nassert op_trimends_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_clamp10_oremptyzero([5, 5, 5]) == [5]\nassert op_trimends_clamp10_oremptyzero([3, 1, 2]) == [1]\nassert op_trimends_clamp10_oremptyzero([10]) == [0]\nassert op_trimends_clamp10_oremptyzero([2, 4, 6]) == [4]\nassert op_trimends_clamp10_oremptyzero([-7, 12, -7]) == [10]"}
{"id": "op_uniq_negate_dropzeros", "entry_point": "op_uniq_negate_dropzeros", "primitives": ["uniq", "negate", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then drop the zeros.", "solution": "def op_uniq_negate_dropzeros(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_uniq_negate_dropzeros([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_negate_dropzeros([]) == []\nassert op_uniq_negate_dropzeros([-2, -1, 0, 1, 2]) == [2, 1, -1, -2]\nassert op_uniq_negate_dropzeros([5, 5, 5]) == [-5]\nassert op_uniq_negate_dropzeros([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_negate_dropzeros([10]) == [-10]\nassert op_uniq_negate_dropzeros([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_negate_dropzeros([-7, 12, -7]) == [7, -12]"}
{"id": "op_rev_div3_add10", "entry_point": "op_rev_div3_add10", "primitives": ["rev", "div3", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then add ten to each.", "solution": "def op_rev_div3_add10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_rev_div3_add10([1, 2, 3, 4]) == [13]\nassert op_rev_div3_add10([]) == []\nassert op_rev_div3_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_rev_div3_add10([5, 5, 5]) == []\nassert op_rev_div3_add10([3, 1, 2]) == [13]\nassert op_rev_div3_add10([10]) == []\nassert op_rev_div3_add10([2, 4, 6]) == [16]\nassert op_rev_div3_add10([-7, 12, -7]) == [22]"}
{"id": "op_double_absval_clamp10", "entry_point": "op_double_absval_clamp10", "primitives": ["double", "absval", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then cap each value at 10.", "solution": "def op_double_absval_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_absval_clamp10([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_absval_clamp10([]) == []\nassert op_double_absval_clamp10([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_double_absval_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_double_absval_clamp10([3, 1, 2]) == [6, 2, 4]\nassert op_double_absval_clamp10([10]) == [10]\nassert op_double_absval_clamp10([2, 4, 6]) == [4, 8, 10]\nassert op_double_absval_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_pos_square_dropwhileneg", "entry_point": "op_pos_square_dropwhileneg", "primitives": ["pos", "square", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then square each, then drop the leading negative values.", "solution": "def op_pos_square_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_pos_square_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_pos_square_dropwhileneg([]) == []\nassert op_pos_square_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 4]\nassert op_pos_square_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_pos_square_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_pos_square_dropwhileneg([10]) == [100]\nassert op_pos_square_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_pos_square_dropwhileneg([-7, 12, -7]) == [144]"}
{"id": "op_dropwhileneg_uniq_allpos", "entry_point": "op_dropwhileneg_uniq_allpos", "primitives": ["dropwhileneg", "uniq", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_dropwhileneg_uniq_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_uniq_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_uniq_allpos([]) == True\nassert op_dropwhileneg_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dropwhileneg_uniq_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_uniq_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_uniq_allpos([10]) == True\nassert op_dropwhileneg_uniq_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_dec_neg_sortabs", "entry_point": "op_dec_neg_sortabs", "primitives": ["dec", "neg", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the negative numbers, then sort by absolute value.", "solution": "def op_dec_neg_sortabs(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dec_neg_sortabs([1, 2, 3, 4]) == []\nassert op_dec_neg_sortabs([]) == []\nassert op_dec_neg_sortabs([-2, -1, 0, 1, 2]) == [-1, -2, -3]\nassert op_dec_neg_sortabs([5, 5, 5]) == []\nassert op_dec_neg_sortabs([3, 1, 2]) == []\nassert op_dec_neg_sortabs([10]) == []\nassert op_dec_neg_sortabs([2, 4, 6]) == []\nassert op_dec_neg_sortabs([-7, 12, -7]) == [-8, -8]"}
{"id": "op_dropfirst_padto3_issorted", "entry_point": "op_dropfirst_padto3_issorted", "primitives": ["dropfirst", "padto3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_padto3_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_dropfirst_padto3_issorted([1, 2, 3, 4]) == True\nassert op_dropfirst_padto3_issorted([]) == True\nassert op_dropfirst_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_padto3_issorted([5, 5, 5]) == False\nassert op_dropfirst_padto3_issorted([3, 1, 2]) == False\nassert op_dropfirst_padto3_issorted([10]) == True\nassert op_dropfirst_padto3_issorted([2, 4, 6]) == False\nassert op_dropfirst_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_neg_dropfirst_allpos", "entry_point": "op_neg_dropfirst_allpos", "primitives": ["neg", "dropfirst", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the first element, then return whether all values are positive.", "solution": "def op_neg_dropfirst_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[1:]\n    return all(x > 0 for x in r)", "tests": "assert op_neg_dropfirst_allpos([1, 2, 3, 4]) == True\nassert op_neg_dropfirst_allpos([]) == True\nassert op_neg_dropfirst_allpos([-2, -1, 0, 1, 2]) == False\nassert op_neg_dropfirst_allpos([5, 5, 5]) == True\nassert op_neg_dropfirst_allpos([3, 1, 2]) == True\nassert op_neg_dropfirst_allpos([10]) == True\nassert op_neg_dropfirst_allpos([2, 4, 6]) == True\nassert op_neg_dropfirst_allpos([-7, 12, -7]) == False"}
{"id": "op_clamp10_sortabs_dropzeros", "entry_point": "op_clamp10_sortabs_dropzeros", "primitives": ["clamp10", "sortabs", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then drop the zeros.", "solution": "def op_clamp10_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_clamp10_sortabs_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sortabs_dropzeros([]) == []\nassert op_clamp10_sortabs_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_clamp10_sortabs_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortabs_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sortabs_dropzeros([10]) == [10]\nassert op_clamp10_sortabs_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sortabs_dropzeros([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_inc_dropwhileneg_neg", "entry_point": "op_inc_dropwhileneg_neg", "primitives": ["inc", "dropwhileneg", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_inc_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_inc_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_inc_dropwhileneg_neg([]) == []\nassert op_inc_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_inc_dropwhileneg_neg([5, 5, 5]) == []\nassert op_inc_dropwhileneg_neg([3, 1, 2]) == []\nassert op_inc_dropwhileneg_neg([10]) == []\nassert op_inc_dropwhileneg_neg([2, 4, 6]) == []\nassert op_inc_dropwhileneg_neg([-7, 12, -7]) == [-6]"}
{"id": "op_first3_trimends_negate", "entry_point": "op_first3_trimends_negate", "primitives": ["first3", "trimends", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then negate each.", "solution": "def op_first3_trimends_negate(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = [-x for x in r]\n    return r", "tests": "assert op_first3_trimends_negate([1, 2, 3, 4]) == [-2]\nassert op_first3_trimends_negate([]) == []\nassert op_first3_trimends_negate([-2, -1, 0, 1, 2]) == [1]\nassert op_first3_trimends_negate([5, 5, 5]) == [-5]\nassert op_first3_trimends_negate([3, 1, 2]) == [-1]\nassert op_first3_trimends_negate([10]) == []\nassert op_first3_trimends_negate([2, 4, 6]) == [-4]\nassert op_first3_trimends_negate([-7, 12, -7]) == [-12]"}
{"id": "op_padto3_neg_issorted", "entry_point": "op_padto3_neg_issorted", "primitives": ["padto3", "neg", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_padto3_neg_issorted(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_padto3_neg_issorted([1, 2, 3, 4]) == True\nassert op_padto3_neg_issorted([]) == True\nassert op_padto3_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_padto3_neg_issorted([5, 5, 5]) == True\nassert op_padto3_neg_issorted([3, 1, 2]) == True\nassert op_padto3_neg_issorted([10]) == True\nassert op_padto3_neg_issorted([2, 4, 6]) == True\nassert op_padto3_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_negate_last3", "entry_point": "op_dec_negate_last3", "primitives": ["dec", "negate", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then keep only the last three.", "solution": "def op_dec_negate_last3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dec_negate_last3([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_dec_negate_last3([]) == []\nassert op_dec_negate_last3([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_dec_negate_last3([5, 5, 5]) == [-4, -4, -4]\nassert op_dec_negate_last3([3, 1, 2]) == [-2, 0, -1]\nassert op_dec_negate_last3([10]) == [-9]\nassert op_dec_negate_last3([2, 4, 6]) == [-1, -3, -5]\nassert op_dec_negate_last3([-7, 12, -7]) == [8, -11, 8]"}
{"id": "op_div3_dec_last3", "entry_point": "op_div3_dec_last3", "primitives": ["div3", "dec", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then subtract one from each, then keep only the last three.", "solution": "def op_div3_dec_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_dec_last3([1, 2, 3, 4]) == [2]\nassert op_div3_dec_last3([]) == []\nassert op_div3_dec_last3([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_dec_last3([5, 5, 5]) == []\nassert op_div3_dec_last3([3, 1, 2]) == [2]\nassert op_div3_dec_last3([10]) == []\nassert op_div3_dec_last3([2, 4, 6]) == [5]\nassert op_div3_dec_last3([-7, 12, -7]) == [11]"}
{"id": "op_rev_add10_absval", "entry_point": "op_rev_add10_absval", "primitives": ["rev", "add10", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then take the absolute value of each.", "solution": "def op_rev_add10_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_add10_absval([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_rev_add10_absval([]) == []\nassert op_rev_add10_absval([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_rev_add10_absval([5, 5, 5]) == [15, 15, 15]\nassert op_rev_add10_absval([3, 1, 2]) == [12, 11, 13]\nassert op_rev_add10_absval([10]) == [20]\nassert op_rev_add10_absval([2, 4, 6]) == [16, 14, 12]\nassert op_rev_add10_absval([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_square_inc_oremptyzero", "entry_point": "op_square_inc_oremptyzero", "primitives": ["square", "inc", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each, then if empty, use a single zero.", "solution": "def op_square_inc_oremptyzero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_square_inc_oremptyzero([1, 2, 3, 4]) == [2, 5, 10, 17]\nassert op_square_inc_oremptyzero([]) == [0]\nassert op_square_inc_oremptyzero([-2, -1, 0, 1, 2]) == [5, 2, 1, 2, 5]\nassert op_square_inc_oremptyzero([5, 5, 5]) == [26, 26, 26]\nassert op_square_inc_oremptyzero([3, 1, 2]) == [10, 2, 5]\nassert op_square_inc_oremptyzero([10]) == [101]\nassert op_square_inc_oremptyzero([2, 4, 6]) == [5, 17, 37]\nassert op_square_inc_oremptyzero([-7, 12, -7]) == [50, 145, 50]"}
{"id": "op_div3_takewhilepos_odds", "entry_point": "op_div3_takewhilepos_odds", "primitives": ["div3", "takewhilepos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then keep the odd numbers.", "solution": "def op_div3_takewhilepos_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_takewhilepos_odds([1, 2, 3, 4]) == [3]\nassert op_div3_takewhilepos_odds([]) == []\nassert op_div3_takewhilepos_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_takewhilepos_odds([5, 5, 5]) == []\nassert op_div3_takewhilepos_odds([3, 1, 2]) == [3]\nassert op_div3_takewhilepos_odds([10]) == []\nassert op_div3_takewhilepos_odds([2, 4, 6]) == []\nassert op_div3_takewhilepos_odds([-7, 12, -7]) == []"}
{"id": "op_add10_dropzeros_absval", "entry_point": "op_add10_dropzeros_absval", "primitives": ["add10", "dropzeros", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then take the absolute value of each.", "solution": "def op_add10_dropzeros_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_dropzeros_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros_absval([]) == []\nassert op_add10_dropzeros_absval([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros_absval([5, 5, 5]) == [15, 15, 15]\nassert op_add10_dropzeros_absval([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropzeros_absval([10]) == [20]\nassert op_add10_dropzeros_absval([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros_absval([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_div3_dropzeros_first3", "entry_point": "op_div3_dropzeros_first3", "primitives": ["div3", "dropzeros", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the zeros, then keep only the first three.", "solution": "def op_div3_dropzeros_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return r", "tests": "assert op_div3_dropzeros_first3([1, 2, 3, 4]) == [3]\nassert op_div3_dropzeros_first3([]) == []\nassert op_div3_dropzeros_first3([-2, -1, 0, 1, 2]) == []\nassert op_div3_dropzeros_first3([5, 5, 5]) == []\nassert op_div3_dropzeros_first3([3, 1, 2]) == [3]\nassert op_div3_dropzeros_first3([10]) == []\nassert op_div3_dropzeros_first3([2, 4, 6]) == [6]\nassert op_div3_dropzeros_first3([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_absval_firsteven", "entry_point": "op_beforezero_absval_firsteven", "primitives": ["beforezero", "absval", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take the absolute value of each, then return the first even value (0 if none).", "solution": "def op_beforezero_absval_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_absval_firsteven([1, 2, 3, 4]) == 2\nassert op_beforezero_absval_firsteven([]) == 0\nassert op_beforezero_absval_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_absval_firsteven([5, 5, 5]) == 0\nassert op_beforezero_absval_firsteven([3, 1, 2]) == 2\nassert op_beforezero_absval_firsteven([10]) == 10\nassert op_beforezero_absval_firsteven([2, 4, 6]) == 2\nassert op_beforezero_absval_firsteven([-7, 12, -7]) == 12"}
{"id": "op_neg_sortabs_trimends", "entry_point": "op_neg_sortabs_trimends", "primitives": ["neg", "sortabs", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then drop the first and last elements.", "solution": "def op_neg_sortabs_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    return r", "tests": "assert op_neg_sortabs_trimends([1, 2, 3, 4]) == []\nassert op_neg_sortabs_trimends([]) == []\nassert op_neg_sortabs_trimends([-2, -1, 0, 1, 2]) == []\nassert op_neg_sortabs_trimends([5, 5, 5]) == []\nassert op_neg_sortabs_trimends([3, 1, 2]) == []\nassert op_neg_sortabs_trimends([10]) == []\nassert op_neg_sortabs_trimends([2, 4, 6]) == []\nassert op_neg_sortabs_trimends([-7, 12, -7]) == []"}
{"id": "op_uniq_gt5_anyeven", "entry_point": "op_uniq_gt5_anyeven", "primitives": ["uniq", "gt5", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep values greater than five, then return whether any value is even.", "solution": "def op_uniq_gt5_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_gt5_anyeven([1, 2, 3, 4]) == False\nassert op_uniq_gt5_anyeven([]) == False\nassert op_uniq_gt5_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_uniq_gt5_anyeven([5, 5, 5]) == False\nassert op_uniq_gt5_anyeven([3, 1, 2]) == False\nassert op_uniq_gt5_anyeven([10]) == True\nassert op_uniq_gt5_anyeven([2, 4, 6]) == True\nassert op_uniq_gt5_anyeven([-7, 12, -7]) == True"}
{"id": "op_first3_trimends_firsteven", "entry_point": "op_first3_trimends_firsteven", "primitives": ["first3", "trimends", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then return the first even value (0 if none).", "solution": "def op_first3_trimends_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_trimends_firsteven([1, 2, 3, 4]) == 2\nassert op_first3_trimends_firsteven([]) == 0\nassert op_first3_trimends_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_first3_trimends_firsteven([5, 5, 5]) == 0\nassert op_first3_trimends_firsteven([3, 1, 2]) == 0\nassert op_first3_trimends_firsteven([10]) == 0\nassert op_first3_trimends_firsteven([2, 4, 6]) == 4\nassert op_first3_trimends_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropwhileneg_takewhilepos_prod", "entry_point": "op_dropwhileneg_takewhilepos_prod", "primitives": ["dropwhileneg", "takewhilepos", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take values while they are positive, then return their product.", "solution": "def op_dropwhileneg_takewhilepos_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_takewhilepos_prod([1, 2, 3, 4]) == 24\nassert op_dropwhileneg_takewhilepos_prod([]) == 1\nassert op_dropwhileneg_takewhilepos_prod([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_takewhilepos_prod([5, 5, 5]) == 125\nassert op_dropwhileneg_takewhilepos_prod([3, 1, 2]) == 6\nassert op_dropwhileneg_takewhilepos_prod([10]) == 10\nassert op_dropwhileneg_takewhilepos_prod([2, 4, 6]) == 48\nassert op_dropwhileneg_takewhilepos_prod([-7, 12, -7]) == 12"}
{"id": "op_nonempty_lower_sortlen", "entry_point": "op_nonempty_lower_sortlen", "primitives": ["nonempty", "lower", "sortlen"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then lowercase each string, then sort by length, shortest first.", "solution": "def op_nonempty_lower_sortlen(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_nonempty_lower_sortlen(['Hello', 'world']) == ['hello', 'world']\nassert op_nonempty_lower_sortlen([]) == []\nassert op_nonempty_lower_sortlen(['  a ', '', 'BC', 'bc']) == ['bc', 'bc', '  a ']\nassert op_nonempty_lower_sortlen(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_nonempty_lower_sortlen(['x']) == ['x']\nassert op_nonempty_lower_sortlen(['abc', 'de', '']) == ['de', 'abc']"}
{"id": "op_evens_add10_sorta", "entry_point": "op_evens_add10_sorta", "primitives": ["evens", "add10", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then sort ascending.", "solution": "def op_evens_add10_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_evens_add10_sorta([1, 2, 3, 4]) == [12, 14]\nassert op_evens_add10_sorta([]) == []\nassert op_evens_add10_sorta([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_evens_add10_sorta([5, 5, 5]) == []\nassert op_evens_add10_sorta([3, 1, 2]) == [12]\nassert op_evens_add10_sorta([10]) == [20]\nassert op_evens_add10_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_evens_add10_sorta([-7, 12, -7]) == [22]"}
{"id": "op_add10_odds_allpos", "entry_point": "op_add10_odds_allpos", "primitives": ["add10", "odds", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_add10_odds_allpos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_add10_odds_allpos([1, 2, 3, 4]) == True\nassert op_add10_odds_allpos([]) == True\nassert op_add10_odds_allpos([-2, -1, 0, 1, 2]) == True\nassert op_add10_odds_allpos([5, 5, 5]) == True\nassert op_add10_odds_allpos([3, 1, 2]) == True\nassert op_add10_odds_allpos([10]) == True\nassert op_add10_odds_allpos([2, 4, 6]) == True\nassert op_add10_odds_allpos([-7, 12, -7]) == True"}
{"id": "op_absval_dec_max", "entry_point": "op_absval_dec_max", "primitives": ["absval", "dec", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then subtract one from each, then return the maximum (0 if empty).", "solution": "def op_absval_dec_max(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x - 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_absval_dec_max([1, 2, 3, 4]) == 3\nassert op_absval_dec_max([]) == 0\nassert op_absval_dec_max([-2, -1, 0, 1, 2]) == 1\nassert op_absval_dec_max([5, 5, 5]) == 4\nassert op_absval_dec_max([3, 1, 2]) == 2\nassert op_absval_dec_max([10]) == 9\nassert op_absval_dec_max([2, 4, 6]) == 5\nassert op_absval_dec_max([-7, 12, -7]) == 11"}
{"id": "op_add10_dropwhileneg_max", "entry_point": "op_add10_dropwhileneg_max", "primitives": ["add10", "dropwhileneg", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_add10_dropwhileneg_max(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_add10_dropwhileneg_max([1, 2, 3, 4]) == 14\nassert op_add10_dropwhileneg_max([]) == 0\nassert op_add10_dropwhileneg_max([-2, -1, 0, 1, 2]) == 12\nassert op_add10_dropwhileneg_max([5, 5, 5]) == 15\nassert op_add10_dropwhileneg_max([3, 1, 2]) == 13\nassert op_add10_dropwhileneg_max([10]) == 20\nassert op_add10_dropwhileneg_max([2, 4, 6]) == 16\nassert op_add10_dropwhileneg_max([-7, 12, -7]) == 22"}
{"id": "op_clamp10_sortd_min", "entry_point": "op_clamp10_sortd_min", "primitives": ["clamp10", "sortd", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort descending, then return the minimum (0 if empty).", "solution": "def op_clamp10_sortd_min(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_clamp10_sortd_min([1, 2, 3, 4]) == 1\nassert op_clamp10_sortd_min([]) == 0\nassert op_clamp10_sortd_min([-2, -1, 0, 1, 2]) == -2\nassert op_clamp10_sortd_min([5, 5, 5]) == 5\nassert op_clamp10_sortd_min([3, 1, 2]) == 1\nassert op_clamp10_sortd_min([10]) == 10\nassert op_clamp10_sortd_min([2, 4, 6]) == 2\nassert op_clamp10_sortd_min([-7, 12, -7]) == -7"}
{"id": "op_inc_neg_odds", "entry_point": "op_inc_neg_odds", "primitives": ["inc", "neg", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_inc_neg_odds(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_inc_neg_odds([1, 2, 3, 4]) == []\nassert op_inc_neg_odds([]) == []\nassert op_inc_neg_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_odds([5, 5, 5]) == []\nassert op_inc_neg_odds([3, 1, 2]) == []\nassert op_inc_neg_odds([10]) == []\nassert op_inc_neg_odds([2, 4, 6]) == []\nassert op_inc_neg_odds([-7, 12, -7]) == []"}
{"id": "op_odds_oremptyzero_absval", "entry_point": "op_odds_oremptyzero_absval", "primitives": ["odds", "oremptyzero", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero, then take the absolute value of each.", "solution": "def op_odds_oremptyzero_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_oremptyzero_absval([1, 2, 3, 4]) == [1, 3]\nassert op_odds_oremptyzero_absval([]) == [0]\nassert op_odds_oremptyzero_absval([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_odds_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_odds_oremptyzero_absval([3, 1, 2]) == [3, 1]\nassert op_odds_oremptyzero_absval([10]) == [0]\nassert op_odds_oremptyzero_absval([2, 4, 6]) == [0]\nassert op_odds_oremptyzero_absval([-7, 12, -7]) == [7, 7]"}
{"id": "op_ages_takewhilepos_max", "entry_point": "op_ages_takewhilepos_max", "primitives": ["ages", "takewhilepos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_ages_takewhilepos_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_ages_takewhilepos_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_takewhilepos_max([]) == 0\nassert op_ages_takewhilepos_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_takewhilepos_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_oremptyzero_trimends_dec", "entry_point": "op_oremptyzero_trimends_dec", "primitives": ["oremptyzero", "trimends", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then subtract one from each.", "solution": "def op_oremptyzero_trimends_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_trimends_dec([1, 2, 3, 4]) == [1, 2]\nassert op_oremptyzero_trimends_dec([]) == []\nassert op_oremptyzero_trimends_dec([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_oremptyzero_trimends_dec([5, 5, 5]) == [4]\nassert op_oremptyzero_trimends_dec([3, 1, 2]) == [0]\nassert op_oremptyzero_trimends_dec([10]) == []\nassert op_oremptyzero_trimends_dec([2, 4, 6]) == [3]\nassert op_oremptyzero_trimends_dec([-7, 12, -7]) == [11]"}
{"id": "op_last3_neg_max", "entry_point": "op_last3_neg_max", "primitives": ["last3", "neg", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_last3_neg_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_last3_neg_max([1, 2, 3, 4]) == 0\nassert op_last3_neg_max([]) == 0\nassert op_last3_neg_max([-2, -1, 0, 1, 2]) == 0\nassert op_last3_neg_max([5, 5, 5]) == 0\nassert op_last3_neg_max([3, 1, 2]) == 0\nassert op_last3_neg_max([10]) == 0\nassert op_last3_neg_max([2, 4, 6]) == 0\nassert op_last3_neg_max([-7, 12, -7]) == -7"}
{"id": "op_prefixup_sortalpha_anyempty", "entry_point": "op_prefixup_sortalpha_anyempty", "primitives": ["prefixup", "sortalpha", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort alphabetically, then return whether any string is empty.", "solution": "def op_prefixup_sortalpha_anyempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    return any(s == '' for s in r)", "tests": "assert op_prefixup_sortalpha_anyempty(['Hello', 'world']) == False\nassert op_prefixup_sortalpha_anyempty([]) == False\nassert op_prefixup_sortalpha_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_prefixup_sortalpha_anyempty(['one', 'one', 'Two']) == False\nassert op_prefixup_sortalpha_anyempty(['x']) == False\nassert op_prefixup_sortalpha_anyempty(['abc', 'de', '']) == False"}
{"id": "op_trimends_beforezero_dropzeros", "entry_point": "op_trimends_beforezero_dropzeros", "primitives": ["trimends", "beforezero", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then drop the zeros.", "solution": "def op_trimends_beforezero_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_beforezero_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_beforezero_dropzeros([]) == []\nassert op_trimends_beforezero_dropzeros([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero_dropzeros([5, 5, 5]) == [5]\nassert op_trimends_beforezero_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_beforezero_dropzeros([10]) == []\nassert op_trimends_beforezero_dropzeros([2, 4, 6]) == [4]\nassert op_trimends_beforezero_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_div3_dropwhileneg_last3", "entry_point": "op_div3_dropwhileneg_last3", "primitives": ["div3", "dropwhileneg", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the leading negative values, then keep only the last three.", "solution": "def op_div3_dropwhileneg_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_dropwhileneg_last3([1, 2, 3, 4]) == [3]\nassert op_div3_dropwhileneg_last3([]) == []\nassert op_div3_dropwhileneg_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_dropwhileneg_last3([5, 5, 5]) == []\nassert op_div3_dropwhileneg_last3([3, 1, 2]) == [3]\nassert op_div3_dropwhileneg_last3([10]) == []\nassert op_div3_dropwhileneg_last3([2, 4, 6]) == [6]\nassert op_div3_dropwhileneg_last3([-7, 12, -7]) == [12]"}
{"id": "op_negate_oremptyzero_last3", "entry_point": "op_negate_oremptyzero_last3", "primitives": ["negate", "oremptyzero", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then keep only the last three.", "solution": "def op_negate_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_negate_oremptyzero_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_negate_oremptyzero_last3([]) == [0]\nassert op_negate_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0, -1, -2]\nassert op_negate_oremptyzero_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_negate_oremptyzero_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_negate_oremptyzero_last3([10]) == [-10]\nassert op_negate_oremptyzero_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_negate_oremptyzero_last3([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_double_oremptyzero_takewhilepos", "entry_point": "op_double_oremptyzero_takewhilepos", "primitives": ["double", "oremptyzero", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then if empty, use a single zero, then take values while they are positive.", "solution": "def op_double_oremptyzero_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r if r else [0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_oremptyzero_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_oremptyzero_takewhilepos([]) == []\nassert op_double_oremptyzero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_oremptyzero_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_double_oremptyzero_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_double_oremptyzero_takewhilepos([10]) == [20]\nassert op_double_oremptyzero_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_double_oremptyzero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_rev_div3_counteven", "entry_point": "op_rev_div3_counteven", "primitives": ["rev", "div3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then return how many values are even.", "solution": "def op_rev_div3_counteven(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_rev_div3_counteven([1, 2, 3, 4]) == 0\nassert op_rev_div3_counteven([]) == 0\nassert op_rev_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_rev_div3_counteven([5, 5, 5]) == 0\nassert op_rev_div3_counteven([3, 1, 2]) == 0\nassert op_rev_div3_counteven([10]) == 0\nassert op_rev_div3_counteven([2, 4, 6]) == 1\nassert op_rev_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_first3_pos_uniq", "entry_point": "op_first3_pos_uniq", "primitives": ["first3", "pos", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the positive numbers, then drop duplicates keeping first occurrence.", "solution": "def op_first3_pos_uniq(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_first3_pos_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_pos_uniq([]) == []\nassert op_first3_pos_uniq([-2, -1, 0, 1, 2]) == []\nassert op_first3_pos_uniq([5, 5, 5]) == [5]\nassert op_first3_pos_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_first3_pos_uniq([10]) == [10]\nassert op_first3_pos_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_first3_pos_uniq([-7, 12, -7]) == [12]"}
{"id": "op_inc_evens_min", "entry_point": "op_inc_evens_min", "primitives": ["inc", "evens", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_inc_evens_min(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_inc_evens_min([1, 2, 3, 4]) == 2\nassert op_inc_evens_min([]) == 0\nassert op_inc_evens_min([-2, -1, 0, 1, 2]) == 0\nassert op_inc_evens_min([5, 5, 5]) == 6\nassert op_inc_evens_min([3, 1, 2]) == 2\nassert op_inc_evens_min([10]) == 0\nassert op_inc_evens_min([2, 4, 6]) == 0\nassert op_inc_evens_min([-7, 12, -7]) == -6"}
{"id": "op_add10_first3_dropzeros", "entry_point": "op_add10_first3_dropzeros", "primitives": ["add10", "first3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the first three, then drop the zeros.", "solution": "def op_add10_first3_dropzeros(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_add10_first3_dropzeros([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_first3_dropzeros([]) == []\nassert op_add10_first3_dropzeros([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_first3_dropzeros([5, 5, 5]) == [15, 15, 15]\nassert op_add10_first3_dropzeros([3, 1, 2]) == [13, 11, 12]\nassert op_add10_first3_dropzeros([10]) == [20]\nassert op_add10_first3_dropzeros([2, 4, 6]) == [12, 14, 16]\nassert op_add10_first3_dropzeros([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_clamp10_uniq_absval", "entry_point": "op_clamp10_uniq_absval", "primitives": ["clamp10", "uniq", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_clamp10_uniq_absval(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_clamp10_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_uniq_absval([]) == []\nassert op_clamp10_uniq_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_clamp10_uniq_absval([5, 5, 5]) == [5]\nassert op_clamp10_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_uniq_absval([10]) == [10]\nassert op_clamp10_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_uniq_absval([-7, 12, -7]) == [7, 10]"}
{"id": "op_sortd_dropzeros_sum", "entry_point": "op_sortd_dropzeros_sum", "primitives": ["sortd", "dropzeros", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the zeros, then return their sum.", "solution": "def op_sortd_dropzeros_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_sortd_dropzeros_sum([1, 2, 3, 4]) == 10\nassert op_sortd_dropzeros_sum([]) == 0\nassert op_sortd_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_dropzeros_sum([5, 5, 5]) == 15\nassert op_sortd_dropzeros_sum([3, 1, 2]) == 6\nassert op_sortd_dropzeros_sum([10]) == 10\nassert op_sortd_dropzeros_sum([2, 4, 6]) == 12\nassert op_sortd_dropzeros_sum([-7, 12, -7]) == -2"}
{"id": "op_takewhilepos_odds_div3", "entry_point": "op_takewhilepos_odds_div3", "primitives": ["takewhilepos", "odds", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the odd numbers, then keep multiples of three.", "solution": "def op_takewhilepos_odds_div3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_takewhilepos_odds_div3([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_odds_div3([]) == []\nassert op_takewhilepos_odds_div3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_odds_div3([5, 5, 5]) == []\nassert op_takewhilepos_odds_div3([3, 1, 2]) == [3]\nassert op_takewhilepos_odds_div3([10]) == []\nassert op_takewhilepos_odds_div3([2, 4, 6]) == []\nassert op_takewhilepos_odds_div3([-7, 12, -7]) == []"}
{"id": "op_negate_dropwhileneg_anyeven", "entry_point": "op_negate_dropwhileneg_anyeven", "primitives": ["negate", "dropwhileneg", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then return whether any value is even.", "solution": "def op_negate_dropwhileneg_anyeven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_negate_dropwhileneg_anyeven([1, 2, 3, 4]) == False\nassert op_negate_dropwhileneg_anyeven([]) == False\nassert op_negate_dropwhileneg_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_negate_dropwhileneg_anyeven([5, 5, 5]) == False\nassert op_negate_dropwhileneg_anyeven([3, 1, 2]) == False\nassert op_negate_dropwhileneg_anyeven([10]) == False\nassert op_negate_dropwhileneg_anyeven([2, 4, 6]) == False\nassert op_negate_dropwhileneg_anyeven([-7, 12, -7]) == True"}
{"id": "op_absval_dropwhileneg_double", "entry_point": "op_absval_dropwhileneg_double", "primitives": ["absval", "dropwhileneg", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then double each.", "solution": "def op_absval_dropwhileneg_double(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_absval_dropwhileneg_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_absval_dropwhileneg_double([]) == []\nassert op_absval_dropwhileneg_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_absval_dropwhileneg_double([5, 5, 5]) == [10, 10, 10]\nassert op_absval_dropwhileneg_double([3, 1, 2]) == [6, 2, 4]\nassert op_absval_dropwhileneg_double([10]) == [20]\nassert op_absval_dropwhileneg_double([2, 4, 6]) == [4, 8, 12]\nassert op_absval_dropwhileneg_double([-7, 12, -7]) == [14, 24, 14]"}
{"id": "op_sortalpha_strip_upper", "entry_point": "op_sortalpha_strip_upper", "primitives": ["sortalpha", "strip", "upper"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then trim whitespace from each, then uppercase each string.", "solution": "def op_sortalpha_strip_upper(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_sortalpha_strip_upper(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_sortalpha_strip_upper([]) == []\nassert op_sortalpha_strip_upper(['  a ', '', 'BC', 'bc']) == ['', 'A', 'BC', 'BC']\nassert op_sortalpha_strip_upper(['one', 'one', 'Two']) == ['TWO', 'ONE', 'ONE']\nassert op_sortalpha_strip_upper(['x']) == ['X']\nassert op_sortalpha_strip_upper(['abc', 'de', '']) == ['', 'ABC', 'DE']"}
{"id": "op_first3_sorta_prod", "entry_point": "op_first3_sorta_prod", "primitives": ["first3", "sorta", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort ascending, then return their product.", "solution": "def op_first3_sorta_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r)\n    return __import__('math').prod(r)", "tests": "assert op_first3_sorta_prod([1, 2, 3, 4]) == 6\nassert op_first3_sorta_prod([]) == 1\nassert op_first3_sorta_prod([-2, -1, 0, 1, 2]) == 0\nassert op_first3_sorta_prod([5, 5, 5]) == 125\nassert op_first3_sorta_prod([3, 1, 2]) == 6\nassert op_first3_sorta_prod([10]) == 10\nassert op_first3_sorta_prod([2, 4, 6]) == 48\nassert op_first3_sorta_prod([-7, 12, -7]) == 588"}
{"id": "op_dropfirst_neg_square", "entry_point": "op_dropfirst_neg_square", "primitives": ["dropfirst", "neg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the negative numbers, then square each.", "solution": "def op_dropfirst_neg_square(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_dropfirst_neg_square([1, 2, 3, 4]) == []\nassert op_dropfirst_neg_square([]) == []\nassert op_dropfirst_neg_square([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_neg_square([5, 5, 5]) == []\nassert op_dropfirst_neg_square([3, 1, 2]) == []\nassert op_dropfirst_neg_square([10]) == []\nassert op_dropfirst_neg_square([2, 4, 6]) == []\nassert op_dropfirst_neg_square([-7, 12, -7]) == [49]"}
{"id": "op_pos_evens_takewhilepos", "entry_point": "op_pos_evens_takewhilepos", "primitives": ["pos", "evens", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then take values while they are positive.", "solution": "def op_pos_evens_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_pos_evens_takewhilepos([1, 2, 3, 4]) == [2, 4]\nassert op_pos_evens_takewhilepos([]) == []\nassert op_pos_evens_takewhilepos([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_evens_takewhilepos([5, 5, 5]) == []\nassert op_pos_evens_takewhilepos([3, 1, 2]) == [2]\nassert op_pos_evens_takewhilepos([10]) == [10]\nassert op_pos_evens_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_pos_evens_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_double_trimends_dec", "entry_point": "op_double_trimends_dec", "primitives": ["double", "trimends", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then subtract one from each.", "solution": "def op_double_trimends_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_trimends_dec([1, 2, 3, 4]) == [3, 5]\nassert op_double_trimends_dec([]) == []\nassert op_double_trimends_dec([-2, -1, 0, 1, 2]) == [-3, -1, 1]\nassert op_double_trimends_dec([5, 5, 5]) == [9]\nassert op_double_trimends_dec([3, 1, 2]) == [1]\nassert op_double_trimends_dec([10]) == []\nassert op_double_trimends_dec([2, 4, 6]) == [7]\nassert op_double_trimends_dec([-7, 12, -7]) == [23]"}
{"id": "op_last3_div3_odds", "entry_point": "op_last3_div3_odds", "primitives": ["last3", "div3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then keep the odd numbers.", "solution": "def op_last3_div3_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_div3_odds([1, 2, 3, 4]) == [3]\nassert op_last3_div3_odds([]) == []\nassert op_last3_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_last3_div3_odds([5, 5, 5]) == []\nassert op_last3_div3_odds([3, 1, 2]) == [3]\nassert op_last3_div3_odds([10]) == []\nassert op_last3_div3_odds([2, 4, 6]) == []\nassert op_last3_div3_odds([-7, 12, -7]) == []"}
{"id": "op_inc_sorta_beforezero", "entry_point": "op_inc_sorta_beforezero", "primitives": ["inc", "sorta", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then keep everything before the first zero.", "solution": "def op_inc_sorta_beforezero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_inc_sorta_beforezero([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sorta_beforezero([]) == []\nassert op_inc_sorta_beforezero([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_sorta_beforezero([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sorta_beforezero([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sorta_beforezero([10]) == [11]\nassert op_inc_sorta_beforezero([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta_beforezero([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_square_dec_sum", "entry_point": "op_square_dec_sum", "primitives": ["square", "dec", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each, then return their sum.", "solution": "def op_square_dec_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    return sum(r)", "tests": "assert op_square_dec_sum([1, 2, 3, 4]) == 26\nassert op_square_dec_sum([]) == 0\nassert op_square_dec_sum([-2, -1, 0, 1, 2]) == 5\nassert op_square_dec_sum([5, 5, 5]) == 72\nassert op_square_dec_sum([3, 1, 2]) == 11\nassert op_square_dec_sum([10]) == 99\nassert op_square_dec_sum([2, 4, 6]) == 53\nassert op_square_dec_sum([-7, 12, -7]) == 239"}
{"id": "op_dropwhileneg_double_takewhilepos", "entry_point": "op_dropwhileneg_double_takewhilepos", "primitives": ["dropwhileneg", "double", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then take values while they are positive.", "solution": "def op_dropwhileneg_double_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_double_takewhilepos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_double_takewhilepos([]) == []\nassert op_dropwhileneg_double_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_double_takewhilepos([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_double_takewhilepos([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_double_takewhilepos([10]) == [20]\nassert op_dropwhileneg_double_takewhilepos([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_double_takewhilepos([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_oremptyzero_uniq", "entry_point": "op_takewhilepos_oremptyzero_uniq", "primitives": ["takewhilepos", "oremptyzero", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_oremptyzero_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_oremptyzero_uniq([]) == [0]\nassert op_takewhilepos_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_oremptyzero_uniq([5, 5, 5]) == [5]\nassert op_takewhilepos_oremptyzero_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_oremptyzero_uniq([10]) == [10]\nassert op_takewhilepos_oremptyzero_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_oremptyzero_uniq([-7, 12, -7]) == [0]"}
{"id": "op_trimends_evens_add10", "entry_point": "op_trimends_evens_add10", "primitives": ["trimends", "evens", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the even numbers, then add ten to each.", "solution": "def op_trimends_evens_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_evens_add10([1, 2, 3, 4]) == [12]\nassert op_trimends_evens_add10([]) == []\nassert op_trimends_evens_add10([-2, -1, 0, 1, 2]) == [10]\nassert op_trimends_evens_add10([5, 5, 5]) == []\nassert op_trimends_evens_add10([3, 1, 2]) == []\nassert op_trimends_evens_add10([10]) == []\nassert op_trimends_evens_add10([2, 4, 6]) == [14]\nassert op_trimends_evens_add10([-7, 12, -7]) == [22]"}
{"id": "op_upper_firstchar_joinc", "entry_point": "op_upper_firstchar_joinc", "primitives": ["upper", "firstchar", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then keep the first character of each (dropping empties), then join them with commas.", "solution": "def op_upper_firstchar_joinc(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s[0] for s in r if s]\n    return ','.join(r)", "tests": "assert op_upper_firstchar_joinc(['Hello', 'world']) == 'H,W'\nassert op_upper_firstchar_joinc([]) == ''\nassert op_upper_firstchar_joinc(['  a ', '', 'BC', 'bc']) == ' ,B,B'\nassert op_upper_firstchar_joinc(['one', 'one', 'Two']) == 'O,O,T'\nassert op_upper_firstchar_joinc(['x']) == 'X'\nassert op_upper_firstchar_joinc(['abc', 'de', '']) == 'A,D'"}
{"id": "op_inc_square_negate", "entry_point": "op_inc_square_negate", "primitives": ["inc", "square", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then square each, then negate each.", "solution": "def op_inc_square_negate(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_inc_square_negate([1, 2, 3, 4]) == [-4, -9, -16, -25]\nassert op_inc_square_negate([]) == []\nassert op_inc_square_negate([-2, -1, 0, 1, 2]) == [-1, 0, -1, -4, -9]\nassert op_inc_square_negate([5, 5, 5]) == [-36, -36, -36]\nassert op_inc_square_negate([3, 1, 2]) == [-16, -4, -9]\nassert op_inc_square_negate([10]) == [-121]\nassert op_inc_square_negate([2, 4, 6]) == [-9, -25, -49]\nassert op_inc_square_negate([-7, 12, -7]) == [-36, -169, -36]"}
{"id": "op_odds_add10_sortd", "entry_point": "op_odds_add10_sortd", "primitives": ["odds", "add10", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add ten to each, then sort descending.", "solution": "def op_odds_add10_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_odds_add10_sortd([1, 2, 3, 4]) == [13, 11]\nassert op_odds_add10_sortd([]) == []\nassert op_odds_add10_sortd([-2, -1, 0, 1, 2]) == [11, 9]\nassert op_odds_add10_sortd([5, 5, 5]) == [15, 15, 15]\nassert op_odds_add10_sortd([3, 1, 2]) == [13, 11]\nassert op_odds_add10_sortd([10]) == []\nassert op_odds_add10_sortd([2, 4, 6]) == []\nassert op_odds_add10_sortd([-7, 12, -7]) == [3, 3]"}
{"id": "op_sortd_neg_negate", "entry_point": "op_sortd_neg_negate", "primitives": ["sortd", "neg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then negate each.", "solution": "def op_sortd_neg_negate(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortd_neg_negate([1, 2, 3, 4]) == []\nassert op_sortd_neg_negate([]) == []\nassert op_sortd_neg_negate([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_sortd_neg_negate([5, 5, 5]) == []\nassert op_sortd_neg_negate([3, 1, 2]) == []\nassert op_sortd_neg_negate([10]) == []\nassert op_sortd_neg_negate([2, 4, 6]) == []\nassert op_sortd_neg_negate([-7, 12, -7]) == [7, 7]"}
{"id": "op_absval_add10_square", "entry_point": "op_absval_add10_square", "primitives": ["absval", "add10", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then square each.", "solution": "def op_absval_add10_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_add10_square([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_absval_add10_square([]) == []\nassert op_absval_add10_square([-2, -1, 0, 1, 2]) == [144, 121, 100, 121, 144]\nassert op_absval_add10_square([5, 5, 5]) == [225, 225, 225]\nassert op_absval_add10_square([3, 1, 2]) == [169, 121, 144]\nassert op_absval_add10_square([10]) == [400]\nassert op_absval_add10_square([2, 4, 6]) == [144, 196, 256]\nassert op_absval_add10_square([-7, 12, -7]) == [289, 484, 289]"}
{"id": "op_double_div3_issorted", "entry_point": "op_double_div3_issorted", "primitives": ["double", "div3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_double_div3_issorted(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_double_div3_issorted([1, 2, 3, 4]) == True\nassert op_double_div3_issorted([]) == True\nassert op_double_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_double_div3_issorted([5, 5, 5]) == True\nassert op_double_div3_issorted([3, 1, 2]) == True\nassert op_double_div3_issorted([10]) == True\nassert op_double_div3_issorted([2, 4, 6]) == True\nassert op_double_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_square_rev", "entry_point": "op_dec_square_rev", "primitives": ["dec", "square", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then reverse the order.", "solution": "def op_dec_square_rev(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_dec_square_rev([1, 2, 3, 4]) == [9, 4, 1, 0]\nassert op_dec_square_rev([]) == []\nassert op_dec_square_rev([-2, -1, 0, 1, 2]) == [1, 0, 1, 4, 9]\nassert op_dec_square_rev([5, 5, 5]) == [16, 16, 16]\nassert op_dec_square_rev([3, 1, 2]) == [1, 0, 4]\nassert op_dec_square_rev([10]) == [81]\nassert op_dec_square_rev([2, 4, 6]) == [25, 9, 1]\nassert op_dec_square_rev([-7, 12, -7]) == [64, 121, 64]"}
{"id": "op_neg_first3_issorted", "entry_point": "op_neg_first3_issorted", "primitives": ["neg", "first3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep only the first three, then return whether the list is sorted ascending.", "solution": "def op_neg_first3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r == sorted(r)", "tests": "assert op_neg_first3_issorted([1, 2, 3, 4]) == True\nassert op_neg_first3_issorted([]) == True\nassert op_neg_first3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_neg_first3_issorted([5, 5, 5]) == True\nassert op_neg_first3_issorted([3, 1, 2]) == True\nassert op_neg_first3_issorted([10]) == True\nassert op_neg_first3_issorted([2, 4, 6]) == True\nassert op_neg_first3_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_neg_odds", "entry_point": "op_gt5_neg_odds", "primitives": ["gt5", "neg", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the negative numbers, then keep the odd numbers.", "solution": "def op_gt5_neg_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_neg_odds([1, 2, 3, 4]) == []\nassert op_gt5_neg_odds([]) == []\nassert op_gt5_neg_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_neg_odds([5, 5, 5]) == []\nassert op_gt5_neg_odds([3, 1, 2]) == []\nassert op_gt5_neg_odds([10]) == []\nassert op_gt5_neg_odds([2, 4, 6]) == []\nassert op_gt5_neg_odds([-7, 12, -7]) == []"}
{"id": "op_beforezero_rev_len", "entry_point": "op_beforezero_rev_len", "primitives": ["beforezero", "rev", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then return how many remain.", "solution": "def op_beforezero_rev_len(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return len(r)", "tests": "assert op_beforezero_rev_len([1, 2, 3, 4]) == 4\nassert op_beforezero_rev_len([]) == 0\nassert op_beforezero_rev_len([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_rev_len([5, 5, 5]) == 3\nassert op_beforezero_rev_len([3, 1, 2]) == 3\nassert op_beforezero_rev_len([10]) == 1\nassert op_beforezero_rev_len([2, 4, 6]) == 3\nassert op_beforezero_rev_len([-7, 12, -7]) == 3"}
{"id": "op_ages_negate_uniq", "entry_point": "op_ages_negate_uniq", "primitives": ["ages", "negate", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_ages_negate_uniq(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_ages_negate_uniq([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [-36, -12]\nassert op_ages_negate_uniq([]) == []\nassert op_ages_negate_uniq([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [-18, -65, -17]\nassert op_ages_negate_uniq([{'name': 'Fi', 'age': 41}]) == [-41]"}
{"id": "op_dropzeros_odds_takewhilepos", "entry_point": "op_dropzeros_odds_takewhilepos", "primitives": ["dropzeros", "odds", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then take values while they are positive.", "solution": "def op_dropzeros_odds_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropzeros_odds_takewhilepos([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds_takewhilepos([]) == []\nassert op_dropzeros_odds_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropzeros_odds_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_takewhilepos([3, 1, 2]) == [3, 1]\nassert op_dropzeros_odds_takewhilepos([10]) == []\nassert op_dropzeros_odds_takewhilepos([2, 4, 6]) == []\nassert op_dropzeros_odds_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_absval_takewhilepos", "entry_point": "op_dropwhileneg_absval_takewhilepos", "primitives": ["dropwhileneg", "absval", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then take the absolute value of each, then take values while they are positive.", "solution": "def op_dropwhileneg_absval_takewhilepos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_dropwhileneg_absval_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_absval_takewhilepos([]) == []\nassert op_dropwhileneg_absval_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_absval_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_absval_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_absval_takewhilepos([10]) == [10]\nassert op_dropwhileneg_absval_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_absval_takewhilepos([-7, 12, -7]) == [12, 7]"}
{"id": "op_dropfirst_last3_beforezero", "entry_point": "op_dropfirst_last3_beforezero", "primitives": ["dropfirst", "last3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the last three, then keep everything before the first zero.", "solution": "def op_dropfirst_last3_beforezero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropfirst_last3_beforezero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_last3_beforezero([]) == []\nassert op_dropfirst_last3_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_last3_beforezero([5, 5, 5]) == [5, 5]\nassert op_dropfirst_last3_beforezero([3, 1, 2]) == [1, 2]\nassert op_dropfirst_last3_beforezero([10]) == []\nassert op_dropfirst_last3_beforezero([2, 4, 6]) == [4, 6]\nassert op_dropfirst_last3_beforezero([-7, 12, -7]) == [12, -7]"}
{"id": "op_clamp10_dropwhileneg_dropzeros", "entry_point": "op_clamp10_dropwhileneg_dropzeros", "primitives": ["clamp10", "dropwhileneg", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then drop the zeros.", "solution": "def op_clamp10_dropwhileneg_dropzeros(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_clamp10_dropwhileneg_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropwhileneg_dropzeros([]) == []\nassert op_clamp10_dropwhileneg_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_dropwhileneg_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropwhileneg_dropzeros([10]) == [10]\nassert op_clamp10_dropwhileneg_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg_dropzeros([-7, 12, -7]) == [10, -7]"}
{"id": "op_beforezero_sortabs_oremptyzero", "entry_point": "op_beforezero_sortabs_oremptyzero", "primitives": ["beforezero", "sortabs", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_beforezero_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_beforezero_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sortabs_oremptyzero([]) == [0]\nassert op_beforezero_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortabs_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortabs_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sortabs_oremptyzero([10]) == [10]\nassert op_beforezero_sortabs_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sortabs_oremptyzero([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_rev_double_uniq", "entry_point": "op_rev_double_uniq", "primitives": ["rev", "double", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then drop duplicates keeping first occurrence.", "solution": "def op_rev_double_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_double_uniq([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_uniq([]) == []\nassert op_rev_double_uniq([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_double_uniq([5, 5, 5]) == [10]\nassert op_rev_double_uniq([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_uniq([10]) == [20]\nassert op_rev_double_uniq([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_pos_odds_trimends", "entry_point": "op_pos_odds_trimends", "primitives": ["pos", "odds", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_pos_odds_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_pos_odds_trimends([1, 2, 3, 4]) == []\nassert op_pos_odds_trimends([]) == []\nassert op_pos_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_pos_odds_trimends([5, 5, 5]) == [5]\nassert op_pos_odds_trimends([3, 1, 2]) == []\nassert op_pos_odds_trimends([10]) == []\nassert op_pos_odds_trimends([2, 4, 6]) == []\nassert op_pos_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_evens_sortabs", "entry_point": "op_sorta_evens_sortabs", "primitives": ["sorta", "evens", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the even numbers, then sort by absolute value.", "solution": "def op_sorta_evens_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_evens_sortabs([]) == []\nassert op_sorta_evens_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sorta_evens_sortabs([5, 5, 5]) == []\nassert op_sorta_evens_sortabs([3, 1, 2]) == [2]\nassert op_sorta_evens_sortabs([10]) == [10]\nassert op_sorta_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_pos_clamp10", "entry_point": "op_beforezero_pos_clamp10", "primitives": ["beforezero", "pos", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then cap each value at 10.", "solution": "def op_beforezero_pos_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_pos_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_pos_clamp10([]) == []\nassert op_beforezero_pos_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_pos_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_pos_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_pos_clamp10([10]) == [10]\nassert op_beforezero_pos_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_pos_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_pos_uniq_dropzeros", "entry_point": "op_pos_uniq_dropzeros", "primitives": ["pos", "uniq", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_pos_uniq_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_pos_uniq_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_uniq_dropzeros([]) == []\nassert op_pos_uniq_dropzeros([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_uniq_dropzeros([5, 5, 5]) == [5]\nassert op_pos_uniq_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_pos_uniq_dropzeros([10]) == [10]\nassert op_pos_uniq_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_pos_uniq_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_ages_dropzeros_gt5", "entry_point": "op_ages_dropzeros_gt5", "primitives": ["ages", "dropzeros", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the zeros, then keep values greater than five.", "solution": "def op_ages_dropzeros_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_dropzeros_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_dropzeros_gt5([]) == []\nassert op_ages_dropzeros_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_dropzeros_gt5([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_square_evens_first3", "entry_point": "op_square_evens_first3", "primitives": ["square", "evens", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then keep only the first three.", "solution": "def op_square_evens_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_square_evens_first3([1, 2, 3, 4]) == [4, 16]\nassert op_square_evens_first3([]) == []\nassert op_square_evens_first3([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_square_evens_first3([5, 5, 5]) == []\nassert op_square_evens_first3([3, 1, 2]) == [4]\nassert op_square_evens_first3([10]) == [100]\nassert op_square_evens_first3([2, 4, 6]) == [4, 16, 36]\nassert op_square_evens_first3([-7, 12, -7]) == [144]"}
{"id": "op_sortd_pos_gt5", "entry_point": "op_sortd_pos_gt5", "primitives": ["sortd", "pos", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then keep values greater than five.", "solution": "def op_sortd_pos_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_pos_gt5([1, 2, 3, 4]) == []\nassert op_sortd_pos_gt5([]) == []\nassert op_sortd_pos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortd_pos_gt5([5, 5, 5]) == []\nassert op_sortd_pos_gt5([3, 1, 2]) == []\nassert op_sortd_pos_gt5([10]) == [10]\nassert op_sortd_pos_gt5([2, 4, 6]) == [6]\nassert op_sortd_pos_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_odds_clamp10", "entry_point": "op_dropzeros_odds_clamp10", "primitives": ["dropzeros", "odds", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the odd numbers, then cap each value at 10.", "solution": "def op_dropzeros_odds_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dropzeros_odds_clamp10([1, 2, 3, 4]) == [1, 3]\nassert op_dropzeros_odds_clamp10([]) == []\nassert op_dropzeros_odds_clamp10([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropzeros_odds_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_odds_clamp10([3, 1, 2]) == [3, 1]\nassert op_dropzeros_odds_clamp10([10]) == []\nassert op_dropzeros_odds_clamp10([2, 4, 6]) == []\nassert op_dropzeros_odds_clamp10([-7, 12, -7]) == [-7, -7]"}
{"id": "op_neg_uniq_counteven", "entry_point": "op_neg_uniq_counteven", "primitives": ["neg", "uniq", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_neg_uniq_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_neg_uniq_counteven([1, 2, 3, 4]) == 0\nassert op_neg_uniq_counteven([]) == 0\nassert op_neg_uniq_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_neg_uniq_counteven([5, 5, 5]) == 0\nassert op_neg_uniq_counteven([3, 1, 2]) == 0\nassert op_neg_uniq_counteven([10]) == 0\nassert op_neg_uniq_counteven([2, 4, 6]) == 0\nassert op_neg_uniq_counteven([-7, 12, -7]) == 0"}
{"id": "op_double_dropzeros_max", "entry_point": "op_double_dropzeros_max", "primitives": ["double", "dropzeros", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then return the maximum (0 if empty).", "solution": "def op_double_dropzeros_max(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return max(r) if r else 0", "tests": "assert op_double_dropzeros_max([1, 2, 3, 4]) == 8\nassert op_double_dropzeros_max([]) == 0\nassert op_double_dropzeros_max([-2, -1, 0, 1, 2]) == 4\nassert op_double_dropzeros_max([5, 5, 5]) == 10\nassert op_double_dropzeros_max([3, 1, 2]) == 6\nassert op_double_dropzeros_max([10]) == 20\nassert op_double_dropzeros_max([2, 4, 6]) == 12\nassert op_double_dropzeros_max([-7, 12, -7]) == 24"}
{"id": "op_negate_dec_double", "entry_point": "op_negate_dec_double", "primitives": ["negate", "dec", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then double each.", "solution": "def op_negate_dec_double(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_negate_dec_double([1, 2, 3, 4]) == [-4, -6, -8, -10]\nassert op_negate_dec_double([]) == []\nassert op_negate_dec_double([-2, -1, 0, 1, 2]) == [2, 0, -2, -4, -6]\nassert op_negate_dec_double([5, 5, 5]) == [-12, -12, -12]\nassert op_negate_dec_double([3, 1, 2]) == [-8, -4, -6]\nassert op_negate_dec_double([10]) == [-22]\nassert op_negate_dec_double([2, 4, 6]) == [-6, -10, -14]\nassert op_negate_dec_double([-7, 12, -7]) == [12, -26, 12]"}
{"id": "op_absval_negate_firsteven", "entry_point": "op_absval_negate_firsteven", "primitives": ["absval", "negate", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then negate each, then return the first even value (0 if none).", "solution": "def op_absval_negate_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_negate_firsteven([1, 2, 3, 4]) == -2\nassert op_absval_negate_firsteven([]) == 0\nassert op_absval_negate_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_absval_negate_firsteven([5, 5, 5]) == 0\nassert op_absval_negate_firsteven([3, 1, 2]) == -2\nassert op_absval_negate_firsteven([10]) == -10\nassert op_absval_negate_firsteven([2, 4, 6]) == -2\nassert op_absval_negate_firsteven([-7, 12, -7]) == -12"}
{"id": "op_first3_trimends_padto3", "entry_point": "op_first3_trimends_padto3", "primitives": ["first3", "trimends", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_first3_trimends_padto3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_first3_trimends_padto3([1, 2, 3, 4]) == [2, 0, 0]\nassert op_first3_trimends_padto3([]) == [0, 0, 0]\nassert op_first3_trimends_padto3([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_first3_trimends_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_first3_trimends_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_first3_trimends_padto3([10]) == [0, 0, 0]\nassert op_first3_trimends_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_first3_trimends_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_dropwhileneg_square_beforezero", "entry_point": "op_dropwhileneg_square_beforezero", "primitives": ["dropwhileneg", "square", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then keep everything before the first zero.", "solution": "def op_dropwhileneg_square_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_square_beforezero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_dropwhileneg_square_beforezero([]) == []\nassert op_dropwhileneg_square_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_square_beforezero([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_square_beforezero([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_square_beforezero([10]) == [100]\nassert op_dropwhileneg_square_beforezero([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_square_beforezero([-7, 12, -7]) == [144, 49]"}
{"id": "op_evens_neg_min", "entry_point": "op_evens_neg_min", "primitives": ["evens", "neg", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_evens_neg_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_evens_neg_min([1, 2, 3, 4]) == 0\nassert op_evens_neg_min([]) == 0\nassert op_evens_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_evens_neg_min([5, 5, 5]) == 0\nassert op_evens_neg_min([3, 1, 2]) == 0\nassert op_evens_neg_min([10]) == 0\nassert op_evens_neg_min([2, 4, 6]) == 0\nassert op_evens_neg_min([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_negate_prod", "entry_point": "op_oremptyzero_negate_prod", "primitives": ["oremptyzero", "negate", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then return their product.", "solution": "def op_oremptyzero_negate_prod(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_oremptyzero_negate_prod([1, 2, 3, 4]) == 24\nassert op_oremptyzero_negate_prod([]) == 0\nassert op_oremptyzero_negate_prod([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_negate_prod([5, 5, 5]) == -125\nassert op_oremptyzero_negate_prod([3, 1, 2]) == -6\nassert op_oremptyzero_negate_prod([10]) == -10\nassert op_oremptyzero_negate_prod([2, 4, 6]) == -48\nassert op_oremptyzero_negate_prod([-7, 12, -7]) == -588"}
{"id": "op_uniq_pos_oremptyzero", "entry_point": "op_uniq_pos_oremptyzero", "primitives": ["uniq", "pos", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_uniq_pos_oremptyzero(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_uniq_pos_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_uniq_pos_oremptyzero([]) == [0]\nassert op_uniq_pos_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_uniq_pos_oremptyzero([5, 5, 5]) == [5]\nassert op_uniq_pos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_pos_oremptyzero([10]) == [10]\nassert op_uniq_pos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_pos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_odds_absval_inc", "entry_point": "op_odds_absval_inc", "primitives": ["odds", "absval", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then add one to each.", "solution": "def op_odds_absval_inc(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_odds_absval_inc([1, 2, 3, 4]) == [2, 4]\nassert op_odds_absval_inc([]) == []\nassert op_odds_absval_inc([-2, -1, 0, 1, 2]) == [2, 2]\nassert op_odds_absval_inc([5, 5, 5]) == [6, 6, 6]\nassert op_odds_absval_inc([3, 1, 2]) == [4, 2]\nassert op_odds_absval_inc([10]) == []\nassert op_odds_absval_inc([2, 4, 6]) == []\nassert op_odds_absval_inc([-7, 12, -7]) == [8, 8]"}
{"id": "op_div3_oremptyzero_min", "entry_point": "op_div3_oremptyzero_min", "primitives": ["div3", "oremptyzero", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_div3_oremptyzero_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_div3_oremptyzero_min([1, 2, 3, 4]) == 3\nassert op_div3_oremptyzero_min([]) == 0\nassert op_div3_oremptyzero_min([-2, -1, 0, 1, 2]) == 0\nassert op_div3_oremptyzero_min([5, 5, 5]) == 0\nassert op_div3_oremptyzero_min([3, 1, 2]) == 3\nassert op_div3_oremptyzero_min([10]) == 0\nassert op_div3_oremptyzero_min([2, 4, 6]) == 6\nassert op_div3_oremptyzero_min([-7, 12, -7]) == 12"}
{"id": "op_inc_gt5_prod", "entry_point": "op_inc_gt5_prod", "primitives": ["inc", "gt5", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then return their product.", "solution": "def op_inc_gt5_prod(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return __import__('math').prod(r)", "tests": "assert op_inc_gt5_prod([1, 2, 3, 4]) == 1\nassert op_inc_gt5_prod([]) == 1\nassert op_inc_gt5_prod([-2, -1, 0, 1, 2]) == 1\nassert op_inc_gt5_prod([5, 5, 5]) == 216\nassert op_inc_gt5_prod([3, 1, 2]) == 1\nassert op_inc_gt5_prod([10]) == 11\nassert op_inc_gt5_prod([2, 4, 6]) == 7\nassert op_inc_gt5_prod([-7, 12, -7]) == 13"}
{"id": "op_prefixup_upper_maxlen", "entry_point": "op_prefixup_upper_maxlen", "primitives": ["prefixup", "upper", "maxlen"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then uppercase each string, then return the length of the longest string (0 if none).", "solution": "def op_prefixup_upper_maxlen(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_prefixup_upper_maxlen(['Hello', 'world']) == 6\nassert op_prefixup_upper_maxlen([]) == 0\nassert op_prefixup_upper_maxlen(['  a ', '', 'BC', 'bc']) == 5\nassert op_prefixup_upper_maxlen(['one', 'one', 'Two']) == 4\nassert op_prefixup_upper_maxlen(['x']) == 2\nassert op_prefixup_upper_maxlen(['abc', 'de', '']) == 4"}
{"id": "op_sorta_dropfirst_trimends", "entry_point": "op_sorta_dropfirst_trimends", "primitives": ["sorta", "dropfirst", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the first element, then drop the first and last elements.", "solution": "def op_sorta_dropfirst_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_dropfirst_trimends([1, 2, 3, 4]) == [3]\nassert op_sorta_dropfirst_trimends([]) == []\nassert op_sorta_dropfirst_trimends([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_sorta_dropfirst_trimends([5, 5, 5]) == []\nassert op_sorta_dropfirst_trimends([3, 1, 2]) == []\nassert op_sorta_dropfirst_trimends([10]) == []\nassert op_sorta_dropfirst_trimends([2, 4, 6]) == []\nassert op_sorta_dropfirst_trimends([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_absval_inc", "entry_point": "op_takewhilepos_absval_inc", "primitives": ["takewhilepos", "absval", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then add one to each.", "solution": "def op_takewhilepos_absval_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_absval_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_takewhilepos_absval_inc([]) == []\nassert op_takewhilepos_absval_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_absval_inc([5, 5, 5]) == [6, 6, 6]\nassert op_takewhilepos_absval_inc([3, 1, 2]) == [4, 2, 3]\nassert op_takewhilepos_absval_inc([10]) == [11]\nassert op_takewhilepos_absval_inc([2, 4, 6]) == [3, 5, 7]\nassert op_takewhilepos_absval_inc([-7, 12, -7]) == []"}
{"id": "op_nonempty_firstchar_longest", "entry_point": "op_nonempty_firstchar_longest", "primitives": ["nonempty", "firstchar", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_nonempty_firstchar_longest(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_nonempty_firstchar_longest(['Hello', 'world']) == 'H'\nassert op_nonempty_firstchar_longest([]) == ''\nassert op_nonempty_firstchar_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_nonempty_firstchar_longest(['one', 'one', 'Two']) == 'o'\nassert op_nonempty_firstchar_longest(['x']) == 'x'\nassert op_nonempty_firstchar_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_last3_clamp10_len", "entry_point": "op_last3_clamp10_len", "primitives": ["last3", "clamp10", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then return how many remain.", "solution": "def op_last3_clamp10_len(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    return len(r)", "tests": "assert op_last3_clamp10_len([1, 2, 3, 4]) == 3\nassert op_last3_clamp10_len([]) == 0\nassert op_last3_clamp10_len([-2, -1, 0, 1, 2]) == 3\nassert op_last3_clamp10_len([5, 5, 5]) == 3\nassert op_last3_clamp10_len([3, 1, 2]) == 3\nassert op_last3_clamp10_len([10]) == 1\nassert op_last3_clamp10_len([2, 4, 6]) == 3\nassert op_last3_clamp10_len([-7, 12, -7]) == 3"}
{"id": "op_clamp10_padto3_trimends", "entry_point": "op_clamp10_padto3_trimends", "primitives": ["clamp10", "padto3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then drop the first and last elements.", "solution": "def op_clamp10_padto3_trimends(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:-1]\n    return r", "tests": "assert op_clamp10_padto3_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_clamp10_padto3_trimends([]) == [0]\nassert op_clamp10_padto3_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_clamp10_padto3_trimends([5, 5, 5]) == [5]\nassert op_clamp10_padto3_trimends([3, 1, 2]) == [1]\nassert op_clamp10_padto3_trimends([10]) == [0]\nassert op_clamp10_padto3_trimends([2, 4, 6]) == [4]\nassert op_clamp10_padto3_trimends([-7, 12, -7]) == [10]"}
{"id": "op_rev_double_padto3", "entry_point": "op_rev_double_padto3", "primitives": ["rev", "double", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then pad with zeros to at least three elements.", "solution": "def op_rev_double_padto3(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_rev_double_padto3([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_rev_double_padto3([]) == [0, 0, 0]\nassert op_rev_double_padto3([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_rev_double_padto3([5, 5, 5]) == [10, 10, 10]\nassert op_rev_double_padto3([3, 1, 2]) == [4, 2, 6]\nassert op_rev_double_padto3([10]) == [20, 0, 0]\nassert op_rev_double_padto3([2, 4, 6]) == [12, 8, 4]\nassert op_rev_double_padto3([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_takewhilepos_dropfirst_firsteven", "entry_point": "op_takewhilepos_dropfirst_firsteven", "primitives": ["takewhilepos", "dropfirst", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first element, then return the first even value (0 if none).", "solution": "def op_takewhilepos_dropfirst_firsteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_takewhilepos_dropfirst_firsteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_dropfirst_firsteven([]) == 0\nassert op_takewhilepos_dropfirst_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_dropfirst_firsteven([5, 5, 5]) == 0\nassert op_takewhilepos_dropfirst_firsteven([3, 1, 2]) == 2\nassert op_takewhilepos_dropfirst_firsteven([10]) == 0\nassert op_takewhilepos_dropfirst_firsteven([2, 4, 6]) == 4\nassert op_takewhilepos_dropfirst_firsteven([-7, 12, -7]) == 0"}
{"id": "op_dropwhileneg_double_div3", "entry_point": "op_dropwhileneg_double_div3", "primitives": ["dropwhileneg", "double", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then keep multiples of three.", "solution": "def op_dropwhileneg_double_div3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_dropwhileneg_double_div3([1, 2, 3, 4]) == [6]\nassert op_dropwhileneg_double_div3([]) == []\nassert op_dropwhileneg_double_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_dropwhileneg_double_div3([5, 5, 5]) == []\nassert op_dropwhileneg_double_div3([3, 1, 2]) == [6]\nassert op_dropwhileneg_double_div3([10]) == []\nassert op_dropwhileneg_double_div3([2, 4, 6]) == [12]\nassert op_dropwhileneg_double_div3([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_negate_inc", "entry_point": "op_takewhilepos_negate_inc", "primitives": ["takewhilepos", "negate", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then add one to each.", "solution": "def op_takewhilepos_negate_inc(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_negate_inc([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_takewhilepos_negate_inc([]) == []\nassert op_takewhilepos_negate_inc([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_inc([5, 5, 5]) == [-4, -4, -4]\nassert op_takewhilepos_negate_inc([3, 1, 2]) == [-2, 0, -1]\nassert op_takewhilepos_negate_inc([10]) == [-9]\nassert op_takewhilepos_negate_inc([2, 4, 6]) == [-1, -3, -5]\nassert op_takewhilepos_negate_inc([-7, 12, -7]) == []"}
{"id": "op_last3_inc_pos", "entry_point": "op_last3_inc_pos", "primitives": ["last3", "inc", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then add one to each, then keep the positive numbers.", "solution": "def op_last3_inc_pos(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_last3_inc_pos([1, 2, 3, 4]) == [3, 4, 5]\nassert op_last3_inc_pos([]) == []\nassert op_last3_inc_pos([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_last3_inc_pos([5, 5, 5]) == [6, 6, 6]\nassert op_last3_inc_pos([3, 1, 2]) == [4, 2, 3]\nassert op_last3_inc_pos([10]) == [11]\nassert op_last3_inc_pos([2, 4, 6]) == [3, 5, 7]\nassert op_last3_inc_pos([-7, 12, -7]) == [13]"}
{"id": "op_double_odds_prod", "entry_point": "op_double_odds_prod", "primitives": ["double", "odds", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep the odd numbers, then return their product.", "solution": "def op_double_odds_prod(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return __import__('math').prod(r)", "tests": "assert op_double_odds_prod([1, 2, 3, 4]) == 1\nassert op_double_odds_prod([]) == 1\nassert op_double_odds_prod([-2, -1, 0, 1, 2]) == 1\nassert op_double_odds_prod([5, 5, 5]) == 1\nassert op_double_odds_prod([3, 1, 2]) == 1\nassert op_double_odds_prod([10]) == 1\nassert op_double_odds_prod([2, 4, 6]) == 1\nassert op_double_odds_prod([-7, 12, -7]) == 1"}
{"id": "op_sorta_square_haszero", "entry_point": "op_sorta_square_haszero", "primitives": ["sorta", "square", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each, then return whether the list contains a zero.", "solution": "def op_sorta_square_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_sorta_square_haszero([1, 2, 3, 4]) == False\nassert op_sorta_square_haszero([]) == False\nassert op_sorta_square_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_square_haszero([5, 5, 5]) == False\nassert op_sorta_square_haszero([3, 1, 2]) == False\nassert op_sorta_square_haszero([10]) == False\nassert op_sorta_square_haszero([2, 4, 6]) == False\nassert op_sorta_square_haszero([-7, 12, -7]) == False"}
{"id": "op_inc_dec_uniq", "entry_point": "op_inc_dec_uniq", "primitives": ["inc", "dec", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then drop duplicates keeping first occurrence.", "solution": "def op_inc_dec_uniq(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_inc_dec_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_inc_dec_uniq([]) == []\nassert op_inc_dec_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_inc_dec_uniq([5, 5, 5]) == [5]\nassert op_inc_dec_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_inc_dec_uniq([10]) == [10]\nassert op_inc_dec_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_inc_dec_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_beforezero_neg_max", "entry_point": "op_beforezero_neg_max", "primitives": ["beforezero", "neg", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_beforezero_neg_max(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_beforezero_neg_max([1, 2, 3, 4]) == 0\nassert op_beforezero_neg_max([]) == 0\nassert op_beforezero_neg_max([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_neg_max([5, 5, 5]) == 0\nassert op_beforezero_neg_max([3, 1, 2]) == 0\nassert op_beforezero_neg_max([10]) == 0\nassert op_beforezero_neg_max([2, 4, 6]) == 0\nassert op_beforezero_neg_max([-7, 12, -7]) == -7"}
{"id": "op_dropzeros_evens_sortabs", "entry_point": "op_dropzeros_evens_sortabs", "primitives": ["dropzeros", "evens", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then sort by absolute value.", "solution": "def op_dropzeros_evens_sortabs(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dropzeros_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_dropzeros_evens_sortabs([]) == []\nassert op_dropzeros_evens_sortabs([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_dropzeros_evens_sortabs([5, 5, 5]) == []\nassert op_dropzeros_evens_sortabs([3, 1, 2]) == [2]\nassert op_dropzeros_evens_sortabs([10]) == [10]\nassert op_dropzeros_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_rev_sortd_trimends", "entry_point": "op_rev_sortd_trimends", "primitives": ["rev", "sortd", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then drop the first and last elements.", "solution": "def op_rev_sortd_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_sortd_trimends([1, 2, 3, 4]) == [3, 2]\nassert op_rev_sortd_trimends([]) == []\nassert op_rev_sortd_trimends([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_rev_sortd_trimends([5, 5, 5]) == [5]\nassert op_rev_sortd_trimends([3, 1, 2]) == [2]\nassert op_rev_sortd_trimends([10]) == []\nassert op_rev_sortd_trimends([2, 4, 6]) == [4]\nassert op_rev_sortd_trimends([-7, 12, -7]) == [-7]"}
{"id": "op_uniq_odds_len", "entry_point": "op_uniq_odds_len", "primitives": ["uniq", "odds", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep the odd numbers, then return how many remain.", "solution": "def op_uniq_odds_len(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_uniq_odds_len([1, 2, 3, 4]) == 2\nassert op_uniq_odds_len([]) == 0\nassert op_uniq_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_odds_len([5, 5, 5]) == 1\nassert op_uniq_odds_len([3, 1, 2]) == 2\nassert op_uniq_odds_len([10]) == 0\nassert op_uniq_odds_len([2, 4, 6]) == 0\nassert op_uniq_odds_len([-7, 12, -7]) == 1"}
{"id": "op_strip_firstchar_lens", "entry_point": "op_strip_firstchar_lens", "primitives": ["strip", "firstchar", "lens"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then keep the first character of each (dropping empties), then return the total number of characters.", "solution": "def op_strip_firstchar_lens(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    return sum(len(s) for s in r)", "tests": "assert op_strip_firstchar_lens(['Hello', 'world']) == 2\nassert op_strip_firstchar_lens([]) == 0\nassert op_strip_firstchar_lens(['  a ', '', 'BC', 'bc']) == 3\nassert op_strip_firstchar_lens(['one', 'one', 'Two']) == 3\nassert op_strip_firstchar_lens(['x']) == 1\nassert op_strip_firstchar_lens(['abc', 'de', '']) == 2"}
{"id": "op_first3_dropzeros_negate", "entry_point": "op_first3_dropzeros_negate", "primitives": ["first3", "dropzeros", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the zeros, then negate each.", "solution": "def op_first3_dropzeros_negate(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_first3_dropzeros_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_first3_dropzeros_negate([]) == []\nassert op_first3_dropzeros_negate([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_first3_dropzeros_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_first3_dropzeros_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_first3_dropzeros_negate([10]) == [-10]\nassert op_first3_dropzeros_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_first3_dropzeros_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_first3_dec_add10", "entry_point": "op_first3_dec_add10", "primitives": ["first3", "dec", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then add ten to each.", "solution": "def op_first3_dec_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_dec_add10([1, 2, 3, 4]) == [10, 11, 12]\nassert op_first3_dec_add10([]) == []\nassert op_first3_dec_add10([-2, -1, 0, 1, 2]) == [7, 8, 9]\nassert op_first3_dec_add10([5, 5, 5]) == [14, 14, 14]\nassert op_first3_dec_add10([3, 1, 2]) == [12, 10, 11]\nassert op_first3_dec_add10([10]) == [19]\nassert op_first3_dec_add10([2, 4, 6]) == [11, 13, 15]\nassert op_first3_dec_add10([-7, 12, -7]) == [2, 21, 2]"}
{"id": "op_div3_beforezero_add10", "entry_point": "op_div3_beforezero_add10", "primitives": ["div3", "beforezero", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then add ten to each.", "solution": "def op_div3_beforezero_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_div3_beforezero_add10([1, 2, 3, 4]) == [13]\nassert op_div3_beforezero_add10([]) == []\nassert op_div3_beforezero_add10([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_add10([5, 5, 5]) == []\nassert op_div3_beforezero_add10([3, 1, 2]) == [13]\nassert op_div3_beforezero_add10([10]) == []\nassert op_div3_beforezero_add10([2, 4, 6]) == [16]\nassert op_div3_beforezero_add10([-7, 12, -7]) == [22]"}
{"id": "op_oremptyzero_dec_len", "entry_point": "op_oremptyzero_dec_len", "primitives": ["oremptyzero", "dec", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then subtract one from each, then return how many remain.", "solution": "def op_oremptyzero_dec_len(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return len(r)", "tests": "assert op_oremptyzero_dec_len([1, 2, 3, 4]) == 4\nassert op_oremptyzero_dec_len([]) == 1\nassert op_oremptyzero_dec_len([-2, -1, 0, 1, 2]) == 5\nassert op_oremptyzero_dec_len([5, 5, 5]) == 3\nassert op_oremptyzero_dec_len([3, 1, 2]) == 3\nassert op_oremptyzero_dec_len([10]) == 1\nassert op_oremptyzero_dec_len([2, 4, 6]) == 3\nassert op_oremptyzero_dec_len([-7, 12, -7]) == 3"}
{"id": "op_pos_gt5_rev", "entry_point": "op_pos_gt5_rev", "primitives": ["pos", "gt5", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep values greater than five, then reverse the order.", "solution": "def op_pos_gt5_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_gt5_rev([1, 2, 3, 4]) == []\nassert op_pos_gt5_rev([]) == []\nassert op_pos_gt5_rev([-2, -1, 0, 1, 2]) == []\nassert op_pos_gt5_rev([5, 5, 5]) == []\nassert op_pos_gt5_rev([3, 1, 2]) == []\nassert op_pos_gt5_rev([10]) == [10]\nassert op_pos_gt5_rev([2, 4, 6]) == [6]\nassert op_pos_gt5_rev([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_sortabs_double", "entry_point": "op_dropzeros_sortabs_double", "primitives": ["dropzeros", "sortabs", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then double each.", "solution": "def op_dropzeros_sortabs_double(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_dropzeros_sortabs_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_sortabs_double([]) == []\nassert op_dropzeros_sortabs_double([-2, -1, 0, 1, 2]) == [-2, 2, -4, 4]\nassert op_dropzeros_sortabs_double([5, 5, 5]) == [10, 10, 10]\nassert op_dropzeros_sortabs_double([3, 1, 2]) == [2, 4, 6]\nassert op_dropzeros_sortabs_double([10]) == [20]\nassert op_dropzeros_sortabs_double([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_sortabs_double([-7, 12, -7]) == [-14, -14, 24]"}
{"id": "op_first3_clamp10_firsteven", "entry_point": "op_first3_clamp10_firsteven", "primitives": ["first3", "clamp10", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cap each value at 10, then return the first even value (0 if none).", "solution": "def op_first3_clamp10_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [min(x, 10) for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_clamp10_firsteven([1, 2, 3, 4]) == 2\nassert op_first3_clamp10_firsteven([]) == 0\nassert op_first3_clamp10_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_first3_clamp10_firsteven([5, 5, 5]) == 0\nassert op_first3_clamp10_firsteven([3, 1, 2]) == 2\nassert op_first3_clamp10_firsteven([10]) == 10\nassert op_first3_clamp10_firsteven([2, 4, 6]) == 2\nassert op_first3_clamp10_firsteven([-7, 12, -7]) == 10"}
{"id": "op_strip_sortlen_anyempty", "entry_point": "op_strip_sortlen_anyempty", "primitives": ["strip", "sortlen", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first, then return whether any string is empty.", "solution": "def op_strip_sortlen_anyempty(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return any(s == '' for s in r)", "tests": "assert op_strip_sortlen_anyempty(['Hello', 'world']) == False\nassert op_strip_sortlen_anyempty([]) == False\nassert op_strip_sortlen_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_strip_sortlen_anyempty(['one', 'one', 'Two']) == False\nassert op_strip_sortlen_anyempty(['x']) == False\nassert op_strip_sortlen_anyempty(['abc', 'de', '']) == True"}
{"id": "op_uniq_negate_div3", "entry_point": "op_uniq_negate_div3", "primitives": ["uniq", "negate", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then negate each, then keep multiples of three.", "solution": "def op_uniq_negate_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_negate_div3([1, 2, 3, 4]) == [-3]\nassert op_uniq_negate_div3([]) == []\nassert op_uniq_negate_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_negate_div3([5, 5, 5]) == []\nassert op_uniq_negate_div3([3, 1, 2]) == [-3]\nassert op_uniq_negate_div3([10]) == []\nassert op_uniq_negate_div3([2, 4, 6]) == [-6]\nassert op_uniq_negate_div3([-7, 12, -7]) == [-12]"}
{"id": "op_nonempty_dropshort_prefixup", "entry_point": "op_nonempty_dropshort_prefixup", "primitives": ["nonempty", "dropshort", "prefixup"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop strings shorter than three characters, then prefix each with a hash.", "solution": "def op_nonempty_dropshort_prefixup(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_nonempty_dropshort_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_nonempty_dropshort_prefixup([]) == []\nassert op_nonempty_dropshort_prefixup(['  a ', '', 'BC', 'bc']) == ['#  a ']\nassert op_nonempty_dropshort_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_nonempty_dropshort_prefixup(['x']) == []\nassert op_nonempty_dropshort_prefixup(['abc', 'de', '']) == ['#abc']"}
{"id": "op_padto3_beforezero_firsteven", "entry_point": "op_padto3_beforezero_firsteven", "primitives": ["padto3", "beforezero", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then return the first even value (0 if none).", "solution": "def op_padto3_beforezero_firsteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_padto3_beforezero_firsteven([1, 2, 3, 4]) == 2\nassert op_padto3_beforezero_firsteven([]) == 0\nassert op_padto3_beforezero_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_beforezero_firsteven([5, 5, 5]) == 0\nassert op_padto3_beforezero_firsteven([3, 1, 2]) == 2\nassert op_padto3_beforezero_firsteven([10]) == 10\nassert op_padto3_beforezero_firsteven([2, 4, 6]) == 2\nassert op_padto3_beforezero_firsteven([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_sortabs_first3", "entry_point": "op_dropfirst_sortabs_first3", "primitives": ["dropfirst", "sortabs", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort by absolute value, then keep only the first three.", "solution": "def op_dropfirst_sortabs_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, key=abs)\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_sortabs_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_sortabs_first3([]) == []\nassert op_dropfirst_sortabs_first3([-2, -1, 0, 1, 2]) == [0, -1, 1]\nassert op_dropfirst_sortabs_first3([5, 5, 5]) == [5, 5]\nassert op_dropfirst_sortabs_first3([3, 1, 2]) == [1, 2]\nassert op_dropfirst_sortabs_first3([10]) == []\nassert op_dropfirst_sortabs_first3([2, 4, 6]) == [4, 6]\nassert op_dropfirst_sortabs_first3([-7, 12, -7]) == [-7, 12]"}
{"id": "op_absval_div3_len", "entry_point": "op_absval_div3_len", "primitives": ["absval", "div3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep multiples of three, then return how many remain.", "solution": "def op_absval_div3_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return len(r)", "tests": "assert op_absval_div3_len([1, 2, 3, 4]) == 1\nassert op_absval_div3_len([]) == 0\nassert op_absval_div3_len([-2, -1, 0, 1, 2]) == 1\nassert op_absval_div3_len([5, 5, 5]) == 0\nassert op_absval_div3_len([3, 1, 2]) == 1\nassert op_absval_div3_len([10]) == 0\nassert op_absval_div3_len([2, 4, 6]) == 1\nassert op_absval_div3_len([-7, 12, -7]) == 1"}
{"id": "op_beforezero_oremptyzero_dropwhileneg", "entry_point": "op_beforezero_oremptyzero_dropwhileneg", "primitives": ["beforezero", "oremptyzero", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then if empty, use a single zero, then drop the leading negative values.", "solution": "def op_beforezero_oremptyzero_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_oremptyzero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_oremptyzero_dropwhileneg([]) == [0]\nassert op_beforezero_oremptyzero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_oremptyzero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_oremptyzero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_oremptyzero_dropwhileneg([10]) == [10]\nassert op_beforezero_oremptyzero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_oremptyzero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_dec_first3_min", "entry_point": "op_dec_first3_min", "primitives": ["dec", "first3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_dec_first3_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_dec_first3_min([1, 2, 3, 4]) == 0\nassert op_dec_first3_min([]) == 0\nassert op_dec_first3_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_first3_min([5, 5, 5]) == 4\nassert op_dec_first3_min([3, 1, 2]) == 0\nassert op_dec_first3_min([10]) == 9\nassert op_dec_first3_min([2, 4, 6]) == 1\nassert op_dec_first3_min([-7, 12, -7]) == -8"}
{"id": "op_clamp10_oremptyzero_sum", "entry_point": "op_clamp10_oremptyzero_sum", "primitives": ["clamp10", "oremptyzero", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then if empty, use a single zero, then return their sum.", "solution": "def op_clamp10_oremptyzero_sum(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_clamp10_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_clamp10_oremptyzero_sum([]) == 0\nassert op_clamp10_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_oremptyzero_sum([5, 5, 5]) == 15\nassert op_clamp10_oremptyzero_sum([3, 1, 2]) == 6\nassert op_clamp10_oremptyzero_sum([10]) == 10\nassert op_clamp10_oremptyzero_sum([2, 4, 6]) == 12\nassert op_clamp10_oremptyzero_sum([-7, 12, -7]) == -4"}
{"id": "op_negate_double_trimends", "entry_point": "op_negate_double_trimends", "primitives": ["negate", "double", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then drop the first and last elements.", "solution": "def op_negate_double_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_double_trimends([1, 2, 3, 4]) == [-4, -6]\nassert op_negate_double_trimends([]) == []\nassert op_negate_double_trimends([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_negate_double_trimends([5, 5, 5]) == [-10]\nassert op_negate_double_trimends([3, 1, 2]) == [-2]\nassert op_negate_double_trimends([10]) == []\nassert op_negate_double_trimends([2, 4, 6]) == [-8]\nassert op_negate_double_trimends([-7, 12, -7]) == [-24]"}
{"id": "op_sorta_negate_clamp10", "entry_point": "op_sorta_negate_clamp10", "primitives": ["sorta", "negate", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then cap each value at 10.", "solution": "def op_sorta_negate_clamp10(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sorta_negate_clamp10([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sorta_negate_clamp10([]) == []\nassert op_sorta_negate_clamp10([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_sorta_negate_clamp10([5, 5, 5]) == [-5, -5, -5]\nassert op_sorta_negate_clamp10([3, 1, 2]) == [-1, -2, -3]\nassert op_sorta_negate_clamp10([10]) == [-10]\nassert op_sorta_negate_clamp10([2, 4, 6]) == [-2, -4, -6]\nassert op_sorta_negate_clamp10([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_pos_inc_gt5", "entry_point": "op_pos_inc_gt5", "primitives": ["pos", "inc", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then keep values greater than five.", "solution": "def op_pos_inc_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_pos_inc_gt5([1, 2, 3, 4]) == []\nassert op_pos_inc_gt5([]) == []\nassert op_pos_inc_gt5([-2, -1, 0, 1, 2]) == []\nassert op_pos_inc_gt5([5, 5, 5]) == [6, 6, 6]\nassert op_pos_inc_gt5([3, 1, 2]) == []\nassert op_pos_inc_gt5([10]) == [11]\nassert op_pos_inc_gt5([2, 4, 6]) == [7]\nassert op_pos_inc_gt5([-7, 12, -7]) == [13]"}
{"id": "op_beforezero_gt5_firsteven", "entry_point": "op_beforezero_gt5_firsteven", "primitives": ["beforezero", "gt5", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep values greater than five, then return the first even value (0 if none).", "solution": "def op_beforezero_gt5_firsteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_beforezero_gt5_firsteven([1, 2, 3, 4]) == 0\nassert op_beforezero_gt5_firsteven([]) == 0\nassert op_beforezero_gt5_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_gt5_firsteven([5, 5, 5]) == 0\nassert op_beforezero_gt5_firsteven([3, 1, 2]) == 0\nassert op_beforezero_gt5_firsteven([10]) == 10\nassert op_beforezero_gt5_firsteven([2, 4, 6]) == 6\nassert op_beforezero_gt5_firsteven([-7, 12, -7]) == 12"}
{"id": "op_beforezero_last3_evens", "entry_point": "op_beforezero_last3_evens", "primitives": ["beforezero", "last3", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the last three, then keep the even numbers.", "solution": "def op_beforezero_last3_evens(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_beforezero_last3_evens([1, 2, 3, 4]) == [2, 4]\nassert op_beforezero_last3_evens([]) == []\nassert op_beforezero_last3_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_last3_evens([5, 5, 5]) == []\nassert op_beforezero_last3_evens([3, 1, 2]) == [2]\nassert op_beforezero_last3_evens([10]) == [10]\nassert op_beforezero_last3_evens([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_last3_evens([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_clamp10_takewhilepos", "entry_point": "op_oremptyzero_clamp10_takewhilepos", "primitives": ["oremptyzero", "clamp10", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cap each value at 10, then take values while they are positive.", "solution": "def op_oremptyzero_clamp10_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [min(x, 10) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_clamp10_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_clamp10_takewhilepos([]) == []\nassert op_oremptyzero_clamp10_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_clamp10_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_clamp10_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_clamp10_takewhilepos([10]) == [10]\nassert op_oremptyzero_clamp10_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_clamp10_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_absval_beforezero_min", "entry_point": "op_absval_beforezero_min", "primitives": ["absval", "beforezero", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then return the minimum (0 if empty).", "solution": "def op_absval_beforezero_min(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return min(r) if r else 0", "tests": "assert op_absval_beforezero_min([1, 2, 3, 4]) == 1\nassert op_absval_beforezero_min([]) == 0\nassert op_absval_beforezero_min([-2, -1, 0, 1, 2]) == 1\nassert op_absval_beforezero_min([5, 5, 5]) == 5\nassert op_absval_beforezero_min([3, 1, 2]) == 1\nassert op_absval_beforezero_min([10]) == 10\nassert op_absval_beforezero_min([2, 4, 6]) == 2\nassert op_absval_beforezero_min([-7, 12, -7]) == 7"}
{"id": "op_dropwhileneg_negate_alldistinct", "entry_point": "op_dropwhileneg_negate_alldistinct", "primitives": ["dropwhileneg", "negate", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then negate each, then return whether all values are distinct.", "solution": "def op_dropwhileneg_negate_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_negate_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_negate_alldistinct([]) == True\nassert op_dropwhileneg_negate_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_negate_alldistinct([5, 5, 5]) == False\nassert op_dropwhileneg_negate_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_negate_alldistinct([10]) == True\nassert op_dropwhileneg_negate_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_negate_alldistinct([-7, 12, -7]) == True"}
{"id": "op_rev_negate_double", "entry_point": "op_rev_negate_double", "primitives": ["rev", "negate", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then negate each, then double each.", "solution": "def op_rev_negate_double(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_rev_negate_double([1, 2, 3, 4]) == [-8, -6, -4, -2]\nassert op_rev_negate_double([]) == []\nassert op_rev_negate_double([-2, -1, 0, 1, 2]) == [-4, -2, 0, 2, 4]\nassert op_rev_negate_double([5, 5, 5]) == [-10, -10, -10]\nassert op_rev_negate_double([3, 1, 2]) == [-4, -2, -6]\nassert op_rev_negate_double([10]) == [-20]\nassert op_rev_negate_double([2, 4, 6]) == [-12, -8, -4]\nassert op_rev_negate_double([-7, 12, -7]) == [14, -24, 14]"}
{"id": "op_first3_uniq_add10", "entry_point": "op_first3_uniq_add10", "primitives": ["first3", "uniq", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then add ten to each.", "solution": "def op_first3_uniq_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_uniq_add10([1, 2, 3, 4]) == [11, 12, 13]\nassert op_first3_uniq_add10([]) == []\nassert op_first3_uniq_add10([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_first3_uniq_add10([5, 5, 5]) == [15]\nassert op_first3_uniq_add10([3, 1, 2]) == [13, 11, 12]\nassert op_first3_uniq_add10([10]) == [20]\nassert op_first3_uniq_add10([2, 4, 6]) == [12, 14, 16]\nassert op_first3_uniq_add10([-7, 12, -7]) == [3, 22]"}
{"id": "op_inc_dropzeros_issorted", "entry_point": "op_inc_dropzeros_issorted", "primitives": ["inc", "dropzeros", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then return whether the list is sorted ascending.", "solution": "def op_inc_dropzeros_issorted(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r == sorted(r)", "tests": "assert op_inc_dropzeros_issorted([1, 2, 3, 4]) == True\nassert op_inc_dropzeros_issorted([]) == True\nassert op_inc_dropzeros_issorted([-2, -1, 0, 1, 2]) == True\nassert op_inc_dropzeros_issorted([5, 5, 5]) == True\nassert op_inc_dropzeros_issorted([3, 1, 2]) == False\nassert op_inc_dropzeros_issorted([10]) == True\nassert op_inc_dropzeros_issorted([2, 4, 6]) == True\nassert op_inc_dropzeros_issorted([-7, 12, -7]) == False"}
{"id": "op_sortabs_evens_prod", "entry_point": "op_sortabs_evens_prod", "primitives": ["sortabs", "evens", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then return their product.", "solution": "def op_sortabs_evens_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_evens_prod([1, 2, 3, 4]) == 8\nassert op_sortabs_evens_prod([]) == 1\nassert op_sortabs_evens_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_evens_prod([5, 5, 5]) == 1\nassert op_sortabs_evens_prod([3, 1, 2]) == 2\nassert op_sortabs_evens_prod([10]) == 10\nassert op_sortabs_evens_prod([2, 4, 6]) == 48\nassert op_sortabs_evens_prod([-7, 12, -7]) == 12"}
{"id": "op_inc_sorta_absval", "entry_point": "op_inc_sorta_absval", "primitives": ["inc", "sorta", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then take the absolute value of each.", "solution": "def op_inc_sorta_absval(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_inc_sorta_absval([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_sorta_absval([]) == []\nassert op_inc_sorta_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2, 3]\nassert op_inc_sorta_absval([5, 5, 5]) == [6, 6, 6]\nassert op_inc_sorta_absval([3, 1, 2]) == [2, 3, 4]\nassert op_inc_sorta_absval([10]) == [11]\nassert op_inc_sorta_absval([2, 4, 6]) == [3, 5, 7]\nassert op_inc_sorta_absval([-7, 12, -7]) == [6, 6, 13]"}
{"id": "op_evens_oremptyzero_allpos", "entry_point": "op_evens_oremptyzero_allpos", "primitives": ["evens", "oremptyzero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_evens_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_evens_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_evens_oremptyzero_allpos([]) == False\nassert op_evens_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_evens_oremptyzero_allpos([5, 5, 5]) == False\nassert op_evens_oremptyzero_allpos([3, 1, 2]) == True\nassert op_evens_oremptyzero_allpos([10]) == True\nassert op_evens_oremptyzero_allpos([2, 4, 6]) == True\nassert op_evens_oremptyzero_allpos([-7, 12, -7]) == True"}
{"id": "op_trimends_rev_pos", "entry_point": "op_trimends_rev_pos", "primitives": ["trimends", "rev", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then keep the positive numbers.", "solution": "def op_trimends_rev_pos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_trimends_rev_pos([1, 2, 3, 4]) == [3, 2]\nassert op_trimends_rev_pos([]) == []\nassert op_trimends_rev_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_trimends_rev_pos([5, 5, 5]) == [5]\nassert op_trimends_rev_pos([3, 1, 2]) == [1]\nassert op_trimends_rev_pos([10]) == []\nassert op_trimends_rev_pos([2, 4, 6]) == [4]\nassert op_trimends_rev_pos([-7, 12, -7]) == [12]"}
{"id": "op_clamp10_rev_dropwhileneg", "entry_point": "op_clamp10_rev_dropwhileneg", "primitives": ["clamp10", "rev", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then reverse the order, then drop the leading negative values.", "solution": "def op_clamp10_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_rev_dropwhileneg([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_clamp10_rev_dropwhileneg([]) == []\nassert op_clamp10_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_clamp10_rev_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_rev_dropwhileneg([3, 1, 2]) == [2, 1, 3]\nassert op_clamp10_rev_dropwhileneg([10]) == [10]\nassert op_clamp10_rev_dropwhileneg([2, 4, 6]) == [6, 4, 2]\nassert op_clamp10_rev_dropwhileneg([-7, 12, -7]) == [10, -7]"}
{"id": "op_dec_dropwhileneg_add10", "entry_point": "op_dec_dropwhileneg_add10", "primitives": ["dec", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the leading negative values, then add ten to each.", "solution": "def op_dec_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_dec_dropwhileneg_add10([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_dec_dropwhileneg_add10([]) == []\nassert op_dec_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [10, 11]\nassert op_dec_dropwhileneg_add10([5, 5, 5]) == [14, 14, 14]\nassert op_dec_dropwhileneg_add10([3, 1, 2]) == [12, 10, 11]\nassert op_dec_dropwhileneg_add10([10]) == [19]\nassert op_dec_dropwhileneg_add10([2, 4, 6]) == [11, 13, 15]\nassert op_dec_dropwhileneg_add10([-7, 12, -7]) == [21, 2]"}
{"id": "op_sorta_dec_pos", "entry_point": "op_sorta_dec_pos", "primitives": ["sorta", "dec", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then subtract one from each, then keep the positive numbers.", "solution": "def op_sorta_dec_pos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sorta_dec_pos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sorta_dec_pos([]) == []\nassert op_sorta_dec_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_sorta_dec_pos([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_dec_pos([3, 1, 2]) == [1, 2]\nassert op_sorta_dec_pos([10]) == [9]\nassert op_sorta_dec_pos([2, 4, 6]) == [1, 3, 5]\nassert op_sorta_dec_pos([-7, 12, -7]) == [11]"}
{"id": "op_dropfirst_inc_haszero", "entry_point": "op_dropfirst_inc_haszero", "primitives": ["dropfirst", "inc", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then add one to each, then return whether the list contains a zero.", "solution": "def op_dropfirst_inc_haszero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_dropfirst_inc_haszero([1, 2, 3, 4]) == False\nassert op_dropfirst_inc_haszero([]) == False\nassert op_dropfirst_inc_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_inc_haszero([5, 5, 5]) == False\nassert op_dropfirst_inc_haszero([3, 1, 2]) == False\nassert op_dropfirst_inc_haszero([10]) == False\nassert op_dropfirst_inc_haszero([2, 4, 6]) == False\nassert op_dropfirst_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_square_last3", "entry_point": "op_dropwhileneg_square_last3", "primitives": ["dropwhileneg", "square", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then square each, then keep only the last three.", "solution": "def op_dropwhileneg_square_last3(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_dropwhileneg_square_last3([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropwhileneg_square_last3([]) == []\nassert op_dropwhileneg_square_last3([-2, -1, 0, 1, 2]) == [0, 1, 4]\nassert op_dropwhileneg_square_last3([5, 5, 5]) == [25, 25, 25]\nassert op_dropwhileneg_square_last3([3, 1, 2]) == [9, 1, 4]\nassert op_dropwhileneg_square_last3([10]) == [100]\nassert op_dropwhileneg_square_last3([2, 4, 6]) == [4, 16, 36]\nassert op_dropwhileneg_square_last3([-7, 12, -7]) == [144, 49]"}
{"id": "op_ages_neg_alldistinct", "entry_point": "op_ages_neg_alldistinct", "primitives": ["ages", "neg", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the negative numbers, then return whether all values are distinct.", "solution": "def op_ages_neg_alldistinct(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x < 0]\n    return len(r) == len(set(r))", "tests": "assert op_ages_neg_alldistinct([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == True\nassert op_ages_neg_alldistinct([]) == True\nassert op_ages_neg_alldistinct([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == True\nassert op_ages_neg_alldistinct([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_absval_gt5_dropwhileneg", "entry_point": "op_absval_gt5_dropwhileneg", "primitives": ["absval", "gt5", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then drop the leading negative values.", "solution": "def op_absval_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_absval_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_absval_gt5_dropwhileneg([]) == []\nassert op_absval_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_absval_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_absval_gt5_dropwhileneg([10]) == [10]\nassert op_absval_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_absval_gt5_dropwhileneg([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_double_add10_dec", "entry_point": "op_double_add10_dec", "primitives": ["double", "add10", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then add ten to each, then subtract one from each.", "solution": "def op_double_add10_dec(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_double_add10_dec([1, 2, 3, 4]) == [11, 13, 15, 17]\nassert op_double_add10_dec([]) == []\nassert op_double_add10_dec([-2, -1, 0, 1, 2]) == [5, 7, 9, 11, 13]\nassert op_double_add10_dec([5, 5, 5]) == [19, 19, 19]\nassert op_double_add10_dec([3, 1, 2]) == [15, 11, 13]\nassert op_double_add10_dec([10]) == [29]\nassert op_double_add10_dec([2, 4, 6]) == [13, 17, 21]\nassert op_double_add10_dec([-7, 12, -7]) == [-5, 33, -5]"}
{"id": "op_sorta_sortabs_neg", "entry_point": "op_sorta_sortabs_neg", "primitives": ["sorta", "sortabs", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort by absolute value, then keep the negative numbers.", "solution": "def op_sorta_sortabs_neg(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sorta_sortabs_neg([1, 2, 3, 4]) == []\nassert op_sorta_sortabs_neg([]) == []\nassert op_sorta_sortabs_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sorta_sortabs_neg([5, 5, 5]) == []\nassert op_sorta_sortabs_neg([3, 1, 2]) == []\nassert op_sorta_sortabs_neg([10]) == []\nassert op_sorta_sortabs_neg([2, 4, 6]) == []\nassert op_sorta_sortabs_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortd_evens_alldistinct", "entry_point": "op_sortd_evens_alldistinct", "primitives": ["sortd", "evens", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_sortd_evens_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_evens_alldistinct([]) == True\nassert op_sortd_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_evens_alldistinct([5, 5, 5]) == True\nassert op_sortd_evens_alldistinct([3, 1, 2]) == True\nassert op_sortd_evens_alldistinct([10]) == True\nassert op_sortd_evens_alldistinct([2, 4, 6]) == True\nassert op_sortd_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_neg_gt5_dropzeros", "entry_point": "op_neg_gt5_dropzeros", "primitives": ["neg", "gt5", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep values greater than five, then drop the zeros.", "solution": "def op_neg_gt5_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_neg_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_neg_gt5_dropzeros([]) == []\nassert op_neg_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_neg_gt5_dropzeros([5, 5, 5]) == []\nassert op_neg_gt5_dropzeros([3, 1, 2]) == []\nassert op_neg_gt5_dropzeros([10]) == []\nassert op_neg_gt5_dropzeros([2, 4, 6]) == []\nassert op_neg_gt5_dropzeros([-7, 12, -7]) == []"}
{"id": "op_beforezero_dropzeros_prod", "entry_point": "op_beforezero_dropzeros_prod", "primitives": ["beforezero", "dropzeros", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the zeros, then return their product.", "solution": "def op_beforezero_dropzeros_prod(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_beforezero_dropzeros_prod([1, 2, 3, 4]) == 24\nassert op_beforezero_dropzeros_prod([]) == 1\nassert op_beforezero_dropzeros_prod([-2, -1, 0, 1, 2]) == 2\nassert op_beforezero_dropzeros_prod([5, 5, 5]) == 125\nassert op_beforezero_dropzeros_prod([3, 1, 2]) == 6\nassert op_beforezero_dropzeros_prod([10]) == 10\nassert op_beforezero_dropzeros_prod([2, 4, 6]) == 48\nassert op_beforezero_dropzeros_prod([-7, 12, -7]) == 588"}
{"id": "op_prefixup_sortalpha_dropshort", "entry_point": "op_prefixup_sortalpha_dropshort", "primitives": ["prefixup", "sortalpha", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort alphabetically, then drop strings shorter than three characters.", "solution": "def op_prefixup_sortalpha_dropshort(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_prefixup_sortalpha_dropshort(['Hello', 'world']) == ['#Hello', '#world']\nassert op_prefixup_sortalpha_dropshort([]) == []\nassert op_prefixup_sortalpha_dropshort(['  a ', '', 'BC', 'bc']) == ['#  a ', '#BC', '#bc']\nassert op_prefixup_sortalpha_dropshort(['one', 'one', 'Two']) == ['#Two', '#one', '#one']\nassert op_prefixup_sortalpha_dropshort(['x']) == []\nassert op_prefixup_sortalpha_dropshort(['abc', 'de', '']) == ['#abc', '#de']"}
{"id": "op_negate_oremptyzero_issorted", "entry_point": "op_negate_oremptyzero_issorted", "primitives": ["negate", "oremptyzero", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then return whether the list is sorted ascending.", "solution": "def op_negate_oremptyzero_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    return r == sorted(r)", "tests": "assert op_negate_oremptyzero_issorted([1, 2, 3, 4]) == False\nassert op_negate_oremptyzero_issorted([]) == True\nassert op_negate_oremptyzero_issorted([-2, -1, 0, 1, 2]) == False\nassert op_negate_oremptyzero_issorted([5, 5, 5]) == True\nassert op_negate_oremptyzero_issorted([3, 1, 2]) == False\nassert op_negate_oremptyzero_issorted([10]) == True\nassert op_negate_oremptyzero_issorted([2, 4, 6]) == False\nassert op_negate_oremptyzero_issorted([-7, 12, -7]) == False"}
{"id": "op_sorta_dropwhileneg_sortd", "entry_point": "op_sorta_dropwhileneg_sortd", "primitives": ["sorta", "dropwhileneg", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then sort descending.", "solution": "def op_sorta_dropwhileneg_sortd(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_sorta_dropwhileneg_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sorta_dropwhileneg_sortd([]) == []\nassert op_sorta_dropwhileneg_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_sorta_dropwhileneg_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_sorta_dropwhileneg_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_sorta_dropwhileneg_sortd([10]) == [10]\nassert op_sorta_dropwhileneg_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_sorta_dropwhileneg_sortd([-7, 12, -7]) == [12]"}
{"id": "op_double_dec_dropzeros", "entry_point": "op_double_dec_dropzeros", "primitives": ["double", "dec", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then subtract one from each, then drop the zeros.", "solution": "def op_double_dec_dropzeros(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_double_dec_dropzeros([1, 2, 3, 4]) == [1, 3, 5, 7]\nassert op_double_dec_dropzeros([]) == []\nassert op_double_dec_dropzeros([-2, -1, 0, 1, 2]) == [-5, -3, -1, 1, 3]\nassert op_double_dec_dropzeros([5, 5, 5]) == [9, 9, 9]\nassert op_double_dec_dropzeros([3, 1, 2]) == [5, 1, 3]\nassert op_double_dec_dropzeros([10]) == [19]\nassert op_double_dec_dropzeros([2, 4, 6]) == [3, 7, 11]\nassert op_double_dec_dropzeros([-7, 12, -7]) == [-15, 23, -15]"}
{"id": "op_double_trimends_neg", "entry_point": "op_double_trimends_neg", "primitives": ["double", "trimends", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_double_trimends_neg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_double_trimends_neg([1, 2, 3, 4]) == []\nassert op_double_trimends_neg([]) == []\nassert op_double_trimends_neg([-2, -1, 0, 1, 2]) == [-2]\nassert op_double_trimends_neg([5, 5, 5]) == []\nassert op_double_trimends_neg([3, 1, 2]) == []\nassert op_double_trimends_neg([10]) == []\nassert op_double_trimends_neg([2, 4, 6]) == []\nassert op_double_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_ages_first3_beforezero", "entry_point": "op_ages_first3_beforezero", "primitives": ["ages", "first3", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then keep everything before the first zero.", "solution": "def op_ages_first3_beforezero(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_ages_first3_beforezero([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_first3_beforezero([]) == []\nassert op_ages_first3_beforezero([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_first3_beforezero([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_first3_neg_div3", "entry_point": "op_first3_neg_div3", "primitives": ["first3", "neg", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the negative numbers, then keep multiples of three.", "solution": "def op_first3_neg_div3(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_first3_neg_div3([1, 2, 3, 4]) == []\nassert op_first3_neg_div3([]) == []\nassert op_first3_neg_div3([-2, -1, 0, 1, 2]) == []\nassert op_first3_neg_div3([5, 5, 5]) == []\nassert op_first3_neg_div3([3, 1, 2]) == []\nassert op_first3_neg_div3([10]) == []\nassert op_first3_neg_div3([2, 4, 6]) == []\nassert op_first3_neg_div3([-7, 12, -7]) == []"}
{"id": "op_evens_negate_counteven", "entry_point": "op_evens_negate_counteven", "primitives": ["evens", "negate", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then negate each, then return how many values are even.", "solution": "def op_evens_negate_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [-x for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_negate_counteven([1, 2, 3, 4]) == 2\nassert op_evens_negate_counteven([]) == 0\nassert op_evens_negate_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_negate_counteven([5, 5, 5]) == 0\nassert op_evens_negate_counteven([3, 1, 2]) == 1\nassert op_evens_negate_counteven([10]) == 1\nassert op_evens_negate_counteven([2, 4, 6]) == 3\nassert op_evens_negate_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortd_odds_dropwhileneg", "entry_point": "op_sortd_odds_dropwhileneg", "primitives": ["sortd", "odds", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_sortd_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_odds_dropwhileneg([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_odds_dropwhileneg([]) == []\nassert op_sortd_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_odds_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_odds_dropwhileneg([3, 1, 2]) == [3, 1]\nassert op_sortd_odds_dropwhileneg([10]) == []\nassert op_sortd_odds_dropwhileneg([2, 4, 6]) == []\nassert op_sortd_odds_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_uniq_dropwhileneg_allpos", "entry_point": "op_uniq_dropwhileneg_allpos", "primitives": ["uniq", "dropwhileneg", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the leading negative values, then return whether all values are positive.", "solution": "def op_uniq_dropwhileneg_allpos(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return all(x > 0 for x in r)", "tests": "assert op_uniq_dropwhileneg_allpos([1, 2, 3, 4]) == True\nassert op_uniq_dropwhileneg_allpos([]) == True\nassert op_uniq_dropwhileneg_allpos([-2, -1, 0, 1, 2]) == False\nassert op_uniq_dropwhileneg_allpos([5, 5, 5]) == True\nassert op_uniq_dropwhileneg_allpos([3, 1, 2]) == True\nassert op_uniq_dropwhileneg_allpos([10]) == True\nassert op_uniq_dropwhileneg_allpos([2, 4, 6]) == True\nassert op_uniq_dropwhileneg_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_dec_alldistinct", "entry_point": "op_negate_dec_alldistinct", "primitives": ["negate", "dec", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then return whether all values are distinct.", "solution": "def op_negate_dec_alldistinct(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_negate_dec_alldistinct([1, 2, 3, 4]) == True\nassert op_negate_dec_alldistinct([]) == True\nassert op_negate_dec_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_negate_dec_alldistinct([5, 5, 5]) == False\nassert op_negate_dec_alldistinct([3, 1, 2]) == True\nassert op_negate_dec_alldistinct([10]) == True\nassert op_negate_dec_alldistinct([2, 4, 6]) == True\nassert op_negate_dec_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropzeros_double_neg", "entry_point": "op_dropzeros_double_neg", "primitives": ["dropzeros", "double", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then keep the negative numbers.", "solution": "def op_dropzeros_double_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropzeros_double_neg([1, 2, 3, 4]) == []\nassert op_dropzeros_double_neg([]) == []\nassert op_dropzeros_double_neg([-2, -1, 0, 1, 2]) == [-4, -2]\nassert op_dropzeros_double_neg([5, 5, 5]) == []\nassert op_dropzeros_double_neg([3, 1, 2]) == []\nassert op_dropzeros_double_neg([10]) == []\nassert op_dropzeros_double_neg([2, 4, 6]) == []\nassert op_dropzeros_double_neg([-7, 12, -7]) == [-14, -14]"}
{"id": "op_sortabs_trimends_gt5", "entry_point": "op_sortabs_trimends_gt5", "primitives": ["sortabs", "trimends", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then keep values greater than five.", "solution": "def op_sortabs_trimends_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_trimends_gt5([1, 2, 3, 4]) == []\nassert op_sortabs_trimends_gt5([]) == []\nassert op_sortabs_trimends_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_trimends_gt5([5, 5, 5]) == []\nassert op_sortabs_trimends_gt5([3, 1, 2]) == []\nassert op_sortabs_trimends_gt5([10]) == []\nassert op_sortabs_trimends_gt5([2, 4, 6]) == []\nassert op_sortabs_trimends_gt5([-7, 12, -7]) == []"}
{"id": "op_last3_double_haszero", "entry_point": "op_last3_double_haszero", "primitives": ["last3", "double", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then double each, then return whether the list contains a zero.", "solution": "def op_last3_double_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return 0 in r", "tests": "assert op_last3_double_haszero([1, 2, 3, 4]) == False\nassert op_last3_double_haszero([]) == False\nassert op_last3_double_haszero([-2, -1, 0, 1, 2]) == True\nassert op_last3_double_haszero([5, 5, 5]) == False\nassert op_last3_double_haszero([3, 1, 2]) == False\nassert op_last3_double_haszero([10]) == False\nassert op_last3_double_haszero([2, 4, 6]) == False\nassert op_last3_double_haszero([-7, 12, -7]) == False"}
{"id": "op_double_padto3_sortd", "entry_point": "op_double_padto3_sortd", "primitives": ["double", "padto3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_double_padto3_sortd(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_double_padto3_sortd([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_padto3_sortd([]) == [0, 0, 0]\nassert op_double_padto3_sortd([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_padto3_sortd([5, 5, 5]) == [10, 10, 10]\nassert op_double_padto3_sortd([3, 1, 2]) == [6, 4, 2]\nassert op_double_padto3_sortd([10]) == [20, 0, 0]\nassert op_double_padto3_sortd([2, 4, 6]) == [12, 8, 4]\nassert op_double_padto3_sortd([-7, 12, -7]) == [24, -14, -14]"}
{"id": "op_clamp10_padto3_oremptyzero", "entry_point": "op_clamp10_padto3_oremptyzero", "primitives": ["clamp10", "padto3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_clamp10_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_padto3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_clamp10_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_padto3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_padto3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_padto3_oremptyzero([10]) == [10, 0, 0]\nassert op_clamp10_padto3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_padto3_oremptyzero([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_clamp10_sorta_pos", "entry_point": "op_clamp10_sorta_pos", "primitives": ["clamp10", "sorta", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then keep the positive numbers.", "solution": "def op_clamp10_sorta_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_sorta_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sorta_pos([]) == []\nassert op_clamp10_sorta_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_clamp10_sorta_pos([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sorta_pos([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sorta_pos([10]) == [10]\nassert op_clamp10_sorta_pos([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sorta_pos([-7, 12, -7]) == [10]"}
{"id": "op_dropfirst_padto3_odds", "entry_point": "op_dropfirst_padto3_odds", "primitives": ["dropfirst", "padto3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_dropfirst_padto3_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_padto3_odds([1, 2, 3, 4]) == [3]\nassert op_dropfirst_padto3_odds([]) == []\nassert op_dropfirst_padto3_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_padto3_odds([5, 5, 5]) == [5, 5]\nassert op_dropfirst_padto3_odds([3, 1, 2]) == [1]\nassert op_dropfirst_padto3_odds([10]) == []\nassert op_dropfirst_padto3_odds([2, 4, 6]) == []\nassert op_dropfirst_padto3_odds([-7, 12, -7]) == [-7]"}
{"id": "op_div3_first3_padto3", "entry_point": "op_div3_first3_padto3", "primitives": ["div3", "first3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_div3_first3_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_div3_first3_padto3([1, 2, 3, 4]) == [3, 0, 0]\nassert op_div3_first3_padto3([]) == [0, 0, 0]\nassert op_div3_first3_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_div3_first3_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_div3_first3_padto3([3, 1, 2]) == [3, 0, 0]\nassert op_div3_first3_padto3([10]) == [0, 0, 0]\nassert op_div3_first3_padto3([2, 4, 6]) == [6, 0, 0]\nassert op_div3_first3_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_negate_inc_issorted", "entry_point": "op_negate_inc_issorted", "primitives": ["negate", "inc", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then add one to each, then return whether the list is sorted ascending.", "solution": "def op_negate_inc_issorted(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r == sorted(r)", "tests": "assert op_negate_inc_issorted([1, 2, 3, 4]) == False\nassert op_negate_inc_issorted([]) == True\nassert op_negate_inc_issorted([-2, -1, 0, 1, 2]) == False\nassert op_negate_inc_issorted([5, 5, 5]) == True\nassert op_negate_inc_issorted([3, 1, 2]) == False\nassert op_negate_inc_issorted([10]) == True\nassert op_negate_inc_issorted([2, 4, 6]) == False\nassert op_negate_inc_issorted([-7, 12, -7]) == False"}
{"id": "op_dropfirst_square_negate", "entry_point": "op_dropfirst_square_negate", "primitives": ["dropfirst", "square", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then negate each.", "solution": "def op_dropfirst_square_negate(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_dropfirst_square_negate([1, 2, 3, 4]) == [-4, -9, -16]\nassert op_dropfirst_square_negate([]) == []\nassert op_dropfirst_square_negate([-2, -1, 0, 1, 2]) == [-1, 0, -1, -4]\nassert op_dropfirst_square_negate([5, 5, 5]) == [-25, -25]\nassert op_dropfirst_square_negate([3, 1, 2]) == [-1, -4]\nassert op_dropfirst_square_negate([10]) == []\nassert op_dropfirst_square_negate([2, 4, 6]) == [-16, -36]\nassert op_dropfirst_square_negate([-7, 12, -7]) == [-144, -49]"}
{"id": "op_gt5_padto3_odds", "entry_point": "op_gt5_padto3_odds", "primitives": ["gt5", "padto3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then keep the odd numbers.", "solution": "def op_gt5_padto3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_gt5_padto3_odds([1, 2, 3, 4]) == []\nassert op_gt5_padto3_odds([]) == []\nassert op_gt5_padto3_odds([-2, -1, 0, 1, 2]) == []\nassert op_gt5_padto3_odds([5, 5, 5]) == []\nassert op_gt5_padto3_odds([3, 1, 2]) == []\nassert op_gt5_padto3_odds([10]) == []\nassert op_gt5_padto3_odds([2, 4, 6]) == []\nassert op_gt5_padto3_odds([-7, 12, -7]) == []"}
{"id": "op_rev_last3_trimends", "entry_point": "op_rev_last3_trimends", "primitives": ["rev", "last3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then drop the first and last elements.", "solution": "def op_rev_last3_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_last3_trimends([1, 2, 3, 4]) == [2]\nassert op_rev_last3_trimends([]) == []\nassert op_rev_last3_trimends([-2, -1, 0, 1, 2]) == [-1]\nassert op_rev_last3_trimends([5, 5, 5]) == [5]\nassert op_rev_last3_trimends([3, 1, 2]) == [1]\nassert op_rev_last3_trimends([10]) == []\nassert op_rev_last3_trimends([2, 4, 6]) == [4]\nassert op_rev_last3_trimends([-7, 12, -7]) == [12]"}
{"id": "op_trimends_inc_prod", "entry_point": "op_trimends_inc_prod", "primitives": ["trimends", "inc", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then add one to each, then return their product.", "solution": "def op_trimends_inc_prod(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_trimends_inc_prod([1, 2, 3, 4]) == 12\nassert op_trimends_inc_prod([]) == 1\nassert op_trimends_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_inc_prod([5, 5, 5]) == 6\nassert op_trimends_inc_prod([3, 1, 2]) == 2\nassert op_trimends_inc_prod([10]) == 1\nassert op_trimends_inc_prod([2, 4, 6]) == 5\nassert op_trimends_inc_prod([-7, 12, -7]) == 13"}
{"id": "op_dropfirst_takewhilepos_padto3", "entry_point": "op_dropfirst_takewhilepos_padto3", "primitives": ["dropfirst", "takewhilepos", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then pad with zeros to at least three elements.", "solution": "def op_dropfirst_takewhilepos_padto3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dropfirst_takewhilepos_padto3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_takewhilepos_padto3([]) == [0, 0, 0]\nassert op_dropfirst_takewhilepos_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_dropfirst_takewhilepos_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_dropfirst_takewhilepos_padto3([3, 1, 2]) == [1, 2, 0]\nassert op_dropfirst_takewhilepos_padto3([10]) == [0, 0, 0]\nassert op_dropfirst_takewhilepos_padto3([2, 4, 6]) == [4, 6, 0]\nassert op_dropfirst_takewhilepos_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sortabs_add10_absval", "entry_point": "op_sortabs_add10_absval", "primitives": ["sortabs", "add10", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add ten to each, then take the absolute value of each.", "solution": "def op_sortabs_add10_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 10 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_add10_absval([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_sortabs_add10_absval([]) == []\nassert op_sortabs_add10_absval([-2, -1, 0, 1, 2]) == [10, 9, 11, 8, 12]\nassert op_sortabs_add10_absval([5, 5, 5]) == [15, 15, 15]\nassert op_sortabs_add10_absval([3, 1, 2]) == [11, 12, 13]\nassert op_sortabs_add10_absval([10]) == [20]\nassert op_sortabs_add10_absval([2, 4, 6]) == [12, 14, 16]\nassert op_sortabs_add10_absval([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_rev_takewhilepos_uniq", "entry_point": "op_rev_takewhilepos_uniq", "primitives": ["rev", "takewhilepos", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then take values while they are positive, then drop duplicates keeping first occurrence.", "solution": "def op_rev_takewhilepos_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_takewhilepos_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_takewhilepos_uniq([]) == []\nassert op_rev_takewhilepos_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_rev_takewhilepos_uniq([5, 5, 5]) == [5]\nassert op_rev_takewhilepos_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_takewhilepos_uniq([10]) == [10]\nassert op_rev_takewhilepos_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_takewhilepos_uniq([-7, 12, -7]) == []"}
{"id": "op_dropfirst_trimends_dropzeros", "entry_point": "op_dropfirst_trimends_dropzeros", "primitives": ["dropfirst", "trimends", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then drop the zeros.", "solution": "def op_dropfirst_trimends_dropzeros(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dropfirst_trimends_dropzeros([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_dropzeros([]) == []\nassert op_dropfirst_trimends_dropzeros([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_trimends_dropzeros([5, 5, 5]) == []\nassert op_dropfirst_trimends_dropzeros([3, 1, 2]) == []\nassert op_dropfirst_trimends_dropzeros([10]) == []\nassert op_dropfirst_trimends_dropzeros([2, 4, 6]) == []\nassert op_dropfirst_trimends_dropzeros([-7, 12, -7]) == []"}
{"id": "op_dropzeros_inc_neg", "entry_point": "op_dropzeros_inc_neg", "primitives": ["dropzeros", "inc", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add one to each, then keep the negative numbers.", "solution": "def op_dropzeros_inc_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropzeros_inc_neg([1, 2, 3, 4]) == []\nassert op_dropzeros_inc_neg([]) == []\nassert op_dropzeros_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_dropzeros_inc_neg([5, 5, 5]) == []\nassert op_dropzeros_inc_neg([3, 1, 2]) == []\nassert op_dropzeros_inc_neg([10]) == []\nassert op_dropzeros_inc_neg([2, 4, 6]) == []\nassert op_dropzeros_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dropzeros_absval_sum", "entry_point": "op_dropzeros_absval_sum", "primitives": ["dropzeros", "absval", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then take the absolute value of each, then return their sum.", "solution": "def op_dropzeros_absval_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_dropzeros_absval_sum([1, 2, 3, 4]) == 10\nassert op_dropzeros_absval_sum([]) == 0\nassert op_dropzeros_absval_sum([-2, -1, 0, 1, 2]) == 6\nassert op_dropzeros_absval_sum([5, 5, 5]) == 15\nassert op_dropzeros_absval_sum([3, 1, 2]) == 6\nassert op_dropzeros_absval_sum([10]) == 10\nassert op_dropzeros_absval_sum([2, 4, 6]) == 12\nassert op_dropzeros_absval_sum([-7, 12, -7]) == 26"}
{"id": "op_evens_dropzeros_dec", "entry_point": "op_evens_dropzeros_dec", "primitives": ["evens", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the zeros, then subtract one from each.", "solution": "def op_evens_dropzeros_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_evens_dropzeros_dec([1, 2, 3, 4]) == [1, 3]\nassert op_evens_dropzeros_dec([]) == []\nassert op_evens_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, 1]\nassert op_evens_dropzeros_dec([5, 5, 5]) == []\nassert op_evens_dropzeros_dec([3, 1, 2]) == [1]\nassert op_evens_dropzeros_dec([10]) == [9]\nassert op_evens_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_evens_dropzeros_dec([-7, 12, -7]) == [11]"}
{"id": "op_oremptyzero_dropwhileneg_issorted", "entry_point": "op_oremptyzero_dropwhileneg_issorted", "primitives": ["oremptyzero", "dropwhileneg", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then return whether the list is sorted ascending.", "solution": "def op_oremptyzero_dropwhileneg_issorted(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r == sorted(r)", "tests": "assert op_oremptyzero_dropwhileneg_issorted([1, 2, 3, 4]) == True\nassert op_oremptyzero_dropwhileneg_issorted([]) == True\nassert op_oremptyzero_dropwhileneg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_oremptyzero_dropwhileneg_issorted([5, 5, 5]) == True\nassert op_oremptyzero_dropwhileneg_issorted([3, 1, 2]) == False\nassert op_oremptyzero_dropwhileneg_issorted([10]) == True\nassert op_oremptyzero_dropwhileneg_issorted([2, 4, 6]) == True\nassert op_oremptyzero_dropwhileneg_issorted([-7, 12, -7]) == False"}
{"id": "op_padto3_inc_len", "entry_point": "op_padto3_inc_len", "primitives": ["padto3", "inc", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then return how many remain.", "solution": "def op_padto3_inc_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return len(r)", "tests": "assert op_padto3_inc_len([1, 2, 3, 4]) == 4\nassert op_padto3_inc_len([]) == 3\nassert op_padto3_inc_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_inc_len([5, 5, 5]) == 3\nassert op_padto3_inc_len([3, 1, 2]) == 3\nassert op_padto3_inc_len([10]) == 3\nassert op_padto3_inc_len([2, 4, 6]) == 3\nassert op_padto3_inc_len([-7, 12, -7]) == 3"}
{"id": "op_ages_trimends_clamp10", "entry_point": "op_ages_trimends_clamp10", "primitives": ["ages", "trimends", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then cap each value at 10.", "solution": "def op_ages_trimends_clamp10(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_ages_trimends_clamp10([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_clamp10([]) == []\nassert op_ages_trimends_clamp10([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [10]\nassert op_ages_trimends_clamp10([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_absval_dropwhileneg_square", "entry_point": "op_absval_dropwhileneg_square", "primitives": ["absval", "dropwhileneg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then square each.", "solution": "def op_absval_dropwhileneg_square(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_absval_dropwhileneg_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_absval_dropwhileneg_square([]) == []\nassert op_absval_dropwhileneg_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_absval_dropwhileneg_square([5, 5, 5]) == [25, 25, 25]\nassert op_absval_dropwhileneg_square([3, 1, 2]) == [9, 1, 4]\nassert op_absval_dropwhileneg_square([10]) == [100]\nassert op_absval_dropwhileneg_square([2, 4, 6]) == [4, 16, 36]\nassert op_absval_dropwhileneg_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_absval_dropwhileneg_odds", "entry_point": "op_absval_dropwhileneg_odds", "primitives": ["absval", "dropwhileneg", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then keep the odd numbers.", "solution": "def op_absval_dropwhileneg_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_dropwhileneg_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_dropwhileneg_odds([]) == []\nassert op_absval_dropwhileneg_odds([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_absval_dropwhileneg_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropwhileneg_odds([3, 1, 2]) == [3, 1]\nassert op_absval_dropwhileneg_odds([10]) == []\nassert op_absval_dropwhileneg_odds([2, 4, 6]) == []\nassert op_absval_dropwhileneg_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_evens_inc_max", "entry_point": "op_evens_inc_max", "primitives": ["evens", "inc", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add one to each, then return the maximum (0 if empty).", "solution": "def op_evens_inc_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_evens_inc_max([1, 2, 3, 4]) == 5\nassert op_evens_inc_max([]) == 0\nassert op_evens_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_evens_inc_max([5, 5, 5]) == 0\nassert op_evens_inc_max([3, 1, 2]) == 3\nassert op_evens_inc_max([10]) == 11\nassert op_evens_inc_max([2, 4, 6]) == 7\nassert op_evens_inc_max([-7, 12, -7]) == 13"}
{"id": "op_square_rev_dropwhileneg", "entry_point": "op_square_rev_dropwhileneg", "primitives": ["square", "rev", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then reverse the order, then drop the leading negative values.", "solution": "def op_square_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_rev_dropwhileneg([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_square_rev_dropwhileneg([]) == []\nassert op_square_rev_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_square_rev_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_rev_dropwhileneg([3, 1, 2]) == [4, 1, 9]\nassert op_square_rev_dropwhileneg([10]) == [100]\nassert op_square_rev_dropwhileneg([2, 4, 6]) == [36, 16, 4]\nassert op_square_rev_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_absval_beforezero_odds", "entry_point": "op_absval_beforezero_odds", "primitives": ["absval", "beforezero", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_absval_beforezero_odds(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_absval_beforezero_odds([1, 2, 3, 4]) == [1, 3]\nassert op_absval_beforezero_odds([]) == []\nassert op_absval_beforezero_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_absval_beforezero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_absval_beforezero_odds([3, 1, 2]) == [3, 1]\nassert op_absval_beforezero_odds([10]) == []\nassert op_absval_beforezero_odds([2, 4, 6]) == []\nassert op_absval_beforezero_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_gt5_double_uniq", "entry_point": "op_gt5_double_uniq", "primitives": ["gt5", "double", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then drop duplicates keeping first occurrence.", "solution": "def op_gt5_double_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_gt5_double_uniq([1, 2, 3, 4]) == []\nassert op_gt5_double_uniq([]) == []\nassert op_gt5_double_uniq([-2, -1, 0, 1, 2]) == []\nassert op_gt5_double_uniq([5, 5, 5]) == []\nassert op_gt5_double_uniq([3, 1, 2]) == []\nassert op_gt5_double_uniq([10]) == [20]\nassert op_gt5_double_uniq([2, 4, 6]) == [12]\nassert op_gt5_double_uniq([-7, 12, -7]) == [24]"}
{"id": "op_last3_rev_div3", "entry_point": "op_last3_rev_div3", "primitives": ["last3", "rev", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then reverse the order, then keep multiples of three.", "solution": "def op_last3_rev_div3(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_last3_rev_div3([1, 2, 3, 4]) == [3]\nassert op_last3_rev_div3([]) == []\nassert op_last3_rev_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_rev_div3([5, 5, 5]) == []\nassert op_last3_rev_div3([3, 1, 2]) == [3]\nassert op_last3_rev_div3([10]) == []\nassert op_last3_rev_div3([2, 4, 6]) == [6]\nassert op_last3_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_first3_haszero", "entry_point": "op_dropwhileneg_first3_haszero", "primitives": ["dropwhileneg", "first3", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep only the first three, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_first3_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return 0 in r", "tests": "assert op_dropwhileneg_first3_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_first3_haszero([]) == False\nassert op_dropwhileneg_first3_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_first3_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_first3_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_first3_haszero([10]) == False\nassert op_dropwhileneg_first3_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_first3_haszero([-7, 12, -7]) == False"}
{"id": "op_odds_neg_last3", "entry_point": "op_odds_neg_last3", "primitives": ["odds", "neg", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then keep only the last three.", "solution": "def op_odds_neg_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = r[-3:]\n    return r", "tests": "assert op_odds_neg_last3([1, 2, 3, 4]) == []\nassert op_odds_neg_last3([]) == []\nassert op_odds_neg_last3([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_neg_last3([5, 5, 5]) == []\nassert op_odds_neg_last3([3, 1, 2]) == []\nassert op_odds_neg_last3([10]) == []\nassert op_odds_neg_last3([2, 4, 6]) == []\nassert op_odds_neg_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_pos_double_prod", "entry_point": "op_pos_double_prod", "primitives": ["pos", "double", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then double each, then return their product.", "solution": "def op_pos_double_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_pos_double_prod([1, 2, 3, 4]) == 384\nassert op_pos_double_prod([]) == 1\nassert op_pos_double_prod([-2, -1, 0, 1, 2]) == 8\nassert op_pos_double_prod([5, 5, 5]) == 1000\nassert op_pos_double_prod([3, 1, 2]) == 48\nassert op_pos_double_prod([10]) == 20\nassert op_pos_double_prod([2, 4, 6]) == 384\nassert op_pos_double_prod([-7, 12, -7]) == 24"}
{"id": "op_square_negate_sortd", "entry_point": "op_square_negate_sortd", "primitives": ["square", "negate", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then negate each, then sort descending.", "solution": "def op_square_negate_sortd(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [-x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_square_negate_sortd([1, 2, 3, 4]) == [-1, -4, -9, -16]\nassert op_square_negate_sortd([]) == []\nassert op_square_negate_sortd([-2, -1, 0, 1, 2]) == [0, -1, -1, -4, -4]\nassert op_square_negate_sortd([5, 5, 5]) == [-25, -25, -25]\nassert op_square_negate_sortd([3, 1, 2]) == [-1, -4, -9]\nassert op_square_negate_sortd([10]) == [-100]\nassert op_square_negate_sortd([2, 4, 6]) == [-4, -16, -36]\nassert op_square_negate_sortd([-7, 12, -7]) == [-49, -49, -144]"}
{"id": "op_double_div3_first3", "entry_point": "op_double_div3_first3", "primitives": ["double", "div3", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then keep only the first three.", "solution": "def op_double_div3_first3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_double_div3_first3([1, 2, 3, 4]) == [6]\nassert op_double_div3_first3([]) == []\nassert op_double_div3_first3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_div3_first3([5, 5, 5]) == []\nassert op_double_div3_first3([3, 1, 2]) == [6]\nassert op_double_div3_first3([10]) == []\nassert op_double_div3_first3([2, 4, 6]) == [12]\nassert op_double_div3_first3([-7, 12, -7]) == [24]"}
{"id": "op_dropshort_upper_joinc", "entry_point": "op_dropshort_upper_joinc", "primitives": ["dropshort", "upper", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then uppercase each string, then join them with commas.", "solution": "def op_dropshort_upper_joinc(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.upper() for s in r]\n    return ','.join(r)", "tests": "assert op_dropshort_upper_joinc(['Hello', 'world']) == 'HELLO,WORLD'\nassert op_dropshort_upper_joinc([]) == ''\nassert op_dropshort_upper_joinc(['  a ', '', 'BC', 'bc']) == '  A '\nassert op_dropshort_upper_joinc(['one', 'one', 'Two']) == 'ONE,ONE,TWO'\nassert op_dropshort_upper_joinc(['x']) == ''\nassert op_dropshort_upper_joinc(['abc', 'de', '']) == 'ABC'"}
{"id": "op_double_negate_clamp10", "entry_point": "op_double_negate_clamp10", "primitives": ["double", "negate", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then negate each, then cap each value at 10.", "solution": "def op_double_negate_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_negate_clamp10([1, 2, 3, 4]) == [-2, -4, -6, -8]\nassert op_double_negate_clamp10([]) == []\nassert op_double_negate_clamp10([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_negate_clamp10([5, 5, 5]) == [-10, -10, -10]\nassert op_double_negate_clamp10([3, 1, 2]) == [-6, -2, -4]\nassert op_double_negate_clamp10([10]) == [-20]\nassert op_double_negate_clamp10([2, 4, 6]) == [-4, -8, -12]\nassert op_double_negate_clamp10([-7, 12, -7]) == [10, -24, 10]"}
{"id": "op_upper_sortlen_dropshort", "entry_point": "op_upper_sortlen_dropshort", "primitives": ["upper", "sortlen", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort by length, shortest first, then drop strings shorter than three characters.", "solution": "def op_upper_sortlen_dropshort(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_upper_sortlen_dropshort(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_sortlen_dropshort([]) == []\nassert op_upper_sortlen_dropshort(['  a ', '', 'BC', 'bc']) == ['  A ']\nassert op_upper_sortlen_dropshort(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_sortlen_dropshort(['x']) == []\nassert op_upper_sortlen_dropshort(['abc', 'de', '']) == ['ABC']"}
{"id": "op_sortabs_inc_last3", "entry_point": "op_sortabs_inc_last3", "primitives": ["sortabs", "inc", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then keep only the last three.", "solution": "def op_sortabs_inc_last3(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_sortabs_inc_last3([1, 2, 3, 4]) == [3, 4, 5]\nassert op_sortabs_inc_last3([]) == []\nassert op_sortabs_inc_last3([-2, -1, 0, 1, 2]) == [2, -1, 3]\nassert op_sortabs_inc_last3([5, 5, 5]) == [6, 6, 6]\nassert op_sortabs_inc_last3([3, 1, 2]) == [2, 3, 4]\nassert op_sortabs_inc_last3([10]) == [11]\nassert op_sortabs_inc_last3([2, 4, 6]) == [3, 5, 7]\nassert op_sortabs_inc_last3([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_ages_uniq_issorted", "entry_point": "op_ages_uniq_issorted", "primitives": ["ages", "uniq", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then return whether the list is sorted ascending.", "solution": "def op_ages_uniq_issorted(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    return r == sorted(r)", "tests": "assert op_ages_uniq_issorted([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == False\nassert op_ages_uniq_issorted([]) == True\nassert op_ages_uniq_issorted([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == False\nassert op_ages_uniq_issorted([{'name': 'Fi', 'age': 41}]) == True"}
{"id": "op_clamp10_sortabs_padto3", "entry_point": "op_clamp10_sortabs_padto3", "primitives": ["clamp10", "sortabs", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort by absolute value, then pad with zeros to at least three elements.", "solution": "def op_clamp10_sortabs_padto3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_clamp10_sortabs_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sortabs_padto3([]) == [0, 0, 0]\nassert op_clamp10_sortabs_padto3([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_clamp10_sortabs_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sortabs_padto3([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sortabs_padto3([10]) == [10, 0, 0]\nassert op_clamp10_sortabs_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sortabs_padto3([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_beforezero_dropfirst_sorta", "entry_point": "op_beforezero_dropfirst_sorta", "primitives": ["beforezero", "dropfirst", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first element, then sort ascending.", "solution": "def op_beforezero_dropfirst_sorta(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:]\n    r = sorted(r)\n    return r", "tests": "assert op_beforezero_dropfirst_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_dropfirst_sorta([]) == []\nassert op_beforezero_dropfirst_sorta([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_dropfirst_sorta([5, 5, 5]) == [5, 5]\nassert op_beforezero_dropfirst_sorta([3, 1, 2]) == [1, 2]\nassert op_beforezero_dropfirst_sorta([10]) == []\nassert op_beforezero_dropfirst_sorta([2, 4, 6]) == [4, 6]\nassert op_beforezero_dropfirst_sorta([-7, 12, -7]) == [-7, 12]"}
{"id": "op_add10_gt5_first3", "entry_point": "op_add10_gt5_first3", "primitives": ["add10", "gt5", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then keep only the first three.", "solution": "def op_add10_gt5_first3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:3]\n    return r", "tests": "assert op_add10_gt5_first3([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_gt5_first3([]) == []\nassert op_add10_gt5_first3([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_gt5_first3([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5_first3([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5_first3([10]) == [20]\nassert op_add10_gt5_first3([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5_first3([-7, 12, -7]) == [22]"}
{"id": "op_sortd_double_alldistinct", "entry_point": "op_sortd_double_alldistinct", "primitives": ["sortd", "double", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then return whether all values are distinct.", "solution": "def op_sortd_double_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_double_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_double_alldistinct([]) == True\nassert op_sortd_double_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_double_alldistinct([5, 5, 5]) == False\nassert op_sortd_double_alldistinct([3, 1, 2]) == True\nassert op_sortd_double_alldistinct([10]) == True\nassert op_sortd_double_alldistinct([2, 4, 6]) == True\nassert op_sortd_double_alldistinct([-7, 12, -7]) == False"}
{"id": "op_last3_dec_square", "entry_point": "op_last3_dec_square", "primitives": ["last3", "dec", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then subtract one from each, then square each.", "solution": "def op_last3_dec_square(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_last3_dec_square([1, 2, 3, 4]) == [1, 4, 9]\nassert op_last3_dec_square([]) == []\nassert op_last3_dec_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_last3_dec_square([5, 5, 5]) == [16, 16, 16]\nassert op_last3_dec_square([3, 1, 2]) == [4, 0, 1]\nassert op_last3_dec_square([10]) == [81]\nassert op_last3_dec_square([2, 4, 6]) == [1, 9, 25]\nassert op_last3_dec_square([-7, 12, -7]) == [64, 121, 64]"}
{"id": "op_padto3_uniq_absval", "entry_point": "op_padto3_uniq_absval", "primitives": ["padto3", "uniq", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_padto3_uniq_absval(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_padto3_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_uniq_absval([]) == [0]\nassert op_padto3_uniq_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_padto3_uniq_absval([5, 5, 5]) == [5]\nassert op_padto3_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_uniq_absval([10]) == [10, 0]\nassert op_padto3_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_uniq_absval([-7, 12, -7]) == [7, 12]"}
{"id": "op_dec_div3_allpos", "entry_point": "op_dec_div3_allpos", "primitives": ["dec", "div3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep multiples of three, then return whether all values are positive.", "solution": "def op_dec_div3_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_div3_allpos([1, 2, 3, 4]) == False\nassert op_dec_div3_allpos([]) == True\nassert op_dec_div3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_div3_allpos([5, 5, 5]) == True\nassert op_dec_div3_allpos([3, 1, 2]) == False\nassert op_dec_div3_allpos([10]) == True\nassert op_dec_div3_allpos([2, 4, 6]) == True\nassert op_dec_div3_allpos([-7, 12, -7]) == True"}
{"id": "op_ages_clamp10_square", "entry_point": "op_ages_clamp10_square", "primitives": ["ages", "clamp10", "square"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cap each value at 10, then square each.", "solution": "def op_ages_clamp10_square(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_ages_clamp10_square([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [100, 100]\nassert op_ages_clamp10_square([]) == []\nassert op_ages_clamp10_square([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [100, 100, 100]\nassert op_ages_clamp10_square([{'name': 'Fi', 'age': 41}]) == [100]"}
{"id": "op_last3_div3_oremptyzero", "entry_point": "op_last3_div3_oremptyzero", "primitives": ["last3", "div3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep multiples of three, then if empty, use a single zero.", "solution": "def op_last3_div3_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_div3_oremptyzero([1, 2, 3, 4]) == [3]\nassert op_last3_div3_oremptyzero([]) == [0]\nassert op_last3_div3_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_last3_div3_oremptyzero([5, 5, 5]) == [0]\nassert op_last3_div3_oremptyzero([3, 1, 2]) == [3]\nassert op_last3_div3_oremptyzero([10]) == [0]\nassert op_last3_div3_oremptyzero([2, 4, 6]) == [6]\nassert op_last3_div3_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_inc_neg_oremptyzero", "entry_point": "op_inc_neg_oremptyzero", "primitives": ["inc", "neg", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the negative numbers, then if empty, use a single zero.", "solution": "def op_inc_neg_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_inc_neg_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_inc_neg_oremptyzero([]) == [0]\nassert op_inc_neg_oremptyzero([-2, -1, 0, 1, 2]) == [-1]\nassert op_inc_neg_oremptyzero([5, 5, 5]) == [0]\nassert op_inc_neg_oremptyzero([3, 1, 2]) == [0]\nassert op_inc_neg_oremptyzero([10]) == [0]\nassert op_inc_neg_oremptyzero([2, 4, 6]) == [0]\nassert op_inc_neg_oremptyzero([-7, 12, -7]) == [-6, -6]"}
{"id": "op_sorta_odds_trimends", "entry_point": "op_sorta_odds_trimends", "primitives": ["sorta", "odds", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the odd numbers, then drop the first and last elements.", "solution": "def op_sorta_odds_trimends(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_sorta_odds_trimends([1, 2, 3, 4]) == []\nassert op_sorta_odds_trimends([]) == []\nassert op_sorta_odds_trimends([-2, -1, 0, 1, 2]) == []\nassert op_sorta_odds_trimends([5, 5, 5]) == [5]\nassert op_sorta_odds_trimends([3, 1, 2]) == []\nassert op_sorta_odds_trimends([10]) == []\nassert op_sorta_odds_trimends([2, 4, 6]) == []\nassert op_sorta_odds_trimends([-7, 12, -7]) == []"}
{"id": "op_sorta_pos_firsteven", "entry_point": "op_sorta_pos_firsteven", "primitives": ["sorta", "pos", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep the positive numbers, then return the first even value (0 if none).", "solution": "def op_sorta_pos_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_pos_firsteven([1, 2, 3, 4]) == 2\nassert op_sorta_pos_firsteven([]) == 0\nassert op_sorta_pos_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_sorta_pos_firsteven([5, 5, 5]) == 0\nassert op_sorta_pos_firsteven([3, 1, 2]) == 2\nassert op_sorta_pos_firsteven([10]) == 10\nassert op_sorta_pos_firsteven([2, 4, 6]) == 2\nassert op_sorta_pos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_gt5_padto3_allpos", "entry_point": "op_gt5_padto3_allpos", "primitives": ["gt5", "padto3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then return whether all values are positive.", "solution": "def op_gt5_padto3_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return all(x > 0 for x in r)", "tests": "assert op_gt5_padto3_allpos([1, 2, 3, 4]) == False\nassert op_gt5_padto3_allpos([]) == False\nassert op_gt5_padto3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_gt5_padto3_allpos([5, 5, 5]) == False\nassert op_gt5_padto3_allpos([3, 1, 2]) == False\nassert op_gt5_padto3_allpos([10]) == False\nassert op_gt5_padto3_allpos([2, 4, 6]) == False\nassert op_gt5_padto3_allpos([-7, 12, -7]) == False"}
{"id": "op_sortabs_dec_dropzeros", "entry_point": "op_sortabs_dec_dropzeros", "primitives": ["sortabs", "dec", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then subtract one from each, then drop the zeros.", "solution": "def op_sortabs_dec_dropzeros(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_sortabs_dec_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_sortabs_dec_dropzeros([]) == []\nassert op_sortabs_dec_dropzeros([-2, -1, 0, 1, 2]) == [-1, -2, -3, 1]\nassert op_sortabs_dec_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_sortabs_dec_dropzeros([3, 1, 2]) == [1, 2]\nassert op_sortabs_dec_dropzeros([10]) == [9]\nassert op_sortabs_dec_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_sortabs_dec_dropzeros([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_padto3_double_gt5", "entry_point": "op_padto3_double_gt5", "primitives": ["padto3", "double", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then keep values greater than five.", "solution": "def op_padto3_double_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_padto3_double_gt5([]) == []\nassert op_padto3_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_padto3_double_gt5([3, 1, 2]) == [6]\nassert op_padto3_double_gt5([10]) == [20]\nassert op_padto3_double_gt5([2, 4, 6]) == [8, 12]\nassert op_padto3_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_trimends_square_pos", "entry_point": "op_trimends_square_pos", "primitives": ["trimends", "square", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then square each, then keep the positive numbers.", "solution": "def op_trimends_square_pos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_trimends_square_pos([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_square_pos([]) == []\nassert op_trimends_square_pos([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_trimends_square_pos([5, 5, 5]) == [25]\nassert op_trimends_square_pos([3, 1, 2]) == [1]\nassert op_trimends_square_pos([10]) == []\nassert op_trimends_square_pos([2, 4, 6]) == [16]\nassert op_trimends_square_pos([-7, 12, -7]) == [144]"}
{"id": "op_uniqs_sortlen_nonempty", "entry_point": "op_uniqs_sortlen_nonempty", "primitives": ["uniqs", "sortlen", "nonempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort by length, shortest first, then drop empty strings.", "solution": "def op_uniqs_sortlen_nonempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=len)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_uniqs_sortlen_nonempty(['Hello', 'world']) == ['Hello', 'world']\nassert op_uniqs_sortlen_nonempty([]) == []\nassert op_uniqs_sortlen_nonempty(['  a ', '', 'BC', 'bc']) == ['BC', 'bc', '  a ']\nassert op_uniqs_sortlen_nonempty(['one', 'one', 'Two']) == ['one', 'Two']\nassert op_uniqs_sortlen_nonempty(['x']) == ['x']\nassert op_uniqs_sortlen_nonempty(['abc', 'de', '']) == ['de', 'abc']"}
{"id": "op_oremptyzero_sortabs_uniq", "entry_point": "op_oremptyzero_sortabs_uniq", "primitives": ["oremptyzero", "sortabs", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_oremptyzero_sortabs_uniq(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_oremptyzero_sortabs_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_sortabs_uniq([]) == [0]\nassert op_oremptyzero_sortabs_uniq([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_oremptyzero_sortabs_uniq([5, 5, 5]) == [5]\nassert op_oremptyzero_sortabs_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_oremptyzero_sortabs_uniq([10]) == [10]\nassert op_oremptyzero_sortabs_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_sortabs_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_padto3_evens_sortd", "entry_point": "op_padto3_evens_sortd", "primitives": ["padto3", "evens", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the even numbers, then sort descending.", "solution": "def op_padto3_evens_sortd(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_padto3_evens_sortd([1, 2, 3, 4]) == [4, 2]\nassert op_padto3_evens_sortd([]) == [0, 0, 0]\nassert op_padto3_evens_sortd([-2, -1, 0, 1, 2]) == [2, 0, -2]\nassert op_padto3_evens_sortd([5, 5, 5]) == []\nassert op_padto3_evens_sortd([3, 1, 2]) == [2]\nassert op_padto3_evens_sortd([10]) == [10, 0, 0]\nassert op_padto3_evens_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_evens_sortd([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_oremptyzero_uniq", "entry_point": "op_dropfirst_oremptyzero_uniq", "primitives": ["dropfirst", "oremptyzero", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_dropfirst_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropfirst_oremptyzero_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_oremptyzero_uniq([]) == [0]\nassert op_dropfirst_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_oremptyzero_uniq([5, 5, 5]) == [5]\nassert op_dropfirst_oremptyzero_uniq([3, 1, 2]) == [1, 2]\nassert op_dropfirst_oremptyzero_uniq([10]) == [0]\nassert op_dropfirst_oremptyzero_uniq([2, 4, 6]) == [4, 6]\nassert op_dropfirst_oremptyzero_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_beforezero_sortd_dropfirst", "entry_point": "op_beforezero_sortd_dropfirst", "primitives": ["beforezero", "sortd", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort descending, then drop the first element.", "solution": "def op_beforezero_sortd_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_sortd_dropfirst([1, 2, 3, 4]) == [3, 2, 1]\nassert op_beforezero_sortd_dropfirst([]) == []\nassert op_beforezero_sortd_dropfirst([-2, -1, 0, 1, 2]) == [-2]\nassert op_beforezero_sortd_dropfirst([5, 5, 5]) == [5, 5]\nassert op_beforezero_sortd_dropfirst([3, 1, 2]) == [2, 1]\nassert op_beforezero_sortd_dropfirst([10]) == []\nassert op_beforezero_sortd_dropfirst([2, 4, 6]) == [4, 2]\nassert op_beforezero_sortd_dropfirst([-7, 12, -7]) == [-7, -7]"}
{"id": "op_takewhilepos_neg_trimends", "entry_point": "op_takewhilepos_neg_trimends", "primitives": ["takewhilepos", "neg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the negative numbers, then drop the first and last elements.", "solution": "def op_takewhilepos_neg_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_neg_trimends([1, 2, 3, 4]) == []\nassert op_takewhilepos_neg_trimends([]) == []\nassert op_takewhilepos_neg_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_neg_trimends([5, 5, 5]) == []\nassert op_takewhilepos_neg_trimends([3, 1, 2]) == []\nassert op_takewhilepos_neg_trimends([10]) == []\nassert op_takewhilepos_neg_trimends([2, 4, 6]) == []\nassert op_takewhilepos_neg_trimends([-7, 12, -7]) == []"}
{"id": "op_gt5_dec_first3", "entry_point": "op_gt5_dec_first3", "primitives": ["gt5", "dec", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then keep only the first three.", "solution": "def op_gt5_dec_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_dec_first3([1, 2, 3, 4]) == []\nassert op_gt5_dec_first3([]) == []\nassert op_gt5_dec_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dec_first3([5, 5, 5]) == []\nassert op_gt5_dec_first3([3, 1, 2]) == []\nassert op_gt5_dec_first3([10]) == [9]\nassert op_gt5_dec_first3([2, 4, 6]) == [5]\nassert op_gt5_dec_first3([-7, 12, -7]) == [11]"}
{"id": "op_ages_trimends_inc", "entry_point": "op_ages_trimends_inc", "primitives": ["ages", "trimends", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then add one to each.", "solution": "def op_ages_trimends_inc(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_ages_trimends_inc([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_inc([]) == []\nassert op_ages_trimends_inc([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [66]\nassert op_ages_trimends_inc([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_dropfirst_trimends_pos", "entry_point": "op_dropfirst_trimends_pos", "primitives": ["dropfirst", "trimends", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then keep the positive numbers.", "solution": "def op_dropfirst_trimends_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_trimends_pos([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_pos([]) == []\nassert op_dropfirst_trimends_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_trimends_pos([5, 5, 5]) == []\nassert op_dropfirst_trimends_pos([3, 1, 2]) == []\nassert op_dropfirst_trimends_pos([10]) == []\nassert op_dropfirst_trimends_pos([2, 4, 6]) == []\nassert op_dropfirst_trimends_pos([-7, 12, -7]) == []"}
{"id": "op_trimends_negate_allpos", "entry_point": "op_trimends_negate_allpos", "primitives": ["trimends", "negate", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then return whether all values are positive.", "solution": "def op_trimends_negate_allpos(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_trimends_negate_allpos([1, 2, 3, 4]) == False\nassert op_trimends_negate_allpos([]) == True\nassert op_trimends_negate_allpos([-2, -1, 0, 1, 2]) == False\nassert op_trimends_negate_allpos([5, 5, 5]) == False\nassert op_trimends_negate_allpos([3, 1, 2]) == False\nassert op_trimends_negate_allpos([10]) == True\nassert op_trimends_negate_allpos([2, 4, 6]) == False\nassert op_trimends_negate_allpos([-7, 12, -7]) == False"}
{"id": "op_div3_trimends_odds", "entry_point": "op_div3_trimends_odds", "primitives": ["div3", "trimends", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop the first and last elements, then keep the odd numbers.", "solution": "def op_div3_trimends_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_trimends_odds([1, 2, 3, 4]) == []\nassert op_div3_trimends_odds([]) == []\nassert op_div3_trimends_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_trimends_odds([5, 5, 5]) == []\nassert op_div3_trimends_odds([3, 1, 2]) == []\nassert op_div3_trimends_odds([10]) == []\nassert op_div3_trimends_odds([2, 4, 6]) == []\nassert op_div3_trimends_odds([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_trimends_allpos", "entry_point": "op_dropwhileneg_trimends_allpos", "primitives": ["dropwhileneg", "trimends", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then return whether all values are positive.", "solution": "def op_dropwhileneg_trimends_allpos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return all(x > 0 for x in r)", "tests": "assert op_dropwhileneg_trimends_allpos([1, 2, 3, 4]) == True\nassert op_dropwhileneg_trimends_allpos([]) == True\nassert op_dropwhileneg_trimends_allpos([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_trimends_allpos([5, 5, 5]) == True\nassert op_dropwhileneg_trimends_allpos([3, 1, 2]) == True\nassert op_dropwhileneg_trimends_allpos([10]) == True\nassert op_dropwhileneg_trimends_allpos([2, 4, 6]) == True\nassert op_dropwhileneg_trimends_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_beforezero_dropwhileneg", "entry_point": "op_takewhilepos_beforezero_dropwhileneg", "primitives": ["takewhilepos", "beforezero", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then drop the leading negative values.", "solution": "def op_takewhilepos_beforezero_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_takewhilepos_beforezero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_beforezero_dropwhileneg([]) == []\nassert op_takewhilepos_beforezero_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_beforezero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_beforezero_dropwhileneg([10]) == [10]\nassert op_takewhilepos_beforezero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_beforezero_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_inc_first3_sorta", "entry_point": "op_inc_first3_sorta", "primitives": ["inc", "first3", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the first three, then sort ascending.", "solution": "def op_inc_first3_sorta(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_inc_first3_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_first3_sorta([]) == []\nassert op_inc_first3_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_first3_sorta([5, 5, 5]) == [6, 6, 6]\nassert op_inc_first3_sorta([3, 1, 2]) == [2, 3, 4]\nassert op_inc_first3_sorta([10]) == [11]\nassert op_inc_first3_sorta([2, 4, 6]) == [3, 5, 7]\nassert op_inc_first3_sorta([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_neg_dropwhileneg_first3", "entry_point": "op_neg_dropwhileneg_first3", "primitives": ["neg", "dropwhileneg", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values, then keep only the first three.", "solution": "def op_neg_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_neg_dropwhileneg_first3([1, 2, 3, 4]) == []\nassert op_neg_dropwhileneg_first3([]) == []\nassert op_neg_dropwhileneg_first3([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropwhileneg_first3([5, 5, 5]) == []\nassert op_neg_dropwhileneg_first3([3, 1, 2]) == []\nassert op_neg_dropwhileneg_first3([10]) == []\nassert op_neg_dropwhileneg_first3([2, 4, 6]) == []\nassert op_neg_dropwhileneg_first3([-7, 12, -7]) == []"}
{"id": "op_sortd_oremptyzero_neg", "entry_point": "op_sortd_oremptyzero_neg", "primitives": ["sortd", "oremptyzero", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then keep the negative numbers.", "solution": "def op_sortd_oremptyzero_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_oremptyzero_neg([1, 2, 3, 4]) == []\nassert op_sortd_oremptyzero_neg([]) == []\nassert op_sortd_oremptyzero_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_sortd_oremptyzero_neg([5, 5, 5]) == []\nassert op_sortd_oremptyzero_neg([3, 1, 2]) == []\nassert op_sortd_oremptyzero_neg([10]) == []\nassert op_sortd_oremptyzero_neg([2, 4, 6]) == []\nassert op_sortd_oremptyzero_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_takewhilepos_double", "entry_point": "op_beforezero_takewhilepos_double", "primitives": ["beforezero", "takewhilepos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then double each.", "solution": "def op_beforezero_takewhilepos_double(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_beforezero_takewhilepos_double([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_beforezero_takewhilepos_double([]) == []\nassert op_beforezero_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_double([5, 5, 5]) == [10, 10, 10]\nassert op_beforezero_takewhilepos_double([3, 1, 2]) == [6, 2, 4]\nassert op_beforezero_takewhilepos_double([10]) == [20]\nassert op_beforezero_takewhilepos_double([2, 4, 6]) == [4, 8, 12]\nassert op_beforezero_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_div3_negate_anyeven", "entry_point": "op_div3_negate_anyeven", "primitives": ["div3", "negate", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then return whether any value is even.", "solution": "def op_div3_negate_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_div3_negate_anyeven([1, 2, 3, 4]) == False\nassert op_div3_negate_anyeven([]) == False\nassert op_div3_negate_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_div3_negate_anyeven([5, 5, 5]) == False\nassert op_div3_negate_anyeven([3, 1, 2]) == False\nassert op_div3_negate_anyeven([10]) == False\nassert op_div3_negate_anyeven([2, 4, 6]) == True\nassert op_div3_negate_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropzeros_dropwhileneg_max", "entry_point": "op_dropzeros_dropwhileneg_max", "primitives": ["dropzeros", "dropwhileneg", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then return the maximum (0 if empty).", "solution": "def op_dropzeros_dropwhileneg_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_dropwhileneg_max([1, 2, 3, 4]) == 4\nassert op_dropzeros_dropwhileneg_max([]) == 0\nassert op_dropzeros_dropwhileneg_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_dropwhileneg_max([5, 5, 5]) == 5\nassert op_dropzeros_dropwhileneg_max([3, 1, 2]) == 3\nassert op_dropzeros_dropwhileneg_max([10]) == 10\nassert op_dropzeros_dropwhileneg_max([2, 4, 6]) == 6\nassert op_dropzeros_dropwhileneg_max([-7, 12, -7]) == 12"}
{"id": "op_sortd_inc_add10", "entry_point": "op_sortd_inc_add10", "primitives": ["sortd", "inc", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then add ten to each.", "solution": "def op_sortd_inc_add10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_sortd_inc_add10([1, 2, 3, 4]) == [15, 14, 13, 12]\nassert op_sortd_inc_add10([]) == []\nassert op_sortd_inc_add10([-2, -1, 0, 1, 2]) == [13, 12, 11, 10, 9]\nassert op_sortd_inc_add10([5, 5, 5]) == [16, 16, 16]\nassert op_sortd_inc_add10([3, 1, 2]) == [14, 13, 12]\nassert op_sortd_inc_add10([10]) == [21]\nassert op_sortd_inc_add10([2, 4, 6]) == [17, 15, 13]\nassert op_sortd_inc_add10([-7, 12, -7]) == [23, 4, 4]"}
{"id": "op_takewhilepos_dropwhileneg_first3", "entry_point": "op_takewhilepos_dropwhileneg_first3", "primitives": ["takewhilepos", "dropwhileneg", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the leading negative values, then keep only the first three.", "solution": "def op_takewhilepos_dropwhileneg_first3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[:3]\n    return r", "tests": "assert op_takewhilepos_dropwhileneg_first3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_dropwhileneg_first3([]) == []\nassert op_takewhilepos_dropwhileneg_first3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropwhileneg_first3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropwhileneg_first3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_dropwhileneg_first3([10]) == [10]\nassert op_takewhilepos_dropwhileneg_first3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_dropwhileneg_first3([-7, 12, -7]) == []"}
{"id": "op_ages_trimends_neg", "entry_point": "op_ages_trimends_neg", "primitives": ["ages", "trimends", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_ages_trimends_neg(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_ages_trimends_neg([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_trimends_neg([]) == []\nassert op_ages_trimends_neg([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_trimends_neg([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_sortabs_oremptyzero_evens", "entry_point": "op_sortabs_oremptyzero_evens", "primitives": ["sortabs", "oremptyzero", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_sortabs_oremptyzero_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_oremptyzero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sortabs_oremptyzero_evens([]) == [0]\nassert op_sortabs_oremptyzero_evens([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_sortabs_oremptyzero_evens([5, 5, 5]) == []\nassert op_sortabs_oremptyzero_evens([3, 1, 2]) == [2]\nassert op_sortabs_oremptyzero_evens([10]) == [10]\nassert op_sortabs_oremptyzero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero_evens([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_trimends_pos", "entry_point": "op_beforezero_trimends_pos", "primitives": ["beforezero", "trimends", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the first and last elements, then keep the positive numbers.", "solution": "def op_beforezero_trimends_pos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_beforezero_trimends_pos([1, 2, 3, 4]) == [2, 3]\nassert op_beforezero_trimends_pos([]) == []\nassert op_beforezero_trimends_pos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_trimends_pos([5, 5, 5]) == [5]\nassert op_beforezero_trimends_pos([3, 1, 2]) == [1]\nassert op_beforezero_trimends_pos([10]) == []\nassert op_beforezero_trimends_pos([2, 4, 6]) == [4]\nassert op_beforezero_trimends_pos([-7, 12, -7]) == [12]"}
{"id": "op_last3_trimends_max", "entry_point": "op_last3_trimends_max", "primitives": ["last3", "trimends", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_last3_trimends_max(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_last3_trimends_max([1, 2, 3, 4]) == 3\nassert op_last3_trimends_max([]) == 0\nassert op_last3_trimends_max([-2, -1, 0, 1, 2]) == 1\nassert op_last3_trimends_max([5, 5, 5]) == 5\nassert op_last3_trimends_max([3, 1, 2]) == 1\nassert op_last3_trimends_max([10]) == 0\nassert op_last3_trimends_max([2, 4, 6]) == 4\nassert op_last3_trimends_max([-7, 12, -7]) == 12"}
{"id": "op_takewhilepos_double_gt5", "entry_point": "op_takewhilepos_double_gt5", "primitives": ["takewhilepos", "double", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then keep values greater than five.", "solution": "def op_takewhilepos_double_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_takewhilepos_double_gt5([]) == []\nassert op_takewhilepos_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_double_gt5([3, 1, 2]) == [6]\nassert op_takewhilepos_double_gt5([10]) == [20]\nassert op_takewhilepos_double_gt5([2, 4, 6]) == [8, 12]\nassert op_takewhilepos_double_gt5([-7, 12, -7]) == []"}
{"id": "op_first3_rev_double", "entry_point": "op_first3_rev_double", "primitives": ["first3", "rev", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then double each.", "solution": "def op_first3_rev_double(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_first3_rev_double([1, 2, 3, 4]) == [6, 4, 2]\nassert op_first3_rev_double([]) == []\nassert op_first3_rev_double([-2, -1, 0, 1, 2]) == [0, -2, -4]\nassert op_first3_rev_double([5, 5, 5]) == [10, 10, 10]\nassert op_first3_rev_double([3, 1, 2]) == [4, 2, 6]\nassert op_first3_rev_double([10]) == [20]\nassert op_first3_rev_double([2, 4, 6]) == [12, 8, 4]\nassert op_first3_rev_double([-7, 12, -7]) == [-14, 24, -14]"}
{"id": "op_gt5_pos_sorta", "entry_point": "op_gt5_pos_sorta", "primitives": ["gt5", "pos", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then sort ascending.", "solution": "def op_gt5_pos_sorta(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = sorted(r)\n    return r", "tests": "assert op_gt5_pos_sorta([1, 2, 3, 4]) == []\nassert op_gt5_pos_sorta([]) == []\nassert op_gt5_pos_sorta([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_sorta([5, 5, 5]) == []\nassert op_gt5_pos_sorta([3, 1, 2]) == []\nassert op_gt5_pos_sorta([10]) == [10]\nassert op_gt5_pos_sorta([2, 4, 6]) == [6]\nassert op_gt5_pos_sorta([-7, 12, -7]) == [12]"}
{"id": "op_evens_div3_anyeven", "entry_point": "op_evens_div3_anyeven", "primitives": ["evens", "div3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then return whether any value is even.", "solution": "def op_evens_div3_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_evens_div3_anyeven([1, 2, 3, 4]) == False\nassert op_evens_div3_anyeven([]) == False\nassert op_evens_div3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_evens_div3_anyeven([5, 5, 5]) == False\nassert op_evens_div3_anyeven([3, 1, 2]) == False\nassert op_evens_div3_anyeven([10]) == False\nassert op_evens_div3_anyeven([2, 4, 6]) == True\nassert op_evens_div3_anyeven([-7, 12, -7]) == True"}
{"id": "op_double_sortabs_dropwhileneg", "entry_point": "op_double_sortabs_dropwhileneg", "primitives": ["double", "sortabs", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort by absolute value, then drop the leading negative values.", "solution": "def op_double_sortabs_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, key=abs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_double_sortabs_dropwhileneg([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_sortabs_dropwhileneg([]) == []\nassert op_double_sortabs_dropwhileneg([-2, -1, 0, 1, 2]) == [0, -2, 2, -4, 4]\nassert op_double_sortabs_dropwhileneg([5, 5, 5]) == [10, 10, 10]\nassert op_double_sortabs_dropwhileneg([3, 1, 2]) == [2, 4, 6]\nassert op_double_sortabs_dropwhileneg([10]) == [20]\nassert op_double_sortabs_dropwhileneg([2, 4, 6]) == [4, 8, 12]\nassert op_double_sortabs_dropwhileneg([-7, 12, -7]) == [24]"}
{"id": "op_sortd_neg_gt5", "entry_point": "op_sortd_neg_gt5", "primitives": ["sortd", "neg", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then keep values greater than five.", "solution": "def op_sortd_neg_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_neg_gt5([1, 2, 3, 4]) == []\nassert op_sortd_neg_gt5([]) == []\nassert op_sortd_neg_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortd_neg_gt5([5, 5, 5]) == []\nassert op_sortd_neg_gt5([3, 1, 2]) == []\nassert op_sortd_neg_gt5([10]) == []\nassert op_sortd_neg_gt5([2, 4, 6]) == []\nassert op_sortd_neg_gt5([-7, 12, -7]) == []"}
{"id": "op_beforezero_sortd_clamp10", "entry_point": "op_beforezero_sortd_clamp10", "primitives": ["beforezero", "sortd", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort descending, then cap each value at 10.", "solution": "def op_beforezero_sortd_clamp10(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_beforezero_sortd_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_beforezero_sortd_clamp10([]) == []\nassert op_beforezero_sortd_clamp10([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_beforezero_sortd_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sortd_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_beforezero_sortd_clamp10([10]) == [10]\nassert op_beforezero_sortd_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_beforezero_sortd_clamp10([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_padto3_dropfirst_max", "entry_point": "op_padto3_dropfirst_max", "primitives": ["padto3", "dropfirst", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element, then return the maximum (0 if empty).", "solution": "def op_padto3_dropfirst_max(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_padto3_dropfirst_max([1, 2, 3, 4]) == 4\nassert op_padto3_dropfirst_max([]) == 0\nassert op_padto3_dropfirst_max([-2, -1, 0, 1, 2]) == 2\nassert op_padto3_dropfirst_max([5, 5, 5]) == 5\nassert op_padto3_dropfirst_max([3, 1, 2]) == 2\nassert op_padto3_dropfirst_max([10]) == 0\nassert op_padto3_dropfirst_max([2, 4, 6]) == 6\nassert op_padto3_dropfirst_max([-7, 12, -7]) == 12"}
{"id": "op_double_gt5_firsteven", "entry_point": "op_double_gt5_firsteven", "primitives": ["double", "gt5", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then return the first even value (0 if none).", "solution": "def op_double_gt5_firsteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_double_gt5_firsteven([1, 2, 3, 4]) == 6\nassert op_double_gt5_firsteven([]) == 0\nassert op_double_gt5_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_double_gt5_firsteven([5, 5, 5]) == 10\nassert op_double_gt5_firsteven([3, 1, 2]) == 6\nassert op_double_gt5_firsteven([10]) == 20\nassert op_double_gt5_firsteven([2, 4, 6]) == 8\nassert op_double_gt5_firsteven([-7, 12, -7]) == 24"}
{"id": "op_beforezero_pos_dropfirst", "entry_point": "op_beforezero_pos_dropfirst", "primitives": ["beforezero", "pos", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep the positive numbers, then drop the first element.", "solution": "def op_beforezero_pos_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 0]\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_pos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_pos_dropfirst([]) == []\nassert op_beforezero_pos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_pos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_beforezero_pos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_beforezero_pos_dropfirst([10]) == []\nassert op_beforezero_pos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_beforezero_pos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_sortabs_div3", "entry_point": "op_oremptyzero_sortabs_div3", "primitives": ["oremptyzero", "sortabs", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then keep multiples of three.", "solution": "def op_oremptyzero_sortabs_div3(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_oremptyzero_sortabs_div3([1, 2, 3, 4]) == [3]\nassert op_oremptyzero_sortabs_div3([]) == [0]\nassert op_oremptyzero_sortabs_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_sortabs_div3([5, 5, 5]) == []\nassert op_oremptyzero_sortabs_div3([3, 1, 2]) == [3]\nassert op_oremptyzero_sortabs_div3([10]) == []\nassert op_oremptyzero_sortabs_div3([2, 4, 6]) == [6]\nassert op_oremptyzero_sortabs_div3([-7, 12, -7]) == [12]"}
{"id": "op_first3_last3_max", "entry_point": "op_first3_last3_max", "primitives": ["first3", "last3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep only the last three, then return the maximum (0 if empty).", "solution": "def op_first3_last3_max(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[-3:]\n    return max(r) if r else 0", "tests": "assert op_first3_last3_max([1, 2, 3, 4]) == 3\nassert op_first3_last3_max([]) == 0\nassert op_first3_last3_max([-2, -1, 0, 1, 2]) == 0\nassert op_first3_last3_max([5, 5, 5]) == 5\nassert op_first3_last3_max([3, 1, 2]) == 3\nassert op_first3_last3_max([10]) == 10\nassert op_first3_last3_max([2, 4, 6]) == 6\nassert op_first3_last3_max([-7, 12, -7]) == 12"}
{"id": "op_square_inc_sortd", "entry_point": "op_square_inc_sortd", "primitives": ["square", "inc", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then add one to each, then sort descending.", "solution": "def op_square_inc_sortd(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x + 1 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_square_inc_sortd([1, 2, 3, 4]) == [17, 10, 5, 2]\nassert op_square_inc_sortd([]) == []\nassert op_square_inc_sortd([-2, -1, 0, 1, 2]) == [5, 5, 2, 2, 1]\nassert op_square_inc_sortd([5, 5, 5]) == [26, 26, 26]\nassert op_square_inc_sortd([3, 1, 2]) == [10, 5, 2]\nassert op_square_inc_sortd([10]) == [101]\nassert op_square_inc_sortd([2, 4, 6]) == [37, 17, 5]\nassert op_square_inc_sortd([-7, 12, -7]) == [145, 50, 50]"}
{"id": "op_div3_last3_double", "entry_point": "op_div3_last3_double", "primitives": ["div3", "last3", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep only the last three, then double each.", "solution": "def op_div3_last3_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[-3:]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_last3_double([1, 2, 3, 4]) == [6]\nassert op_div3_last3_double([]) == []\nassert op_div3_last3_double([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_last3_double([5, 5, 5]) == []\nassert op_div3_last3_double([3, 1, 2]) == [6]\nassert op_div3_last3_double([10]) == []\nassert op_div3_last3_double([2, 4, 6]) == [12]\nassert op_div3_last3_double([-7, 12, -7]) == [24]"}
{"id": "op_firstchar_sortlen_nonempty", "entry_point": "op_firstchar_sortlen_nonempty", "primitives": ["firstchar", "sortlen", "nonempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort by length, shortest first, then drop empty strings.", "solution": "def op_firstchar_sortlen_nonempty(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r, key=len)\n    r = [s for s in r if s]\n    return r", "tests": "assert op_firstchar_sortlen_nonempty(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_sortlen_nonempty([]) == []\nassert op_firstchar_sortlen_nonempty(['  a ', '', 'BC', 'bc']) == [' ', 'B', 'b']\nassert op_firstchar_sortlen_nonempty(['one', 'one', 'Two']) == ['o', 'o', 'T']\nassert op_firstchar_sortlen_nonempty(['x']) == ['x']\nassert op_firstchar_sortlen_nonempty(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_square_odds_dropwhileneg", "entry_point": "op_square_odds_dropwhileneg", "primitives": ["square", "odds", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then drop the leading negative values.", "solution": "def op_square_odds_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_odds_dropwhileneg([1, 2, 3, 4]) == [1, 9]\nassert op_square_odds_dropwhileneg([]) == []\nassert op_square_odds_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 1]\nassert op_square_odds_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_odds_dropwhileneg([3, 1, 2]) == [9, 1]\nassert op_square_odds_dropwhileneg([10]) == []\nassert op_square_odds_dropwhileneg([2, 4, 6]) == []\nassert op_square_odds_dropwhileneg([-7, 12, -7]) == [49, 49]"}
{"id": "op_padto3_inc_allpos", "entry_point": "op_padto3_inc_allpos", "primitives": ["padto3", "inc", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then return whether all values are positive.", "solution": "def op_padto3_inc_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_inc_allpos([1, 2, 3, 4]) == True\nassert op_padto3_inc_allpos([]) == True\nassert op_padto3_inc_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_inc_allpos([5, 5, 5]) == True\nassert op_padto3_inc_allpos([3, 1, 2]) == True\nassert op_padto3_inc_allpos([10]) == True\nassert op_padto3_inc_allpos([2, 4, 6]) == True\nassert op_padto3_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_pos_oremptyzero", "entry_point": "op_last3_pos_oremptyzero", "primitives": ["last3", "pos", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_last3_pos_oremptyzero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_last3_pos_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_pos_oremptyzero([]) == [0]\nassert op_last3_pos_oremptyzero([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_last3_pos_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_last3_pos_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_last3_pos_oremptyzero([10]) == [10]\nassert op_last3_pos_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_last3_pos_oremptyzero([-7, 12, -7]) == [12]"}
{"id": "op_lower_nonempty_firstchar", "entry_point": "op_lower_nonempty_firstchar", "primitives": ["lower", "nonempty", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then drop empty strings, then keep the first character of each (dropping empties).", "solution": "def op_lower_nonempty_firstchar(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s for s in r if s]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_lower_nonempty_firstchar(['Hello', 'world']) == ['h', 'w']\nassert op_lower_nonempty_firstchar([]) == []\nassert op_lower_nonempty_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'b', 'b']\nassert op_lower_nonempty_firstchar(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_lower_nonempty_firstchar(['x']) == ['x']\nassert op_lower_nonempty_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_sortd_inc_div3", "entry_point": "op_sortd_inc_div3", "primitives": ["sortd", "inc", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then keep multiples of three.", "solution": "def op_sortd_inc_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_inc_div3([1, 2, 3, 4]) == [3]\nassert op_sortd_inc_div3([]) == []\nassert op_sortd_inc_div3([-2, -1, 0, 1, 2]) == [3, 0]\nassert op_sortd_inc_div3([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_inc_div3([3, 1, 2]) == [3]\nassert op_sortd_inc_div3([10]) == []\nassert op_sortd_inc_div3([2, 4, 6]) == [3]\nassert op_sortd_inc_div3([-7, 12, -7]) == [-6, -6]"}
{"id": "op_dropzeros_double_uniq", "entry_point": "op_dropzeros_double_uniq", "primitives": ["dropzeros", "double", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then drop duplicates keeping first occurrence.", "solution": "def op_dropzeros_double_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropzeros_double_uniq([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropzeros_double_uniq([]) == []\nassert op_dropzeros_double_uniq([-2, -1, 0, 1, 2]) == [-4, -2, 2, 4]\nassert op_dropzeros_double_uniq([5, 5, 5]) == [10]\nassert op_dropzeros_double_uniq([3, 1, 2]) == [6, 2, 4]\nassert op_dropzeros_double_uniq([10]) == [20]\nassert op_dropzeros_double_uniq([2, 4, 6]) == [4, 8, 12]\nassert op_dropzeros_double_uniq([-7, 12, -7]) == [-14, 24]"}
{"id": "op_div3_padto3_sum", "entry_point": "op_div3_padto3_sum", "primitives": ["div3", "padto3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then pad with zeros to at least three elements, then return their sum.", "solution": "def op_div3_padto3_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(r)", "tests": "assert op_div3_padto3_sum([1, 2, 3, 4]) == 3\nassert op_div3_padto3_sum([]) == 0\nassert op_div3_padto3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_div3_padto3_sum([5, 5, 5]) == 0\nassert op_div3_padto3_sum([3, 1, 2]) == 3\nassert op_div3_padto3_sum([10]) == 0\nassert op_div3_padto3_sum([2, 4, 6]) == 6\nassert op_div3_padto3_sum([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_absval_alldistinct", "entry_point": "op_dropfirst_absval_alldistinct", "primitives": ["dropfirst", "absval", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then return whether all values are distinct.", "solution": "def op_dropfirst_absval_alldistinct(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_dropfirst_absval_alldistinct([1, 2, 3, 4]) == True\nassert op_dropfirst_absval_alldistinct([]) == True\nassert op_dropfirst_absval_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_dropfirst_absval_alldistinct([5, 5, 5]) == False\nassert op_dropfirst_absval_alldistinct([3, 1, 2]) == True\nassert op_dropfirst_absval_alldistinct([10]) == True\nassert op_dropfirst_absval_alldistinct([2, 4, 6]) == True\nassert op_dropfirst_absval_alldistinct([-7, 12, -7]) == True"}
{"id": "op_absval_oremptyzero_allpos", "entry_point": "op_absval_oremptyzero_allpos", "primitives": ["absval", "oremptyzero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then if empty, use a single zero, then return whether all values are positive.", "solution": "def op_absval_oremptyzero_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r if r else [0]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_oremptyzero_allpos([1, 2, 3, 4]) == True\nassert op_absval_oremptyzero_allpos([]) == False\nassert op_absval_oremptyzero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_absval_oremptyzero_allpos([5, 5, 5]) == True\nassert op_absval_oremptyzero_allpos([3, 1, 2]) == True\nassert op_absval_oremptyzero_allpos([10]) == True\nassert op_absval_oremptyzero_allpos([2, 4, 6]) == True\nassert op_absval_oremptyzero_allpos([-7, 12, -7]) == True"}
{"id": "op_odds_negate_dropzeros", "entry_point": "op_odds_negate_dropzeros", "primitives": ["odds", "negate", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then negate each, then drop the zeros.", "solution": "def op_odds_negate_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_odds_negate_dropzeros([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_negate_dropzeros([]) == []\nassert op_odds_negate_dropzeros([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_odds_negate_dropzeros([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_negate_dropzeros([3, 1, 2]) == [-3, -1]\nassert op_odds_negate_dropzeros([10]) == []\nassert op_odds_negate_dropzeros([2, 4, 6]) == []\nassert op_odds_negate_dropzeros([-7, 12, -7]) == [7, 7]"}
{"id": "op_gt5_oremptyzero_sortd", "entry_point": "op_gt5_oremptyzero_sortd", "primitives": ["gt5", "oremptyzero", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then if empty, use a single zero, then sort descending.", "solution": "def op_gt5_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_oremptyzero_sortd([1, 2, 3, 4]) == [0]\nassert op_gt5_oremptyzero_sortd([]) == [0]\nassert op_gt5_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [0]\nassert op_gt5_oremptyzero_sortd([5, 5, 5]) == [0]\nassert op_gt5_oremptyzero_sortd([3, 1, 2]) == [0]\nassert op_gt5_oremptyzero_sortd([10]) == [10]\nassert op_gt5_oremptyzero_sortd([2, 4, 6]) == [6]\nassert op_gt5_oremptyzero_sortd([-7, 12, -7]) == [12]"}
{"id": "op_add10_evens_haszero", "entry_point": "op_add10_evens_haszero", "primitives": ["add10", "evens", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the even numbers, then return whether the list contains a zero.", "solution": "def op_add10_evens_haszero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return 0 in r", "tests": "assert op_add10_evens_haszero([1, 2, 3, 4]) == False\nassert op_add10_evens_haszero([]) == False\nassert op_add10_evens_haszero([-2, -1, 0, 1, 2]) == False\nassert op_add10_evens_haszero([5, 5, 5]) == False\nassert op_add10_evens_haszero([3, 1, 2]) == False\nassert op_add10_evens_haszero([10]) == False\nassert op_add10_evens_haszero([2, 4, 6]) == False\nassert op_add10_evens_haszero([-7, 12, -7]) == False"}
{"id": "op_first3_div3_issorted", "entry_point": "op_first3_div3_issorted", "primitives": ["first3", "div3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_first3_div3_issorted(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_first3_div3_issorted([1, 2, 3, 4]) == True\nassert op_first3_div3_issorted([]) == True\nassert op_first3_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_first3_div3_issorted([5, 5, 5]) == True\nassert op_first3_div3_issorted([3, 1, 2]) == True\nassert op_first3_div3_issorted([10]) == True\nassert op_first3_div3_issorted([2, 4, 6]) == True\nassert op_first3_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_gt5_dropwhileneg_haszero", "entry_point": "op_gt5_dropwhileneg_haszero", "primitives": ["gt5", "dropwhileneg", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_gt5_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_gt5_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_gt5_dropwhileneg_haszero([]) == False\nassert op_gt5_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_gt5_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_gt5_dropwhileneg_haszero([10]) == False\nassert op_gt5_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_gt5_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_dec_anyeven", "entry_point": "op_gt5_dec_anyeven", "primitives": ["gt5", "dec", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then subtract one from each, then return whether any value is even.", "solution": "def op_gt5_dec_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_dec_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_dec_anyeven([]) == False\nassert op_gt5_dec_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_dec_anyeven([5, 5, 5]) == False\nassert op_gt5_dec_anyeven([3, 1, 2]) == False\nassert op_gt5_dec_anyeven([10]) == False\nassert op_gt5_dec_anyeven([2, 4, 6]) == False\nassert op_gt5_dec_anyeven([-7, 12, -7]) == False"}
{"id": "op_evens_trimends_issorted", "entry_point": "op_evens_trimends_issorted", "primitives": ["evens", "trimends", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then drop the first and last elements, then return whether the list is sorted ascending.", "solution": "def op_evens_trimends_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:-1]\n    return r == sorted(r)", "tests": "assert op_evens_trimends_issorted([1, 2, 3, 4]) == True\nassert op_evens_trimends_issorted([]) == True\nassert op_evens_trimends_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_trimends_issorted([5, 5, 5]) == True\nassert op_evens_trimends_issorted([3, 1, 2]) == True\nassert op_evens_trimends_issorted([10]) == True\nassert op_evens_trimends_issorted([2, 4, 6]) == True\nassert op_evens_trimends_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_dropfirst_rev", "entry_point": "op_padto3_dropfirst_rev", "primitives": ["padto3", "dropfirst", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the first element, then reverse the order.", "solution": "def op_padto3_dropfirst_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_dropfirst_rev([1, 2, 3, 4]) == [4, 3, 2]\nassert op_padto3_dropfirst_rev([]) == [0, 0]\nassert op_padto3_dropfirst_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_padto3_dropfirst_rev([5, 5, 5]) == [5, 5]\nassert op_padto3_dropfirst_rev([3, 1, 2]) == [2, 1]\nassert op_padto3_dropfirst_rev([10]) == [0, 0]\nassert op_padto3_dropfirst_rev([2, 4, 6]) == [6, 4]\nassert op_padto3_dropfirst_rev([-7, 12, -7]) == [-7, 12]"}
{"id": "op_pos_uniq_padto3", "entry_point": "op_pos_uniq_padto3", "primitives": ["pos", "uniq", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then pad with zeros to at least three elements.", "solution": "def op_pos_uniq_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_pos_uniq_padto3([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_uniq_padto3([]) == [0, 0, 0]\nassert op_pos_uniq_padto3([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_uniq_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_pos_uniq_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_pos_uniq_padto3([10]) == [10, 0, 0]\nassert op_pos_uniq_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_pos_uniq_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_sorta_absval_allpos", "entry_point": "op_sorta_absval_allpos", "primitives": ["sorta", "absval", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take the absolute value of each, then return whether all values are positive.", "solution": "def op_sorta_absval_allpos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_sorta_absval_allpos([1, 2, 3, 4]) == True\nassert op_sorta_absval_allpos([]) == True\nassert op_sorta_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sorta_absval_allpos([5, 5, 5]) == True\nassert op_sorta_absval_allpos([3, 1, 2]) == True\nassert op_sorta_absval_allpos([10]) == True\nassert op_sorta_absval_allpos([2, 4, 6]) == True\nassert op_sorta_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_first3_dropzeros", "entry_point": "op_takewhilepos_first3_dropzeros", "primitives": ["takewhilepos", "first3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then drop the zeros.", "solution": "def op_takewhilepos_first3_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_first3_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_first3_dropzeros([]) == []\nassert op_takewhilepos_first3_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_first3_dropzeros([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_first3_dropzeros([10]) == [10]\nassert op_takewhilepos_first3_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_first3_dropzeros([-7, 12, -7]) == []"}
{"id": "op_absval_takewhilepos_firsteven", "entry_point": "op_absval_takewhilepos_firsteven", "primitives": ["absval", "takewhilepos", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then return the first even value (0 if none).", "solution": "def op_absval_takewhilepos_firsteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_absval_takewhilepos_firsteven([1, 2, 3, 4]) == 2\nassert op_absval_takewhilepos_firsteven([]) == 0\nassert op_absval_takewhilepos_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_takewhilepos_firsteven([5, 5, 5]) == 0\nassert op_absval_takewhilepos_firsteven([3, 1, 2]) == 2\nassert op_absval_takewhilepos_firsteven([10]) == 10\nassert op_absval_takewhilepos_firsteven([2, 4, 6]) == 2\nassert op_absval_takewhilepos_firsteven([-7, 12, -7]) == 12"}
{"id": "op_uniq_clamp10_last3", "entry_point": "op_uniq_clamp10_last3", "primitives": ["uniq", "clamp10", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then keep only the last three.", "solution": "def op_uniq_clamp10_last3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_uniq_clamp10_last3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_clamp10_last3([]) == []\nassert op_uniq_clamp10_last3([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_uniq_clamp10_last3([5, 5, 5]) == [5]\nassert op_uniq_clamp10_last3([3, 1, 2]) == [3, 1, 2]\nassert op_uniq_clamp10_last3([10]) == [10]\nassert op_uniq_clamp10_last3([2, 4, 6]) == [2, 4, 6]\nassert op_uniq_clamp10_last3([-7, 12, -7]) == [-7, 10]"}
{"id": "op_padto3_oremptyzero_pos", "entry_point": "op_padto3_oremptyzero_pos", "primitives": ["padto3", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_padto3_oremptyzero_pos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_padto3_oremptyzero_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_oremptyzero_pos([]) == []\nassert op_padto3_oremptyzero_pos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_padto3_oremptyzero_pos([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_oremptyzero_pos([3, 1, 2]) == [3, 1, 2]\nassert op_padto3_oremptyzero_pos([10]) == [10]\nassert op_padto3_oremptyzero_pos([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_oremptyzero_pos([-7, 12, -7]) == [12]"}
{"id": "op_absval_clamp10_sum", "entry_point": "op_absval_clamp10_sum", "primitives": ["absval", "clamp10", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then return their sum.", "solution": "def op_absval_clamp10_sum(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    return sum(r)", "tests": "assert op_absval_clamp10_sum([1, 2, 3, 4]) == 10\nassert op_absval_clamp10_sum([]) == 0\nassert op_absval_clamp10_sum([-2, -1, 0, 1, 2]) == 6\nassert op_absval_clamp10_sum([5, 5, 5]) == 15\nassert op_absval_clamp10_sum([3, 1, 2]) == 6\nassert op_absval_clamp10_sum([10]) == 10\nassert op_absval_clamp10_sum([2, 4, 6]) == 12\nassert op_absval_clamp10_sum([-7, 12, -7]) == 24"}
{"id": "op_dec_evens_max", "entry_point": "op_dec_evens_max", "primitives": ["dec", "evens", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_dec_evens_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_dec_evens_max([1, 2, 3, 4]) == 2\nassert op_dec_evens_max([]) == 0\nassert op_dec_evens_max([-2, -1, 0, 1, 2]) == 0\nassert op_dec_evens_max([5, 5, 5]) == 4\nassert op_dec_evens_max([3, 1, 2]) == 2\nassert op_dec_evens_max([10]) == 0\nassert op_dec_evens_max([2, 4, 6]) == 0\nassert op_dec_evens_max([-7, 12, -7]) == -8"}
{"id": "op_sortabs_evens_rev", "entry_point": "op_sortabs_evens_rev", "primitives": ["sortabs", "evens", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then reverse the order.", "solution": "def op_sortabs_evens_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_evens_rev([1, 2, 3, 4]) == [4, 2]\nassert op_sortabs_evens_rev([]) == []\nassert op_sortabs_evens_rev([-2, -1, 0, 1, 2]) == [2, -2, 0]\nassert op_sortabs_evens_rev([5, 5, 5]) == []\nassert op_sortabs_evens_rev([3, 1, 2]) == [2]\nassert op_sortabs_evens_rev([10]) == [10]\nassert op_sortabs_evens_rev([2, 4, 6]) == [6, 4, 2]\nassert op_sortabs_evens_rev([-7, 12, -7]) == [12]"}
{"id": "op_add10_last3_counteven", "entry_point": "op_add10_last3_counteven", "primitives": ["add10", "last3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep only the last three, then return how many values are even.", "solution": "def op_add10_last3_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[-3:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_last3_counteven([1, 2, 3, 4]) == 2\nassert op_add10_last3_counteven([]) == 0\nassert op_add10_last3_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_add10_last3_counteven([5, 5, 5]) == 0\nassert op_add10_last3_counteven([3, 1, 2]) == 1\nassert op_add10_last3_counteven([10]) == 1\nassert op_add10_last3_counteven([2, 4, 6]) == 3\nassert op_add10_last3_counteven([-7, 12, -7]) == 1"}
{"id": "op_pos_takewhilepos_absval", "entry_point": "op_pos_takewhilepos_absval", "primitives": ["pos", "takewhilepos", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive, then take the absolute value of each.", "solution": "def op_pos_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_takewhilepos_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_takewhilepos_absval([]) == []\nassert op_pos_takewhilepos_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_takewhilepos_absval([5, 5, 5]) == [5, 5, 5]\nassert op_pos_takewhilepos_absval([3, 1, 2]) == [3, 1, 2]\nassert op_pos_takewhilepos_absval([10]) == [10]\nassert op_pos_takewhilepos_absval([2, 4, 6]) == [2, 4, 6]\nassert op_pos_takewhilepos_absval([-7, 12, -7]) == [12]"}
{"id": "op_square_takewhilepos_first3", "entry_point": "op_square_takewhilepos_first3", "primitives": ["square", "takewhilepos", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then keep only the first three.", "solution": "def op_square_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_square_takewhilepos_first3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_square_takewhilepos_first3([]) == []\nassert op_square_takewhilepos_first3([-2, -1, 0, 1, 2]) == [4, 1]\nassert op_square_takewhilepos_first3([5, 5, 5]) == [25, 25, 25]\nassert op_square_takewhilepos_first3([3, 1, 2]) == [9, 1, 4]\nassert op_square_takewhilepos_first3([10]) == [100]\nassert op_square_takewhilepos_first3([2, 4, 6]) == [4, 16, 36]\nassert op_square_takewhilepos_first3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_last3_oremptyzero_anyeven", "entry_point": "op_last3_oremptyzero_anyeven", "primitives": ["last3", "oremptyzero", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return whether any value is even.", "solution": "def op_last3_oremptyzero_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_oremptyzero_anyeven([1, 2, 3, 4]) == True\nassert op_last3_oremptyzero_anyeven([]) == True\nassert op_last3_oremptyzero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_oremptyzero_anyeven([5, 5, 5]) == False\nassert op_last3_oremptyzero_anyeven([3, 1, 2]) == True\nassert op_last3_oremptyzero_anyeven([10]) == True\nassert op_last3_oremptyzero_anyeven([2, 4, 6]) == True\nassert op_last3_oremptyzero_anyeven([-7, 12, -7]) == True"}
{"id": "op_evens_sortd_odds", "entry_point": "op_evens_sortd_odds", "primitives": ["evens", "sortd", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort descending, then keep the odd numbers.", "solution": "def op_evens_sortd_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_sortd_odds([1, 2, 3, 4]) == []\nassert op_evens_sortd_odds([]) == []\nassert op_evens_sortd_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_sortd_odds([5, 5, 5]) == []\nassert op_evens_sortd_odds([3, 1, 2]) == []\nassert op_evens_sortd_odds([10]) == []\nassert op_evens_sortd_odds([2, 4, 6]) == []\nassert op_evens_sortd_odds([-7, 12, -7]) == []"}
{"id": "op_ages_uniq_counteven", "entry_point": "op_ages_uniq_counteven", "primitives": ["ages", "uniq", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_ages_uniq_counteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_ages_uniq_counteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 2\nassert op_ages_uniq_counteven([]) == 0\nassert op_ages_uniq_counteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 1\nassert op_ages_uniq_counteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_odds_dec_max", "entry_point": "op_odds_dec_max", "primitives": ["odds", "dec", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each, then return the maximum (0 if empty).", "solution": "def op_odds_dec_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_odds_dec_max([1, 2, 3, 4]) == 2\nassert op_odds_dec_max([]) == 0\nassert op_odds_dec_max([-2, -1, 0, 1, 2]) == 0\nassert op_odds_dec_max([5, 5, 5]) == 4\nassert op_odds_dec_max([3, 1, 2]) == 2\nassert op_odds_dec_max([10]) == 0\nassert op_odds_dec_max([2, 4, 6]) == 0\nassert op_odds_dec_max([-7, 12, -7]) == -8"}
{"id": "op_rev_padto3_square", "entry_point": "op_rev_padto3_square", "primitives": ["rev", "padto3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then pad with zeros to at least three elements, then square each.", "solution": "def op_rev_padto3_square(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_rev_padto3_square([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_rev_padto3_square([]) == [0, 0, 0]\nassert op_rev_padto3_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_rev_padto3_square([5, 5, 5]) == [25, 25, 25]\nassert op_rev_padto3_square([3, 1, 2]) == [4, 1, 9]\nassert op_rev_padto3_square([10]) == [100, 0, 0]\nassert op_rev_padto3_square([2, 4, 6]) == [36, 16, 4]\nassert op_rev_padto3_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_negate_dropwhileneg_square", "entry_point": "op_negate_dropwhileneg_square", "primitives": ["negate", "dropwhileneg", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the leading negative values, then square each.", "solution": "def op_negate_dropwhileneg_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_dropwhileneg_square([1, 2, 3, 4]) == []\nassert op_negate_dropwhileneg_square([]) == []\nassert op_negate_dropwhileneg_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_dropwhileneg_square([5, 5, 5]) == []\nassert op_negate_dropwhileneg_square([3, 1, 2]) == []\nassert op_negate_dropwhileneg_square([10]) == []\nassert op_negate_dropwhileneg_square([2, 4, 6]) == []\nassert op_negate_dropwhileneg_square([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_dropwhileneg_uniq_absval", "entry_point": "op_dropwhileneg_uniq_absval", "primitives": ["dropwhileneg", "uniq", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop duplicates keeping first occurrence, then take the absolute value of each.", "solution": "def op_dropwhileneg_uniq_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_uniq_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_uniq_absval([]) == []\nassert op_dropwhileneg_uniq_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_uniq_absval([5, 5, 5]) == [5]\nassert op_dropwhileneg_uniq_absval([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_uniq_absval([10]) == [10]\nassert op_dropwhileneg_uniq_absval([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_uniq_absval([-7, 12, -7]) == [12, 7]"}
{"id": "op_sortd_odds_dropfirst", "entry_point": "op_sortd_odds_dropfirst", "primitives": ["sortd", "odds", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the odd numbers, then drop the first element.", "solution": "def op_sortd_odds_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:]\n    return r", "tests": "assert op_sortd_odds_dropfirst([1, 2, 3, 4]) == [1]\nassert op_sortd_odds_dropfirst([]) == []\nassert op_sortd_odds_dropfirst([-2, -1, 0, 1, 2]) == [-1]\nassert op_sortd_odds_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortd_odds_dropfirst([3, 1, 2]) == [1]\nassert op_sortd_odds_dropfirst([10]) == []\nassert op_sortd_odds_dropfirst([2, 4, 6]) == []\nassert op_sortd_odds_dropfirst([-7, 12, -7]) == [-7]"}
{"id": "op_absval_takewhilepos_rev", "entry_point": "op_absval_takewhilepos_rev", "primitives": ["absval", "takewhilepos", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then reverse the order.", "solution": "def op_absval_takewhilepos_rev(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_absval_takewhilepos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_takewhilepos_rev([]) == []\nassert op_absval_takewhilepos_rev([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_absval_takewhilepos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_absval_takewhilepos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_absval_takewhilepos_rev([10]) == [10]\nassert op_absval_takewhilepos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_absval_takewhilepos_rev([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_add10_dropwhileneg_negate", "entry_point": "op_add10_dropwhileneg_negate", "primitives": ["add10", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the leading negative values, then negate each.", "solution": "def op_add10_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_add10_dropwhileneg_negate([1, 2, 3, 4]) == [-11, -12, -13, -14]\nassert op_add10_dropwhileneg_negate([]) == []\nassert op_add10_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [-8, -9, -10, -11, -12]\nassert op_add10_dropwhileneg_negate([5, 5, 5]) == [-15, -15, -15]\nassert op_add10_dropwhileneg_negate([3, 1, 2]) == [-13, -11, -12]\nassert op_add10_dropwhileneg_negate([10]) == [-20]\nassert op_add10_dropwhileneg_negate([2, 4, 6]) == [-12, -14, -16]\nassert op_add10_dropwhileneg_negate([-7, 12, -7]) == [-3, -22, -3]"}
{"id": "op_firstchar_sortalpha_strip", "entry_point": "op_firstchar_sortalpha_strip", "primitives": ["firstchar", "sortalpha", "strip"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then sort alphabetically, then trim whitespace from each.", "solution": "def op_firstchar_sortalpha_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_sortalpha_strip(['Hello', 'world']) == ['H', 'w']\nassert op_firstchar_sortalpha_strip([]) == []\nassert op_firstchar_sortalpha_strip(['  a ', '', 'BC', 'bc']) == ['', 'B', 'b']\nassert op_firstchar_sortalpha_strip(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_firstchar_sortalpha_strip(['x']) == ['x']\nassert op_firstchar_sortalpha_strip(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_absval_clamp10_sortd", "entry_point": "op_absval_clamp10_sortd", "primitives": ["absval", "clamp10", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then cap each value at 10, then sort descending.", "solution": "def op_absval_clamp10_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_clamp10_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_absval_clamp10_sortd([]) == []\nassert op_absval_clamp10_sortd([-2, -1, 0, 1, 2]) == [2, 2, 1, 1, 0]\nassert op_absval_clamp10_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_absval_clamp10_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_absval_clamp10_sortd([10]) == [10]\nassert op_absval_clamp10_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_absval_clamp10_sortd([-7, 12, -7]) == [10, 7, 7]"}
{"id": "op_sortd_padto3_div3", "entry_point": "op_sortd_padto3_div3", "primitives": ["sortd", "padto3", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then keep multiples of three.", "solution": "def op_sortd_padto3_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_padto3_div3([1, 2, 3, 4]) == [3]\nassert op_sortd_padto3_div3([]) == [0, 0, 0]\nassert op_sortd_padto3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_padto3_div3([5, 5, 5]) == []\nassert op_sortd_padto3_div3([3, 1, 2]) == [3]\nassert op_sortd_padto3_div3([10]) == [0, 0]\nassert op_sortd_padto3_div3([2, 4, 6]) == [6]\nassert op_sortd_padto3_div3([-7, 12, -7]) == [12]"}
{"id": "op_dropwhileneg_trimends_counteven", "entry_point": "op_dropwhileneg_trimends_counteven", "primitives": ["dropwhileneg", "trimends", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then return how many values are even.", "solution": "def op_dropwhileneg_trimends_counteven(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropwhileneg_trimends_counteven([1, 2, 3, 4]) == 1\nassert op_dropwhileneg_trimends_counteven([]) == 0\nassert op_dropwhileneg_trimends_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_trimends_counteven([5, 5, 5]) == 0\nassert op_dropwhileneg_trimends_counteven([3, 1, 2]) == 0\nassert op_dropwhileneg_trimends_counteven([10]) == 0\nassert op_dropwhileneg_trimends_counteven([2, 4, 6]) == 1\nassert op_dropwhileneg_trimends_counteven([-7, 12, -7]) == 0"}
{"id": "op_sortabs_square_anyeven", "entry_point": "op_sortabs_square_anyeven", "primitives": ["sortabs", "square", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then square each, then return whether any value is even.", "solution": "def op_sortabs_square_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * x for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_square_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_square_anyeven([]) == False\nassert op_sortabs_square_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_square_anyeven([5, 5, 5]) == False\nassert op_sortabs_square_anyeven([3, 1, 2]) == True\nassert op_sortabs_square_anyeven([10]) == True\nassert op_sortabs_square_anyeven([2, 4, 6]) == True\nassert op_sortabs_square_anyeven([-7, 12, -7]) == True"}
{"id": "op_beforezero_sorta_absval", "entry_point": "op_beforezero_sorta_absval", "primitives": ["beforezero", "sorta", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort ascending, then take the absolute value of each.", "solution": "def op_beforezero_sorta_absval(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_beforezero_sorta_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_beforezero_sorta_absval([]) == []\nassert op_beforezero_sorta_absval([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_beforezero_sorta_absval([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_sorta_absval([3, 1, 2]) == [1, 2, 3]\nassert op_beforezero_sorta_absval([10]) == [10]\nassert op_beforezero_sorta_absval([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_sorta_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_clamp10_dropzeros_uniq", "entry_point": "op_clamp10_dropzeros_uniq", "primitives": ["clamp10", "dropzeros", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then drop duplicates keeping first occurrence.", "solution": "def op_clamp10_dropzeros_uniq(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_clamp10_dropzeros_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropzeros_uniq([]) == []\nassert op_clamp10_dropzeros_uniq([-2, -1, 0, 1, 2]) == [-2, -1, 1, 2]\nassert op_clamp10_dropzeros_uniq([5, 5, 5]) == [5]\nassert op_clamp10_dropzeros_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_dropzeros_uniq([10]) == [10]\nassert op_clamp10_dropzeros_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropzeros_uniq([-7, 12, -7]) == [-7, 10]"}
{"id": "op_dec_sortabs_uniq", "entry_point": "op_dec_sortabs_uniq", "primitives": ["dec", "sortabs", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_dec_sortabs_uniq(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dec_sortabs_uniq([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sortabs_uniq([]) == []\nassert op_dec_sortabs_uniq([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, -3]\nassert op_dec_sortabs_uniq([5, 5, 5]) == [4]\nassert op_dec_sortabs_uniq([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sortabs_uniq([10]) == [9]\nassert op_dec_sortabs_uniq([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sortabs_uniq([-7, 12, -7]) == [-8, 11]"}
{"id": "op_inc_clamp10_first3", "entry_point": "op_inc_clamp10_first3", "primitives": ["inc", "clamp10", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then cap each value at 10, then keep only the first three.", "solution": "def op_inc_clamp10_first3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_inc_clamp10_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_inc_clamp10_first3([]) == []\nassert op_inc_clamp10_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_clamp10_first3([5, 5, 5]) == [6, 6, 6]\nassert op_inc_clamp10_first3([3, 1, 2]) == [4, 2, 3]\nassert op_inc_clamp10_first3([10]) == [10]\nassert op_inc_clamp10_first3([2, 4, 6]) == [3, 5, 7]\nassert op_inc_clamp10_first3([-7, 12, -7]) == [-6, 10, -6]"}
{"id": "op_inc_pos_haszero", "entry_point": "op_inc_pos_haszero", "primitives": ["inc", "pos", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the positive numbers, then return whether the list contains a zero.", "solution": "def op_inc_pos_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 0]\n    return 0 in r", "tests": "assert op_inc_pos_haszero([1, 2, 3, 4]) == False\nassert op_inc_pos_haszero([]) == False\nassert op_inc_pos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_inc_pos_haszero([5, 5, 5]) == False\nassert op_inc_pos_haszero([3, 1, 2]) == False\nassert op_inc_pos_haszero([10]) == False\nassert op_inc_pos_haszero([2, 4, 6]) == False\nassert op_inc_pos_haszero([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_negate_dec", "entry_point": "op_oremptyzero_negate_dec", "primitives": ["oremptyzero", "negate", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then subtract one from each.", "solution": "def op_oremptyzero_negate_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_negate_dec([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_oremptyzero_negate_dec([]) == [-1]\nassert op_oremptyzero_negate_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_oremptyzero_negate_dec([5, 5, 5]) == [-6, -6, -6]\nassert op_oremptyzero_negate_dec([3, 1, 2]) == [-4, -2, -3]\nassert op_oremptyzero_negate_dec([10]) == [-11]\nassert op_oremptyzero_negate_dec([2, 4, 6]) == [-3, -5, -7]\nassert op_oremptyzero_negate_dec([-7, 12, -7]) == [6, -13, 6]"}
{"id": "op_evens_pos_max", "entry_point": "op_evens_pos_max", "primitives": ["evens", "pos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep the positive numbers, then return the maximum (0 if empty).", "solution": "def op_evens_pos_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 0]\n    return max(r) if r else 0", "tests": "assert op_evens_pos_max([1, 2, 3, 4]) == 4\nassert op_evens_pos_max([]) == 0\nassert op_evens_pos_max([-2, -1, 0, 1, 2]) == 2\nassert op_evens_pos_max([5, 5, 5]) == 0\nassert op_evens_pos_max([3, 1, 2]) == 2\nassert op_evens_pos_max([10]) == 10\nassert op_evens_pos_max([2, 4, 6]) == 6\nassert op_evens_pos_max([-7, 12, -7]) == 12"}
{"id": "op_dropfirst_trimends_prod", "entry_point": "op_dropfirst_trimends_prod", "primitives": ["dropfirst", "trimends", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then return their product.", "solution": "def op_dropfirst_trimends_prod(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    return __import__('math').prod(r)", "tests": "assert op_dropfirst_trimends_prod([1, 2, 3, 4]) == 3\nassert op_dropfirst_trimends_prod([]) == 1\nassert op_dropfirst_trimends_prod([-2, -1, 0, 1, 2]) == 0\nassert op_dropfirst_trimends_prod([5, 5, 5]) == 1\nassert op_dropfirst_trimends_prod([3, 1, 2]) == 1\nassert op_dropfirst_trimends_prod([10]) == 1\nassert op_dropfirst_trimends_prod([2, 4, 6]) == 1\nassert op_dropfirst_trimends_prod([-7, 12, -7]) == 1"}
{"id": "op_evens_div3_odds", "entry_point": "op_evens_div3_odds", "primitives": ["evens", "div3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then keep the odd numbers.", "solution": "def op_evens_div3_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_div3_odds([1, 2, 3, 4]) == []\nassert op_evens_div3_odds([]) == []\nassert op_evens_div3_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_div3_odds([5, 5, 5]) == []\nassert op_evens_div3_odds([3, 1, 2]) == []\nassert op_evens_div3_odds([10]) == []\nassert op_evens_div3_odds([2, 4, 6]) == []\nassert op_evens_div3_odds([-7, 12, -7]) == []"}
{"id": "op_evens_beforezero_padto3", "entry_point": "op_evens_beforezero_padto3", "primitives": ["evens", "beforezero", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep everything before the first zero, then pad with zeros to at least three elements.", "solution": "def op_evens_beforezero_padto3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_evens_beforezero_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_evens_beforezero_padto3([]) == [0, 0, 0]\nassert op_evens_beforezero_padto3([-2, -1, 0, 1, 2]) == [-2, 0, 0]\nassert op_evens_beforezero_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_evens_beforezero_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_evens_beforezero_padto3([10]) == [10, 0, 0]\nassert op_evens_beforezero_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_evens_beforezero_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_double_sortd_alldistinct", "entry_point": "op_double_sortd_alldistinct", "primitives": ["double", "sortd", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then sort descending, then return whether all values are distinct.", "solution": "def op_double_sortd_alldistinct(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = sorted(r, reverse=True)\n    return len(r) == len(set(r))", "tests": "assert op_double_sortd_alldistinct([1, 2, 3, 4]) == True\nassert op_double_sortd_alldistinct([]) == True\nassert op_double_sortd_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_double_sortd_alldistinct([5, 5, 5]) == False\nassert op_double_sortd_alldistinct([3, 1, 2]) == True\nassert op_double_sortd_alldistinct([10]) == True\nassert op_double_sortd_alldistinct([2, 4, 6]) == True\nassert op_double_sortd_alldistinct([-7, 12, -7]) == False"}
{"id": "op_odds_oremptyzero_uniq", "entry_point": "op_odds_oremptyzero_uniq", "primitives": ["odds", "oremptyzero", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then if empty, use a single zero, then drop duplicates keeping first occurrence.", "solution": "def op_odds_oremptyzero_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_odds_oremptyzero_uniq([1, 2, 3, 4]) == [1, 3]\nassert op_odds_oremptyzero_uniq([]) == [0]\nassert op_odds_oremptyzero_uniq([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_oremptyzero_uniq([5, 5, 5]) == [5]\nassert op_odds_oremptyzero_uniq([3, 1, 2]) == [3, 1]\nassert op_odds_oremptyzero_uniq([10]) == [0]\nassert op_odds_oremptyzero_uniq([2, 4, 6]) == [0]\nassert op_odds_oremptyzero_uniq([-7, 12, -7]) == [-7]"}
{"id": "op_double_absval_neg", "entry_point": "op_double_absval_neg", "primitives": ["double", "absval", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then take the absolute value of each, then keep the negative numbers.", "solution": "def op_double_absval_neg(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_double_absval_neg([1, 2, 3, 4]) == []\nassert op_double_absval_neg([]) == []\nassert op_double_absval_neg([-2, -1, 0, 1, 2]) == []\nassert op_double_absval_neg([5, 5, 5]) == []\nassert op_double_absval_neg([3, 1, 2]) == []\nassert op_double_absval_neg([10]) == []\nassert op_double_absval_neg([2, 4, 6]) == []\nassert op_double_absval_neg([-7, 12, -7]) == []"}
{"id": "op_odds_absval_haszero", "entry_point": "op_odds_absval_haszero", "primitives": ["odds", "absval", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then take the absolute value of each, then return whether the list contains a zero.", "solution": "def op_odds_absval_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [abs(x) for x in r]\n    return 0 in r", "tests": "assert op_odds_absval_haszero([1, 2, 3, 4]) == False\nassert op_odds_absval_haszero([]) == False\nassert op_odds_absval_haszero([-2, -1, 0, 1, 2]) == False\nassert op_odds_absval_haszero([5, 5, 5]) == False\nassert op_odds_absval_haszero([3, 1, 2]) == False\nassert op_odds_absval_haszero([10]) == False\nassert op_odds_absval_haszero([2, 4, 6]) == False\nassert op_odds_absval_haszero([-7, 12, -7]) == False"}
{"id": "op_gt5_evens_first3", "entry_point": "op_gt5_evens_first3", "primitives": ["gt5", "evens", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then keep only the first three.", "solution": "def op_gt5_evens_first3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:3]\n    return r", "tests": "assert op_gt5_evens_first3([1, 2, 3, 4]) == []\nassert op_gt5_evens_first3([]) == []\nassert op_gt5_evens_first3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_evens_first3([5, 5, 5]) == []\nassert op_gt5_evens_first3([3, 1, 2]) == []\nassert op_gt5_evens_first3([10]) == [10]\nassert op_gt5_evens_first3([2, 4, 6]) == [6]\nassert op_gt5_evens_first3([-7, 12, -7]) == [12]"}
{"id": "op_last3_evens_odds", "entry_point": "op_last3_evens_odds", "primitives": ["last3", "evens", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep the even numbers, then keep the odd numbers.", "solution": "def op_last3_evens_odds(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_last3_evens_odds([1, 2, 3, 4]) == []\nassert op_last3_evens_odds([]) == []\nassert op_last3_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_last3_evens_odds([5, 5, 5]) == []\nassert op_last3_evens_odds([3, 1, 2]) == []\nassert op_last3_evens_odds([10]) == []\nassert op_last3_evens_odds([2, 4, 6]) == []\nassert op_last3_evens_odds([-7, 12, -7]) == []"}
{"id": "op_div3_square_absval", "entry_point": "op_div3_square_absval", "primitives": ["div3", "square", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then square each, then take the absolute value of each.", "solution": "def op_div3_square_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x * x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_square_absval([1, 2, 3, 4]) == [9]\nassert op_div3_square_absval([]) == []\nassert op_div3_square_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_square_absval([5, 5, 5]) == []\nassert op_div3_square_absval([3, 1, 2]) == [9]\nassert op_div3_square_absval([10]) == []\nassert op_div3_square_absval([2, 4, 6]) == [36]\nassert op_div3_square_absval([-7, 12, -7]) == [144]"}
{"id": "op_neg_rev_dropwhileneg", "entry_point": "op_neg_rev_dropwhileneg", "primitives": ["neg", "rev", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then reverse the order, then drop the leading negative values.", "solution": "def op_neg_rev_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_rev_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_rev_dropwhileneg([]) == []\nassert op_neg_rev_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_neg_rev_dropwhileneg([5, 5, 5]) == []\nassert op_neg_rev_dropwhileneg([3, 1, 2]) == []\nassert op_neg_rev_dropwhileneg([10]) == []\nassert op_neg_rev_dropwhileneg([2, 4, 6]) == []\nassert op_neg_rev_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_clamp10_odds_last3", "entry_point": "op_clamp10_odds_last3", "primitives": ["clamp10", "odds", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then keep only the last three.", "solution": "def op_clamp10_odds_last3(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = r[-3:]\n    return r", "tests": "assert op_clamp10_odds_last3([1, 2, 3, 4]) == [1, 3]\nassert op_clamp10_odds_last3([]) == []\nassert op_clamp10_odds_last3([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_clamp10_odds_last3([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_odds_last3([3, 1, 2]) == [3, 1]\nassert op_clamp10_odds_last3([10]) == []\nassert op_clamp10_odds_last3([2, 4, 6]) == []\nassert op_clamp10_odds_last3([-7, 12, -7]) == [-7, -7]"}
{"id": "op_beforezero_rev_div3", "entry_point": "op_beforezero_rev_div3", "primitives": ["beforezero", "rev", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then reverse the order, then keep multiples of three.", "solution": "def op_beforezero_rev_div3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_beforezero_rev_div3([1, 2, 3, 4]) == [3]\nassert op_beforezero_rev_div3([]) == []\nassert op_beforezero_rev_div3([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_rev_div3([5, 5, 5]) == []\nassert op_beforezero_rev_div3([3, 1, 2]) == [3]\nassert op_beforezero_rev_div3([10]) == []\nassert op_beforezero_rev_div3([2, 4, 6]) == [6]\nassert op_beforezero_rev_div3([-7, 12, -7]) == [12]"}
{"id": "op_gt5_evens_alldistinct", "entry_point": "op_gt5_evens_alldistinct", "primitives": ["gt5", "evens", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the even numbers, then return whether all values are distinct.", "solution": "def op_gt5_evens_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 == 0]\n    return len(r) == len(set(r))", "tests": "assert op_gt5_evens_alldistinct([1, 2, 3, 4]) == True\nassert op_gt5_evens_alldistinct([]) == True\nassert op_gt5_evens_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_gt5_evens_alldistinct([5, 5, 5]) == True\nassert op_gt5_evens_alldistinct([3, 1, 2]) == True\nassert op_gt5_evens_alldistinct([10]) == True\nassert op_gt5_evens_alldistinct([2, 4, 6]) == True\nassert op_gt5_evens_alldistinct([-7, 12, -7]) == True"}
{"id": "op_dropwhileneg_odds_pos", "entry_point": "op_dropwhileneg_odds_pos", "primitives": ["dropwhileneg", "odds", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the odd numbers, then keep the positive numbers.", "solution": "def op_dropwhileneg_odds_pos(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropwhileneg_odds_pos([1, 2, 3, 4]) == [1, 3]\nassert op_dropwhileneg_odds_pos([]) == []\nassert op_dropwhileneg_odds_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_odds_pos([5, 5, 5]) == [5, 5, 5]\nassert op_dropwhileneg_odds_pos([3, 1, 2]) == [3, 1]\nassert op_dropwhileneg_odds_pos([10]) == []\nassert op_dropwhileneg_odds_pos([2, 4, 6]) == []\nassert op_dropwhileneg_odds_pos([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_double_dropzeros", "entry_point": "op_takewhilepos_double_dropzeros", "primitives": ["takewhilepos", "double", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then double each, then drop the zeros.", "solution": "def op_takewhilepos_double_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_double_dropzeros([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_takewhilepos_double_dropzeros([]) == []\nassert op_takewhilepos_double_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_double_dropzeros([5, 5, 5]) == [10, 10, 10]\nassert op_takewhilepos_double_dropzeros([3, 1, 2]) == [6, 2, 4]\nassert op_takewhilepos_double_dropzeros([10]) == [20]\nassert op_takewhilepos_double_dropzeros([2, 4, 6]) == [4, 8, 12]\nassert op_takewhilepos_double_dropzeros([-7, 12, -7]) == []"}
{"id": "op_odds_div3_max", "entry_point": "op_odds_div3_max", "primitives": ["odds", "div3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then return the maximum (0 if empty).", "solution": "def op_odds_div3_max(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return max(r) if r else 0", "tests": "assert op_odds_div3_max([1, 2, 3, 4]) == 3\nassert op_odds_div3_max([]) == 0\nassert op_odds_div3_max([-2, -1, 0, 1, 2]) == 0\nassert op_odds_div3_max([5, 5, 5]) == 0\nassert op_odds_div3_max([3, 1, 2]) == 3\nassert op_odds_div3_max([10]) == 0\nassert op_odds_div3_max([2, 4, 6]) == 0\nassert op_odds_div3_max([-7, 12, -7]) == 0"}
{"id": "op_dec_sortd_absval", "entry_point": "op_dec_sortd_absval", "primitives": ["dec", "sortd", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort descending, then take the absolute value of each.", "solution": "def op_dec_sortd_absval(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dec_sortd_absval([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_dec_sortd_absval([]) == []\nassert op_dec_sortd_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2, 3]\nassert op_dec_sortd_absval([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortd_absval([3, 1, 2]) == [2, 1, 0]\nassert op_dec_sortd_absval([10]) == [9]\nassert op_dec_sortd_absval([2, 4, 6]) == [5, 3, 1]\nassert op_dec_sortd_absval([-7, 12, -7]) == [11, 8, 8]"}
{"id": "op_square_pos_dropwhileneg", "entry_point": "op_square_pos_dropwhileneg", "primitives": ["square", "pos", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the positive numbers, then drop the leading negative values.", "solution": "def op_square_pos_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_pos_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_pos_dropwhileneg([]) == []\nassert op_square_pos_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 1, 4]\nassert op_square_pos_dropwhileneg([5, 5, 5]) == [25, 25, 25]\nassert op_square_pos_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_square_pos_dropwhileneg([10]) == [100]\nassert op_square_pos_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_square_pos_dropwhileneg([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_neg_inc_alldistinct", "entry_point": "op_neg_inc_alldistinct", "primitives": ["neg", "inc", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add one to each, then return whether all values are distinct.", "solution": "def op_neg_inc_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 1 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_neg_inc_alldistinct([1, 2, 3, 4]) == True\nassert op_neg_inc_alldistinct([]) == True\nassert op_neg_inc_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_neg_inc_alldistinct([5, 5, 5]) == True\nassert op_neg_inc_alldistinct([3, 1, 2]) == True\nassert op_neg_inc_alldistinct([10]) == True\nassert op_neg_inc_alldistinct([2, 4, 6]) == True\nassert op_neg_inc_alldistinct([-7, 12, -7]) == False"}
{"id": "op_dropfirst_sortd_trimends", "entry_point": "op_dropfirst_sortd_trimends", "primitives": ["dropfirst", "sortd", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort descending, then drop the first and last elements.", "solution": "def op_dropfirst_sortd_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_sortd_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_sortd_trimends([]) == []\nassert op_dropfirst_sortd_trimends([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_dropfirst_sortd_trimends([5, 5, 5]) == []\nassert op_dropfirst_sortd_trimends([3, 1, 2]) == []\nassert op_dropfirst_sortd_trimends([10]) == []\nassert op_dropfirst_sortd_trimends([2, 4, 6]) == []\nassert op_dropfirst_sortd_trimends([-7, 12, -7]) == []"}
{"id": "op_neg_sorta_anyeven", "entry_point": "op_neg_sorta_anyeven", "primitives": ["neg", "sorta", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort ascending, then return whether any value is even.", "solution": "def op_neg_sorta_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_neg_sorta_anyeven([1, 2, 3, 4]) == False\nassert op_neg_sorta_anyeven([]) == False\nassert op_neg_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_neg_sorta_anyeven([5, 5, 5]) == False\nassert op_neg_sorta_anyeven([3, 1, 2]) == False\nassert op_neg_sorta_anyeven([10]) == False\nassert op_neg_sorta_anyeven([2, 4, 6]) == False\nassert op_neg_sorta_anyeven([-7, 12, -7]) == False"}
{"id": "op_dropfirst_sorta_issorted", "entry_point": "op_dropfirst_sorta_issorted", "primitives": ["dropfirst", "sorta", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then return whether the list is sorted ascending.", "solution": "def op_dropfirst_sorta_issorted(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    return r == sorted(r)", "tests": "assert op_dropfirst_sorta_issorted([1, 2, 3, 4]) == True\nassert op_dropfirst_sorta_issorted([]) == True\nassert op_dropfirst_sorta_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_sorta_issorted([5, 5, 5]) == True\nassert op_dropfirst_sorta_issorted([3, 1, 2]) == True\nassert op_dropfirst_sorta_issorted([10]) == True\nassert op_dropfirst_sorta_issorted([2, 4, 6]) == True\nassert op_dropfirst_sorta_issorted([-7, 12, -7]) == True"}
{"id": "op_dropfirst_takewhilepos_absval", "entry_point": "op_dropfirst_takewhilepos_absval", "primitives": ["dropfirst", "takewhilepos", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take values while they are positive, then take the absolute value of each.", "solution": "def op_dropfirst_takewhilepos_absval(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropfirst_takewhilepos_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_takewhilepos_absval([]) == []\nassert op_dropfirst_takewhilepos_absval([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_takewhilepos_absval([5, 5, 5]) == [5, 5]\nassert op_dropfirst_takewhilepos_absval([3, 1, 2]) == [1, 2]\nassert op_dropfirst_takewhilepos_absval([10]) == []\nassert op_dropfirst_takewhilepos_absval([2, 4, 6]) == [4, 6]\nassert op_dropfirst_takewhilepos_absval([-7, 12, -7]) == [12]"}
{"id": "op_evens_rev_odds", "entry_point": "op_evens_rev_odds", "primitives": ["evens", "rev", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then reverse the order, then keep the odd numbers.", "solution": "def op_evens_rev_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_evens_rev_odds([1, 2, 3, 4]) == []\nassert op_evens_rev_odds([]) == []\nassert op_evens_rev_odds([-2, -1, 0, 1, 2]) == []\nassert op_evens_rev_odds([5, 5, 5]) == []\nassert op_evens_rev_odds([3, 1, 2]) == []\nassert op_evens_rev_odds([10]) == []\nassert op_evens_rev_odds([2, 4, 6]) == []\nassert op_evens_rev_odds([-7, 12, -7]) == []"}
{"id": "op_rev_gt5_beforezero", "entry_point": "op_rev_gt5_beforezero", "primitives": ["rev", "gt5", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_rev_gt5_beforezero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_rev_gt5_beforezero([1, 2, 3, 4]) == []\nassert op_rev_gt5_beforezero([]) == []\nassert op_rev_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_rev_gt5_beforezero([5, 5, 5]) == []\nassert op_rev_gt5_beforezero([3, 1, 2]) == []\nassert op_rev_gt5_beforezero([10]) == [10]\nassert op_rev_gt5_beforezero([2, 4, 6]) == [6]\nassert op_rev_gt5_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_absval_odds_dec", "entry_point": "op_absval_odds_dec", "primitives": ["absval", "odds", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the odd numbers, then subtract one from each.", "solution": "def op_absval_odds_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_odds_dec([1, 2, 3, 4]) == [0, 2]\nassert op_absval_odds_dec([]) == []\nassert op_absval_odds_dec([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_absval_odds_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_odds_dec([3, 1, 2]) == [2, 0]\nassert op_absval_odds_dec([10]) == []\nassert op_absval_odds_dec([2, 4, 6]) == []\nassert op_absval_odds_dec([-7, 12, -7]) == [6, 6]"}
{"id": "op_sortd_gt5_counteven", "entry_point": "op_sortd_gt5_counteven", "primitives": ["sortd", "gt5", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five, then return how many values are even.", "solution": "def op_sortd_gt5_counteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortd_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_sortd_gt5_counteven([]) == 0\nassert op_sortd_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_sortd_gt5_counteven([5, 5, 5]) == 0\nassert op_sortd_gt5_counteven([3, 1, 2]) == 0\nassert op_sortd_gt5_counteven([10]) == 1\nassert op_sortd_gt5_counteven([2, 4, 6]) == 1\nassert op_sortd_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_absval_first3_div3", "entry_point": "op_absval_first3_div3", "primitives": ["absval", "first3", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the first three, then keep multiples of three.", "solution": "def op_absval_first3_div3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:3]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_absval_first3_div3([1, 2, 3, 4]) == [3]\nassert op_absval_first3_div3([]) == []\nassert op_absval_first3_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_absval_first3_div3([5, 5, 5]) == []\nassert op_absval_first3_div3([3, 1, 2]) == [3]\nassert op_absval_first3_div3([10]) == []\nassert op_absval_first3_div3([2, 4, 6]) == [6]\nassert op_absval_first3_div3([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_beforezero_oremptyzero", "entry_point": "op_takewhilepos_beforezero_oremptyzero", "primitives": ["takewhilepos", "beforezero", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_takewhilepos_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_takewhilepos_beforezero_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_beforezero_oremptyzero([]) == [0]\nassert op_takewhilepos_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [0]\nassert op_takewhilepos_beforezero_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_beforezero_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_beforezero_oremptyzero([10]) == [10]\nassert op_takewhilepos_beforezero_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_beforezero_oremptyzero([-7, 12, -7]) == [0]"}
{"id": "op_rev_double_max", "entry_point": "op_rev_double_max", "primitives": ["rev", "double", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then return the maximum (0 if empty).", "solution": "def op_rev_double_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return max(r) if r else 0", "tests": "assert op_rev_double_max([1, 2, 3, 4]) == 8\nassert op_rev_double_max([]) == 0\nassert op_rev_double_max([-2, -1, 0, 1, 2]) == 4\nassert op_rev_double_max([5, 5, 5]) == 10\nassert op_rev_double_max([3, 1, 2]) == 6\nassert op_rev_double_max([10]) == 20\nassert op_rev_double_max([2, 4, 6]) == 12\nassert op_rev_double_max([-7, 12, -7]) == 24"}
{"id": "op_oremptyzero_inc_dropfirst", "entry_point": "op_oremptyzero_inc_dropfirst", "primitives": ["oremptyzero", "inc", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then add one to each, then drop the first element.", "solution": "def op_oremptyzero_inc_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x + 1 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_inc_dropfirst([1, 2, 3, 4]) == [3, 4, 5]\nassert op_oremptyzero_inc_dropfirst([]) == []\nassert op_oremptyzero_inc_dropfirst([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_oremptyzero_inc_dropfirst([5, 5, 5]) == [6, 6]\nassert op_oremptyzero_inc_dropfirst([3, 1, 2]) == [2, 3]\nassert op_oremptyzero_inc_dropfirst([10]) == []\nassert op_oremptyzero_inc_dropfirst([2, 4, 6]) == [5, 7]\nassert op_oremptyzero_inc_dropfirst([-7, 12, -7]) == [13, -6]"}
{"id": "op_last3_negate_sorta", "entry_point": "op_last3_negate_sorta", "primitives": ["last3", "negate", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then negate each, then sort ascending.", "solution": "def op_last3_negate_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [-x for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_negate_sorta([1, 2, 3, 4]) == [-4, -3, -2]\nassert op_last3_negate_sorta([]) == []\nassert op_last3_negate_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_last3_negate_sorta([5, 5, 5]) == [-5, -5, -5]\nassert op_last3_negate_sorta([3, 1, 2]) == [-3, -2, -1]\nassert op_last3_negate_sorta([10]) == [-10]\nassert op_last3_negate_sorta([2, 4, 6]) == [-6, -4, -2]\nassert op_last3_negate_sorta([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_takewhilepos_beforezero_dec", "entry_point": "op_takewhilepos_beforezero_dec", "primitives": ["takewhilepos", "beforezero", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then subtract one from each.", "solution": "def op_takewhilepos_beforezero_dec(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_takewhilepos_beforezero_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_takewhilepos_beforezero_dec([]) == []\nassert op_takewhilepos_beforezero_dec([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_beforezero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_beforezero_dec([3, 1, 2]) == [2, 0, 1]\nassert op_takewhilepos_beforezero_dec([10]) == [9]\nassert op_takewhilepos_beforezero_dec([2, 4, 6]) == [1, 3, 5]\nassert op_takewhilepos_beforezero_dec([-7, 12, -7]) == []"}
{"id": "op_sorta_dropwhileneg_evens", "entry_point": "op_sorta_dropwhileneg_evens", "primitives": ["sorta", "dropwhileneg", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the leading negative values, then keep the even numbers.", "solution": "def op_sorta_dropwhileneg_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_dropwhileneg_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_dropwhileneg_evens([]) == []\nassert op_sorta_dropwhileneg_evens([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_sorta_dropwhileneg_evens([5, 5, 5]) == []\nassert op_sorta_dropwhileneg_evens([3, 1, 2]) == [2]\nassert op_sorta_dropwhileneg_evens([10]) == [10]\nassert op_sorta_dropwhileneg_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_dropwhileneg_evens([-7, 12, -7]) == [12]"}
{"id": "op_ages_add10_pos", "entry_point": "op_ages_add10_pos", "primitives": ["ages", "add10", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then add ten to each, then keep the positive numbers.", "solution": "def op_ages_add10_pos(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_ages_add10_pos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [46, 22]\nassert op_ages_add10_pos([]) == []\nassert op_ages_add10_pos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [28, 75, 27]\nassert op_ages_add10_pos([{'name': 'Fi', 'age': 41}]) == [51]"}
{"id": "op_first3_inc_prod", "entry_point": "op_first3_inc_prod", "primitives": ["first3", "inc", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then return their product.", "solution": "def op_first3_inc_prod(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_first3_inc_prod([1, 2, 3, 4]) == 24\nassert op_first3_inc_prod([]) == 1\nassert op_first3_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_first3_inc_prod([5, 5, 5]) == 216\nassert op_first3_inc_prod([3, 1, 2]) == 24\nassert op_first3_inc_prod([10]) == 11\nassert op_first3_inc_prod([2, 4, 6]) == 105\nassert op_first3_inc_prod([-7, 12, -7]) == 468"}
{"id": "op_takewhilepos_first3_uniq", "entry_point": "op_takewhilepos_first3_uniq", "primitives": ["takewhilepos", "first3", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_takewhilepos_first3_uniq(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_takewhilepos_first3_uniq([1, 2, 3, 4]) == [1, 2, 3]\nassert op_takewhilepos_first3_uniq([]) == []\nassert op_takewhilepos_first3_uniq([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_first3_uniq([5, 5, 5]) == [5]\nassert op_takewhilepos_first3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_first3_uniq([10]) == [10]\nassert op_takewhilepos_first3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_first3_uniq([-7, 12, -7]) == []"}
{"id": "op_sortabs_oremptyzero_sorta", "entry_point": "op_sortabs_oremptyzero_sorta", "primitives": ["sortabs", "oremptyzero", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then sort ascending.", "solution": "def op_sortabs_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_oremptyzero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_oremptyzero_sorta([]) == [0]\nassert op_sortabs_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_sortabs_oremptyzero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_oremptyzero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_oremptyzero_sorta([10]) == [10]\nassert op_sortabs_oremptyzero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_dec_sortd_alldistinct", "entry_point": "op_dec_sortd_alldistinct", "primitives": ["dec", "sortd", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort descending, then return whether all values are distinct.", "solution": "def op_dec_sortd_alldistinct(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return len(r) == len(set(r))", "tests": "assert op_dec_sortd_alldistinct([1, 2, 3, 4]) == True\nassert op_dec_sortd_alldistinct([]) == True\nassert op_dec_sortd_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dec_sortd_alldistinct([5, 5, 5]) == False\nassert op_dec_sortd_alldistinct([3, 1, 2]) == True\nassert op_dec_sortd_alldistinct([10]) == True\nassert op_dec_sortd_alldistinct([2, 4, 6]) == True\nassert op_dec_sortd_alldistinct([-7, 12, -7]) == False"}
{"id": "op_pos_negate_clamp10", "entry_point": "op_pos_negate_clamp10", "primitives": ["pos", "negate", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then cap each value at 10.", "solution": "def op_pos_negate_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_negate_clamp10([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_pos_negate_clamp10([]) == []\nassert op_pos_negate_clamp10([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_negate_clamp10([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_negate_clamp10([3, 1, 2]) == [-3, -1, -2]\nassert op_pos_negate_clamp10([10]) == [-10]\nassert op_pos_negate_clamp10([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_negate_clamp10([-7, 12, -7]) == [-12]"}
{"id": "op_square_evens_last3", "entry_point": "op_square_evens_last3", "primitives": ["square", "evens", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then keep only the last three.", "solution": "def op_square_evens_last3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r[-3:]\n    return r", "tests": "assert op_square_evens_last3([1, 2, 3, 4]) == [4, 16]\nassert op_square_evens_last3([]) == []\nassert op_square_evens_last3([-2, -1, 0, 1, 2]) == [4, 0, 4]\nassert op_square_evens_last3([5, 5, 5]) == []\nassert op_square_evens_last3([3, 1, 2]) == [4]\nassert op_square_evens_last3([10]) == [100]\nassert op_square_evens_last3([2, 4, 6]) == [4, 16, 36]\nassert op_square_evens_last3([-7, 12, -7]) == [144]"}
{"id": "op_names_sortlen_firstchar", "entry_point": "op_names_sortlen_firstchar", "primitives": ["names", "sortlen", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then sort by length, shortest first, then keep the first character of each (dropping empties).", "solution": "def op_names_sortlen_firstchar(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_names_sortlen_firstchar([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['B', 'A']\nassert op_names_sortlen_firstchar([]) == []\nassert op_names_sortlen_firstchar([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['C', 'E', 'D']\nassert op_names_sortlen_firstchar([{'name': 'Fi', 'age': 41}]) == ['F']"}
{"id": "op_ages_uniq_prod", "entry_point": "op_ages_uniq_prod", "primitives": ["ages", "uniq", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop duplicates keeping first occurrence, then return their product.", "solution": "def op_ages_uniq_prod(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(dict.fromkeys(r))\n    return __import__('math').prod(r)", "tests": "assert op_ages_uniq_prod([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 432\nassert op_ages_uniq_prod([]) == 1\nassert op_ages_uniq_prod([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 19890\nassert op_ages_uniq_prod([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_inc_uniq_dropwhileneg", "entry_point": "op_inc_uniq_dropwhileneg", "primitives": ["inc", "uniq", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_inc_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_inc_uniq_dropwhileneg([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_uniq_dropwhileneg([]) == []\nassert op_inc_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_inc_uniq_dropwhileneg([5, 5, 5]) == [6]\nassert op_inc_uniq_dropwhileneg([3, 1, 2]) == [4, 2, 3]\nassert op_inc_uniq_dropwhileneg([10]) == [11]\nassert op_inc_uniq_dropwhileneg([2, 4, 6]) == [3, 5, 7]\nassert op_inc_uniq_dropwhileneg([-7, 12, -7]) == [13]"}
{"id": "op_rev_first3_uniq", "entry_point": "op_rev_first3_uniq", "primitives": ["rev", "first3", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then drop duplicates keeping first occurrence.", "solution": "def op_rev_first3_uniq(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_rev_first3_uniq([1, 2, 3, 4]) == [4, 3, 2]\nassert op_rev_first3_uniq([]) == []\nassert op_rev_first3_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_rev_first3_uniq([5, 5, 5]) == [5]\nassert op_rev_first3_uniq([3, 1, 2]) == [2, 1, 3]\nassert op_rev_first3_uniq([10]) == [10]\nassert op_rev_first3_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_rev_first3_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_odds_inc_sum", "entry_point": "op_odds_inc_sum", "primitives": ["odds", "inc", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then return their sum.", "solution": "def op_odds_inc_sum(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return sum(r)", "tests": "assert op_odds_inc_sum([1, 2, 3, 4]) == 6\nassert op_odds_inc_sum([]) == 0\nassert op_odds_inc_sum([-2, -1, 0, 1, 2]) == 2\nassert op_odds_inc_sum([5, 5, 5]) == 18\nassert op_odds_inc_sum([3, 1, 2]) == 6\nassert op_odds_inc_sum([10]) == 0\nassert op_odds_inc_sum([2, 4, 6]) == 0\nassert op_odds_inc_sum([-7, 12, -7]) == -12"}
{"id": "op_square_evens_sum", "entry_point": "op_square_evens_sum", "primitives": ["square", "evens", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the even numbers, then return their sum.", "solution": "def op_square_evens_sum(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return sum(r)", "tests": "assert op_square_evens_sum([1, 2, 3, 4]) == 20\nassert op_square_evens_sum([]) == 0\nassert op_square_evens_sum([-2, -1, 0, 1, 2]) == 8\nassert op_square_evens_sum([5, 5, 5]) == 0\nassert op_square_evens_sum([3, 1, 2]) == 4\nassert op_square_evens_sum([10]) == 100\nassert op_square_evens_sum([2, 4, 6]) == 56\nassert op_square_evens_sum([-7, 12, -7]) == 144"}
{"id": "op_trimends_last3_sum", "entry_point": "op_trimends_last3_sum", "primitives": ["trimends", "last3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then return their sum.", "solution": "def op_trimends_last3_sum(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_trimends_last3_sum([1, 2, 3, 4]) == 5\nassert op_trimends_last3_sum([]) == 0\nassert op_trimends_last3_sum([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_last3_sum([5, 5, 5]) == 5\nassert op_trimends_last3_sum([3, 1, 2]) == 1\nassert op_trimends_last3_sum([10]) == 0\nassert op_trimends_last3_sum([2, 4, 6]) == 4\nassert op_trimends_last3_sum([-7, 12, -7]) == 12"}
{"id": "op_negate_add10_uniq", "entry_point": "op_negate_add10_uniq", "primitives": ["negate", "add10", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_negate_add10_uniq(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_negate_add10_uniq([1, 2, 3, 4]) == [9, 8, 7, 6]\nassert op_negate_add10_uniq([]) == []\nassert op_negate_add10_uniq([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_negate_add10_uniq([5, 5, 5]) == [5]\nassert op_negate_add10_uniq([3, 1, 2]) == [7, 9, 8]\nassert op_negate_add10_uniq([10]) == [0]\nassert op_negate_add10_uniq([2, 4, 6]) == [8, 6, 4]\nassert op_negate_add10_uniq([-7, 12, -7]) == [17, -2]"}
{"id": "op_dec_absval_dropzeros", "entry_point": "op_dec_absval_dropzeros", "primitives": ["dec", "absval", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then take the absolute value of each, then drop the zeros.", "solution": "def op_dec_absval_dropzeros(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_dec_absval_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dec_absval_dropzeros([]) == []\nassert op_dec_absval_dropzeros([-2, -1, 0, 1, 2]) == [3, 2, 1, 1]\nassert op_dec_absval_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_dec_absval_dropzeros([3, 1, 2]) == [2, 1]\nassert op_dec_absval_dropzeros([10]) == [9]\nassert op_dec_absval_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_dec_absval_dropzeros([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_ages_evens_rev", "entry_point": "op_ages_evens_rev", "primitives": ["ages", "evens", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep the even numbers, then reverse the order.", "solution": "def op_ages_evens_rev(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x for x in r if x % 2 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_ages_evens_rev([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [12, 36]\nassert op_ages_evens_rev([]) == []\nassert op_ages_evens_rev([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18]\nassert op_ages_evens_rev([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_last3_dropwhileneg_uniq", "entry_point": "op_last3_dropwhileneg_uniq", "primitives": ["last3", "dropwhileneg", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the leading negative values, then drop duplicates keeping first occurrence.", "solution": "def op_last3_dropwhileneg_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_dropwhileneg_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_dropwhileneg_uniq([]) == []\nassert op_last3_dropwhileneg_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_dropwhileneg_uniq([5, 5, 5]) == [5]\nassert op_last3_dropwhileneg_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_last3_dropwhileneg_uniq([10]) == [10]\nassert op_last3_dropwhileneg_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_last3_dropwhileneg_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_rev_trimends_sortabs", "entry_point": "op_rev_trimends_sortabs", "primitives": ["rev", "trimends", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop the first and last elements, then sort by absolute value.", "solution": "def op_rev_trimends_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_trimends_sortabs([1, 2, 3, 4]) == [2, 3]\nassert op_rev_trimends_sortabs([]) == []\nassert op_rev_trimends_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1]\nassert op_rev_trimends_sortabs([5, 5, 5]) == [5]\nassert op_rev_trimends_sortabs([3, 1, 2]) == [1]\nassert op_rev_trimends_sortabs([10]) == []\nassert op_rev_trimends_sortabs([2, 4, 6]) == [4]\nassert op_rev_trimends_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_nonempty_uniqs_anyempty", "entry_point": "op_nonempty_uniqs_anyempty", "primitives": ["nonempty", "uniqs", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_nonempty_uniqs_anyempty(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_nonempty_uniqs_anyempty(['Hello', 'world']) == False\nassert op_nonempty_uniqs_anyempty([]) == False\nassert op_nonempty_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_nonempty_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_nonempty_uniqs_anyempty(['x']) == False\nassert op_nonempty_uniqs_anyempty(['abc', 'de', '']) == False"}
{"id": "op_dropfirst_absval_anyeven", "entry_point": "op_dropfirst_absval_anyeven", "primitives": ["dropfirst", "absval", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then take the absolute value of each, then return whether any value is even.", "solution": "def op_dropfirst_absval_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_absval_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_absval_anyeven([]) == False\nassert op_dropfirst_absval_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_absval_anyeven([5, 5, 5]) == False\nassert op_dropfirst_absval_anyeven([3, 1, 2]) == True\nassert op_dropfirst_absval_anyeven([10]) == False\nassert op_dropfirst_absval_anyeven([2, 4, 6]) == True\nassert op_dropfirst_absval_anyeven([-7, 12, -7]) == True"}
{"id": "op_sortd_absval_double", "entry_point": "op_sortd_absval_double", "primitives": ["sortd", "absval", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then double each.", "solution": "def op_sortd_absval_double(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortd_absval_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_absval_double([]) == []\nassert op_sortd_absval_double([-2, -1, 0, 1, 2]) == [4, 2, 0, 2, 4]\nassert op_sortd_absval_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_absval_double([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_absval_double([10]) == [20]\nassert op_sortd_absval_double([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_absval_double([-7, 12, -7]) == [24, 14, 14]"}
{"id": "op_prefixup_sortalpha_firstchar", "entry_point": "op_prefixup_sortalpha_firstchar", "primitives": ["prefixup", "sortalpha", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then sort alphabetically, then keep the first character of each (dropping empties).", "solution": "def op_prefixup_sortalpha_firstchar(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = sorted(r)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_prefixup_sortalpha_firstchar(['Hello', 'world']) == ['#', '#']\nassert op_prefixup_sortalpha_firstchar([]) == []\nassert op_prefixup_sortalpha_firstchar(['  a ', '', 'BC', 'bc']) == ['#', '#', '#', '#']\nassert op_prefixup_sortalpha_firstchar(['one', 'one', 'Two']) == ['#', '#', '#']\nassert op_prefixup_sortalpha_firstchar(['x']) == ['#']\nassert op_prefixup_sortalpha_firstchar(['abc', 'de', '']) == ['#', '#', '#']"}
{"id": "op_neg_takewhilepos_double", "entry_point": "op_neg_takewhilepos_double", "primitives": ["neg", "takewhilepos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take values while they are positive, then double each.", "solution": "def op_neg_takewhilepos_double(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_neg_takewhilepos_double([1, 2, 3, 4]) == []\nassert op_neg_takewhilepos_double([]) == []\nassert op_neg_takewhilepos_double([-2, -1, 0, 1, 2]) == []\nassert op_neg_takewhilepos_double([5, 5, 5]) == []\nassert op_neg_takewhilepos_double([3, 1, 2]) == []\nassert op_neg_takewhilepos_double([10]) == []\nassert op_neg_takewhilepos_double([2, 4, 6]) == []\nassert op_neg_takewhilepos_double([-7, 12, -7]) == []"}
{"id": "op_gt5_padto3_issorted", "entry_point": "op_gt5_padto3_issorted", "primitives": ["gt5", "padto3", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then return whether the list is sorted ascending.", "solution": "def op_gt5_padto3_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r == sorted(r)", "tests": "assert op_gt5_padto3_issorted([1, 2, 3, 4]) == True\nassert op_gt5_padto3_issorted([]) == True\nassert op_gt5_padto3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_gt5_padto3_issorted([5, 5, 5]) == True\nassert op_gt5_padto3_issorted([3, 1, 2]) == True\nassert op_gt5_padto3_issorted([10]) == False\nassert op_gt5_padto3_issorted([2, 4, 6]) == False\nassert op_gt5_padto3_issorted([-7, 12, -7]) == False"}
{"id": "op_last3_dropfirst_issorted", "entry_point": "op_last3_dropfirst_issorted", "primitives": ["last3", "dropfirst", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then return whether the list is sorted ascending.", "solution": "def op_last3_dropfirst_issorted(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return r == sorted(r)", "tests": "assert op_last3_dropfirst_issorted([1, 2, 3, 4]) == True\nassert op_last3_dropfirst_issorted([]) == True\nassert op_last3_dropfirst_issorted([-2, -1, 0, 1, 2]) == True\nassert op_last3_dropfirst_issorted([5, 5, 5]) == True\nassert op_last3_dropfirst_issorted([3, 1, 2]) == True\nassert op_last3_dropfirst_issorted([10]) == True\nassert op_last3_dropfirst_issorted([2, 4, 6]) == True\nassert op_last3_dropfirst_issorted([-7, 12, -7]) == False"}
{"id": "op_trimends_dropzeros_evens", "entry_point": "op_trimends_dropzeros_evens", "primitives": ["trimends", "dropzeros", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop the zeros, then keep the even numbers.", "solution": "def op_trimends_dropzeros_evens(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_trimends_dropzeros_evens([1, 2, 3, 4]) == [2]\nassert op_trimends_dropzeros_evens([]) == []\nassert op_trimends_dropzeros_evens([-2, -1, 0, 1, 2]) == []\nassert op_trimends_dropzeros_evens([5, 5, 5]) == []\nassert op_trimends_dropzeros_evens([3, 1, 2]) == []\nassert op_trimends_dropzeros_evens([10]) == []\nassert op_trimends_dropzeros_evens([2, 4, 6]) == [4]\nassert op_trimends_dropzeros_evens([-7, 12, -7]) == [12]"}
{"id": "op_first3_odds_dec", "entry_point": "op_first3_odds_dec", "primitives": ["first3", "odds", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep the odd numbers, then subtract one from each.", "solution": "def op_first3_odds_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_odds_dec([1, 2, 3, 4]) == [0, 2]\nassert op_first3_odds_dec([]) == []\nassert op_first3_odds_dec([-2, -1, 0, 1, 2]) == [-2]\nassert op_first3_odds_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_odds_dec([3, 1, 2]) == [2, 0]\nassert op_first3_odds_dec([10]) == []\nassert op_first3_odds_dec([2, 4, 6]) == []\nassert op_first3_odds_dec([-7, 12, -7]) == [-8, -8]"}
{"id": "op_rev_sorta_sortabs", "entry_point": "op_rev_sorta_sortabs", "primitives": ["rev", "sorta", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort ascending, then sort by absolute value.", "solution": "def op_rev_sorta_sortabs(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r)\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_rev_sorta_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_rev_sorta_sortabs([]) == []\nassert op_rev_sorta_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_rev_sorta_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sorta_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_rev_sorta_sortabs([10]) == [10]\nassert op_rev_sorta_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_rev_sorta_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_sortabs_clamp10_anyeven", "entry_point": "op_sortabs_clamp10_anyeven", "primitives": ["sortabs", "clamp10", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then return whether any value is even.", "solution": "def op_sortabs_clamp10_anyeven(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_sortabs_clamp10_anyeven([1, 2, 3, 4]) == True\nassert op_sortabs_clamp10_anyeven([]) == False\nassert op_sortabs_clamp10_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_sortabs_clamp10_anyeven([5, 5, 5]) == False\nassert op_sortabs_clamp10_anyeven([3, 1, 2]) == True\nassert op_sortabs_clamp10_anyeven([10]) == True\nassert op_sortabs_clamp10_anyeven([2, 4, 6]) == True\nassert op_sortabs_clamp10_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniq_sorta_counteven", "entry_point": "op_uniq_sorta_counteven", "primitives": ["uniq", "sorta", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then sort ascending, then return how many values are even.", "solution": "def op_uniq_sorta_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_uniq_sorta_counteven([]) == 0\nassert op_uniq_sorta_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_uniq_sorta_counteven([5, 5, 5]) == 0\nassert op_uniq_sorta_counteven([3, 1, 2]) == 1\nassert op_uniq_sorta_counteven([10]) == 1\nassert op_uniq_sorta_counteven([2, 4, 6]) == 3\nassert op_uniq_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_odds_dec_double", "entry_point": "op_odds_dec_double", "primitives": ["odds", "dec", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then subtract one from each, then double each.", "solution": "def op_odds_dec_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x - 1 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_dec_double([1, 2, 3, 4]) == [0, 4]\nassert op_odds_dec_double([]) == []\nassert op_odds_dec_double([-2, -1, 0, 1, 2]) == [-4, 0]\nassert op_odds_dec_double([5, 5, 5]) == [8, 8, 8]\nassert op_odds_dec_double([3, 1, 2]) == [4, 0]\nassert op_odds_dec_double([10]) == []\nassert op_odds_dec_double([2, 4, 6]) == []\nassert op_odds_dec_double([-7, 12, -7]) == [-16, -16]"}
{"id": "op_neg_dec_takewhilepos", "entry_point": "op_neg_dec_takewhilepos", "primitives": ["neg", "dec", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then subtract one from each, then take values while they are positive.", "solution": "def op_neg_dec_takewhilepos(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_neg_dec_takewhilepos([1, 2, 3, 4]) == []\nassert op_neg_dec_takewhilepos([]) == []\nassert op_neg_dec_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_neg_dec_takewhilepos([5, 5, 5]) == []\nassert op_neg_dec_takewhilepos([3, 1, 2]) == []\nassert op_neg_dec_takewhilepos([10]) == []\nassert op_neg_dec_takewhilepos([2, 4, 6]) == []\nassert op_neg_dec_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_square_beforezero_anyeven", "entry_point": "op_square_beforezero_anyeven", "primitives": ["square", "beforezero", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then return whether any value is even.", "solution": "def op_square_beforezero_anyeven(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_square_beforezero_anyeven([1, 2, 3, 4]) == True\nassert op_square_beforezero_anyeven([]) == False\nassert op_square_beforezero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_square_beforezero_anyeven([5, 5, 5]) == False\nassert op_square_beforezero_anyeven([3, 1, 2]) == True\nassert op_square_beforezero_anyeven([10]) == True\nassert op_square_beforezero_anyeven([2, 4, 6]) == True\nassert op_square_beforezero_anyeven([-7, 12, -7]) == True"}
{"id": "op_ages_takewhilepos_absval", "entry_point": "op_ages_takewhilepos_absval", "primitives": ["ages", "takewhilepos", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then take values while they are positive, then take the absolute value of each.", "solution": "def op_ages_takewhilepos_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_takewhilepos_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_takewhilepos_absval([]) == []\nassert op_ages_takewhilepos_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_takewhilepos_absval([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_neg_absval_dropwhileneg", "entry_point": "op_neg_absval_dropwhileneg", "primitives": ["neg", "absval", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then drop the leading negative values.", "solution": "def op_neg_absval_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_neg_absval_dropwhileneg([1, 2, 3, 4]) == []\nassert op_neg_absval_dropwhileneg([]) == []\nassert op_neg_absval_dropwhileneg([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_neg_absval_dropwhileneg([5, 5, 5]) == []\nassert op_neg_absval_dropwhileneg([3, 1, 2]) == []\nassert op_neg_absval_dropwhileneg([10]) == []\nassert op_neg_absval_dropwhileneg([2, 4, 6]) == []\nassert op_neg_absval_dropwhileneg([-7, 12, -7]) == [7, 7]"}
{"id": "op_odds_neg_double", "entry_point": "op_odds_neg_double", "primitives": ["odds", "neg", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep the negative numbers, then double each.", "solution": "def op_odds_neg_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_odds_neg_double([1, 2, 3, 4]) == []\nassert op_odds_neg_double([]) == []\nassert op_odds_neg_double([-2, -1, 0, 1, 2]) == [-2]\nassert op_odds_neg_double([5, 5, 5]) == []\nassert op_odds_neg_double([3, 1, 2]) == []\nassert op_odds_neg_double([10]) == []\nassert op_odds_neg_double([2, 4, 6]) == []\nassert op_odds_neg_double([-7, 12, -7]) == [-14, -14]"}
{"id": "op_neg_pos_min", "entry_point": "op_neg_pos_min", "primitives": ["neg", "pos", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the positive numbers, then return the minimum (0 if empty).", "solution": "def op_neg_pos_min(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x > 0]\n    return min(r) if r else 0", "tests": "assert op_neg_pos_min([1, 2, 3, 4]) == 0\nassert op_neg_pos_min([]) == 0\nassert op_neg_pos_min([-2, -1, 0, 1, 2]) == 0\nassert op_neg_pos_min([5, 5, 5]) == 0\nassert op_neg_pos_min([3, 1, 2]) == 0\nassert op_neg_pos_min([10]) == 0\nassert op_neg_pos_min([2, 4, 6]) == 0\nassert op_neg_pos_min([-7, 12, -7]) == 0"}
{"id": "op_takewhilepos_dropzeros_gt5", "entry_point": "op_takewhilepos_dropzeros_gt5", "primitives": ["takewhilepos", "dropzeros", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then keep values greater than five.", "solution": "def op_takewhilepos_dropzeros_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_dropzeros_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_dropzeros_gt5([]) == []\nassert op_takewhilepos_dropzeros_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropzeros_gt5([5, 5, 5]) == []\nassert op_takewhilepos_dropzeros_gt5([3, 1, 2]) == []\nassert op_takewhilepos_dropzeros_gt5([10]) == [10]\nassert op_takewhilepos_dropzeros_gt5([2, 4, 6]) == [6]\nassert op_takewhilepos_dropzeros_gt5([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_trimends_sorta", "entry_point": "op_dropwhileneg_trimends_sorta", "primitives": ["dropwhileneg", "trimends", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then sort ascending.", "solution": "def op_dropwhileneg_trimends_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_trimends_sorta([1, 2, 3, 4]) == [2, 3]\nassert op_dropwhileneg_trimends_sorta([]) == []\nassert op_dropwhileneg_trimends_sorta([-2, -1, 0, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_sorta([5, 5, 5]) == [5]\nassert op_dropwhileneg_trimends_sorta([3, 1, 2]) == [1]\nassert op_dropwhileneg_trimends_sorta([10]) == []\nassert op_dropwhileneg_trimends_sorta([2, 4, 6]) == [4]\nassert op_dropwhileneg_trimends_sorta([-7, 12, -7]) == []"}
{"id": "op_div3_oremptyzero_last3", "entry_point": "op_div3_oremptyzero_last3", "primitives": ["div3", "oremptyzero", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then keep only the last three.", "solution": "def op_div3_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_div3_oremptyzero_last3([1, 2, 3, 4]) == [3]\nassert op_div3_oremptyzero_last3([]) == [0]\nassert op_div3_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_oremptyzero_last3([5, 5, 5]) == [0]\nassert op_div3_oremptyzero_last3([3, 1, 2]) == [3]\nassert op_div3_oremptyzero_last3([10]) == [0]\nassert op_div3_oremptyzero_last3([2, 4, 6]) == [6]\nassert op_div3_oremptyzero_last3([-7, 12, -7]) == [12]"}
{"id": "op_uniq_oremptyzero_div3", "entry_point": "op_uniq_oremptyzero_div3", "primitives": ["uniq", "oremptyzero", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then keep multiples of three.", "solution": "def op_uniq_oremptyzero_div3(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_uniq_oremptyzero_div3([1, 2, 3, 4]) == [3]\nassert op_uniq_oremptyzero_div3([]) == [0]\nassert op_uniq_oremptyzero_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_uniq_oremptyzero_div3([5, 5, 5]) == []\nassert op_uniq_oremptyzero_div3([3, 1, 2]) == [3]\nassert op_uniq_oremptyzero_div3([10]) == []\nassert op_uniq_oremptyzero_div3([2, 4, 6]) == [6]\nassert op_uniq_oremptyzero_div3([-7, 12, -7]) == [12]"}
{"id": "op_square_sortabs_oremptyzero", "entry_point": "op_square_sortabs_oremptyzero", "primitives": ["square", "sortabs", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_square_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_square_sortabs_oremptyzero([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sortabs_oremptyzero([]) == [0]\nassert op_square_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_square_sortabs_oremptyzero([5, 5, 5]) == [25, 25, 25]\nassert op_square_sortabs_oremptyzero([3, 1, 2]) == [1, 4, 9]\nassert op_square_sortabs_oremptyzero([10]) == [100]\nassert op_square_sortabs_oremptyzero([2, 4, 6]) == [4, 16, 36]\nassert op_square_sortabs_oremptyzero([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_padto3_neg_min", "entry_point": "op_padto3_neg_min", "primitives": ["padto3", "neg", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the negative numbers, then return the minimum (0 if empty).", "solution": "def op_padto3_neg_min(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return min(r) if r else 0", "tests": "assert op_padto3_neg_min([1, 2, 3, 4]) == 0\nassert op_padto3_neg_min([]) == 0\nassert op_padto3_neg_min([-2, -1, 0, 1, 2]) == -2\nassert op_padto3_neg_min([5, 5, 5]) == 0\nassert op_padto3_neg_min([3, 1, 2]) == 0\nassert op_padto3_neg_min([10]) == 0\nassert op_padto3_neg_min([2, 4, 6]) == 0\nassert op_padto3_neg_min([-7, 12, -7]) == -7"}
{"id": "op_dropwhileneg_sortd_max", "entry_point": "op_dropwhileneg_sortd_max", "primitives": ["dropwhileneg", "sortd", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_sortd_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_sortd_max([1, 2, 3, 4]) == 4\nassert op_dropwhileneg_sortd_max([]) == 0\nassert op_dropwhileneg_sortd_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_sortd_max([5, 5, 5]) == 5\nassert op_dropwhileneg_sortd_max([3, 1, 2]) == 3\nassert op_dropwhileneg_sortd_max([10]) == 10\nassert op_dropwhileneg_sortd_max([2, 4, 6]) == 6\nassert op_dropwhileneg_sortd_max([-7, 12, -7]) == 12"}
{"id": "op_sortd_gt5_inc", "entry_point": "op_sortd_gt5_inc", "primitives": ["sortd", "gt5", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five, then add one to each.", "solution": "def op_sortd_gt5_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_gt5_inc([1, 2, 3, 4]) == []\nassert op_sortd_gt5_inc([]) == []\nassert op_sortd_gt5_inc([-2, -1, 0, 1, 2]) == []\nassert op_sortd_gt5_inc([5, 5, 5]) == []\nassert op_sortd_gt5_inc([3, 1, 2]) == []\nassert op_sortd_gt5_inc([10]) == [11]\nassert op_sortd_gt5_inc([2, 4, 6]) == [7]\nassert op_sortd_gt5_inc([-7, 12, -7]) == [13]"}
{"id": "op_trimends_last3_dropwhileneg", "entry_point": "op_trimends_last3_dropwhileneg", "primitives": ["trimends", "last3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep only the last three, then drop the leading negative values.", "solution": "def op_trimends_last3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[-3:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_last3_dropwhileneg([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_last3_dropwhileneg([]) == []\nassert op_trimends_last3_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_trimends_last3_dropwhileneg([5, 5, 5]) == [5]\nassert op_trimends_last3_dropwhileneg([3, 1, 2]) == [1]\nassert op_trimends_last3_dropwhileneg([10]) == []\nassert op_trimends_last3_dropwhileneg([2, 4, 6]) == [4]\nassert op_trimends_last3_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_trimends_rev", "entry_point": "op_sortabs_trimends_rev", "primitives": ["sortabs", "trimends", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop the first and last elements, then reverse the order.", "solution": "def op_sortabs_trimends_rev(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    return r", "tests": "assert op_sortabs_trimends_rev([1, 2, 3, 4]) == [3, 2]\nassert op_sortabs_trimends_rev([]) == []\nassert op_sortabs_trimends_rev([-2, -1, 0, 1, 2]) == [-2, 1, -1]\nassert op_sortabs_trimends_rev([5, 5, 5]) == [5]\nassert op_sortabs_trimends_rev([3, 1, 2]) == [2]\nassert op_sortabs_trimends_rev([10]) == []\nassert op_sortabs_trimends_rev([2, 4, 6]) == [4]\nassert op_sortabs_trimends_rev([-7, 12, -7]) == [-7]"}
{"id": "op_dropwhileneg_dropfirst_absval", "entry_point": "op_dropwhileneg_dropfirst_absval", "primitives": ["dropwhileneg", "dropfirst", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then take the absolute value of each.", "solution": "def op_dropwhileneg_dropfirst_absval(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_dropwhileneg_dropfirst_absval([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropwhileneg_dropfirst_absval([]) == []\nassert op_dropwhileneg_dropfirst_absval([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst_absval([5, 5, 5]) == [5, 5]\nassert op_dropwhileneg_dropfirst_absval([3, 1, 2]) == [1, 2]\nassert op_dropwhileneg_dropfirst_absval([10]) == []\nassert op_dropwhileneg_dropfirst_absval([2, 4, 6]) == [4, 6]\nassert op_dropwhileneg_dropfirst_absval([-7, 12, -7]) == [7]"}
{"id": "op_div3_uniq_gt5", "entry_point": "op_div3_uniq_gt5", "primitives": ["div3", "uniq", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then drop duplicates keeping first occurrence, then keep values greater than five.", "solution": "def op_div3_uniq_gt5(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_div3_uniq_gt5([1, 2, 3, 4]) == []\nassert op_div3_uniq_gt5([]) == []\nassert op_div3_uniq_gt5([-2, -1, 0, 1, 2]) == []\nassert op_div3_uniq_gt5([5, 5, 5]) == []\nassert op_div3_uniq_gt5([3, 1, 2]) == []\nassert op_div3_uniq_gt5([10]) == []\nassert op_div3_uniq_gt5([2, 4, 6]) == [6]\nassert op_div3_uniq_gt5([-7, 12, -7]) == [12]"}
{"id": "op_first3_trimends_add10", "entry_point": "op_first3_trimends_add10", "primitives": ["first3", "trimends", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop the first and last elements, then add ten to each.", "solution": "def op_first3_trimends_add10(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[1:-1]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_first3_trimends_add10([1, 2, 3, 4]) == [12]\nassert op_first3_trimends_add10([]) == []\nassert op_first3_trimends_add10([-2, -1, 0, 1, 2]) == [9]\nassert op_first3_trimends_add10([5, 5, 5]) == [15]\nassert op_first3_trimends_add10([3, 1, 2]) == [11]\nassert op_first3_trimends_add10([10]) == []\nassert op_first3_trimends_add10([2, 4, 6]) == [14]\nassert op_first3_trimends_add10([-7, 12, -7]) == [22]"}
{"id": "op_absval_padto3_len", "entry_point": "op_absval_padto3_len", "primitives": ["absval", "padto3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_absval_padto3_len(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_absval_padto3_len([1, 2, 3, 4]) == 4\nassert op_absval_padto3_len([]) == 3\nassert op_absval_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_absval_padto3_len([5, 5, 5]) == 3\nassert op_absval_padto3_len([3, 1, 2]) == 3\nassert op_absval_padto3_len([10]) == 3\nassert op_absval_padto3_len([2, 4, 6]) == 3\nassert op_absval_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_sortabs_uniq_allpos", "entry_point": "op_sortabs_uniq_allpos", "primitives": ["sortabs", "uniq", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then drop duplicates keeping first occurrence, then return whether all values are positive.", "solution": "def op_sortabs_uniq_allpos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return all(x > 0 for x in r)", "tests": "assert op_sortabs_uniq_allpos([1, 2, 3, 4]) == True\nassert op_sortabs_uniq_allpos([]) == True\nassert op_sortabs_uniq_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sortabs_uniq_allpos([5, 5, 5]) == True\nassert op_sortabs_uniq_allpos([3, 1, 2]) == True\nassert op_sortabs_uniq_allpos([10]) == True\nassert op_sortabs_uniq_allpos([2, 4, 6]) == True\nassert op_sortabs_uniq_allpos([-7, 12, -7]) == False"}
{"id": "op_last3_clamp10_sortd", "entry_point": "op_last3_clamp10_sortd", "primitives": ["last3", "clamp10", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then cap each value at 10, then sort descending.", "solution": "def op_last3_clamp10_sortd(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [min(x, 10) for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_last3_clamp10_sortd([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_clamp10_sortd([]) == []\nassert op_last3_clamp10_sortd([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_clamp10_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_last3_clamp10_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_last3_clamp10_sortd([10]) == [10]\nassert op_last3_clamp10_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_last3_clamp10_sortd([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_sorta_rev_haszero", "entry_point": "op_sorta_rev_haszero", "primitives": ["sorta", "rev", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then return whether the list contains a zero.", "solution": "def op_sorta_rev_haszero(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    return 0 in r", "tests": "assert op_sorta_rev_haszero([1, 2, 3, 4]) == False\nassert op_sorta_rev_haszero([]) == False\nassert op_sorta_rev_haszero([-2, -1, 0, 1, 2]) == True\nassert op_sorta_rev_haszero([5, 5, 5]) == False\nassert op_sorta_rev_haszero([3, 1, 2]) == False\nassert op_sorta_rev_haszero([10]) == False\nassert op_sorta_rev_haszero([2, 4, 6]) == False\nassert op_sorta_rev_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_negate_len", "entry_point": "op_dropfirst_negate_len", "primitives": ["dropfirst", "negate", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then negate each, then return how many remain.", "solution": "def op_dropfirst_negate_len(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [-x for x in r]\n    return len(r)", "tests": "assert op_dropfirst_negate_len([1, 2, 3, 4]) == 3\nassert op_dropfirst_negate_len([]) == 0\nassert op_dropfirst_negate_len([-2, -1, 0, 1, 2]) == 4\nassert op_dropfirst_negate_len([5, 5, 5]) == 2\nassert op_dropfirst_negate_len([3, 1, 2]) == 2\nassert op_dropfirst_negate_len([10]) == 0\nassert op_dropfirst_negate_len([2, 4, 6]) == 2\nassert op_dropfirst_negate_len([-7, 12, -7]) == 2"}
{"id": "op_padto3_dec_allpos", "entry_point": "op_padto3_dec_allpos", "primitives": ["padto3", "dec", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then return whether all values are positive.", "solution": "def op_padto3_dec_allpos(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_padto3_dec_allpos([1, 2, 3, 4]) == False\nassert op_padto3_dec_allpos([]) == False\nassert op_padto3_dec_allpos([-2, -1, 0, 1, 2]) == False\nassert op_padto3_dec_allpos([5, 5, 5]) == True\nassert op_padto3_dec_allpos([3, 1, 2]) == False\nassert op_padto3_dec_allpos([10]) == False\nassert op_padto3_dec_allpos([2, 4, 6]) == True\nassert op_padto3_dec_allpos([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_padto3_uniq", "entry_point": "op_dropwhileneg_padto3_uniq", "primitives": ["dropwhileneg", "padto3", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then pad with zeros to at least three elements, then drop duplicates keeping first occurrence.", "solution": "def op_dropwhileneg_padto3_uniq(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_dropwhileneg_padto3_uniq([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dropwhileneg_padto3_uniq([]) == [0]\nassert op_dropwhileneg_padto3_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_dropwhileneg_padto3_uniq([5, 5, 5]) == [5]\nassert op_dropwhileneg_padto3_uniq([3, 1, 2]) == [3, 1, 2]\nassert op_dropwhileneg_padto3_uniq([10]) == [10, 0]\nassert op_dropwhileneg_padto3_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_dropwhileneg_padto3_uniq([-7, 12, -7]) == [12, -7, 0]"}
{"id": "op_uniq_add10_inc", "entry_point": "op_uniq_add10_inc", "primitives": ["uniq", "add10", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then add one to each.", "solution": "def op_uniq_add10_inc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_uniq_add10_inc([1, 2, 3, 4]) == [12, 13, 14, 15]\nassert op_uniq_add10_inc([]) == []\nassert op_uniq_add10_inc([-2, -1, 0, 1, 2]) == [9, 10, 11, 12, 13]\nassert op_uniq_add10_inc([5, 5, 5]) == [16]\nassert op_uniq_add10_inc([3, 1, 2]) == [14, 12, 13]\nassert op_uniq_add10_inc([10]) == [21]\nassert op_uniq_add10_inc([2, 4, 6]) == [13, 15, 17]\nassert op_uniq_add10_inc([-7, 12, -7]) == [4, 23]"}
{"id": "op_add10_dropfirst_dec", "entry_point": "op_add10_dropfirst_dec", "primitives": ["add10", "dropfirst", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then subtract one from each.", "solution": "def op_add10_dropfirst_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_dropfirst_dec([1, 2, 3, 4]) == [11, 12, 13]\nassert op_add10_dropfirst_dec([]) == []\nassert op_add10_dropfirst_dec([-2, -1, 0, 1, 2]) == [8, 9, 10, 11]\nassert op_add10_dropfirst_dec([5, 5, 5]) == [14, 14]\nassert op_add10_dropfirst_dec([3, 1, 2]) == [10, 11]\nassert op_add10_dropfirst_dec([10]) == []\nassert op_add10_dropfirst_dec([2, 4, 6]) == [13, 15]\nassert op_add10_dropfirst_dec([-7, 12, -7]) == [21, 2]"}
{"id": "op_add10_dropzeros_counteven", "entry_point": "op_add10_dropzeros_counteven", "primitives": ["add10", "dropzeros", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then return how many values are even.", "solution": "def op_add10_dropzeros_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_add10_dropzeros_counteven([]) == 0\nassert op_add10_dropzeros_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_add10_dropzeros_counteven([5, 5, 5]) == 0\nassert op_add10_dropzeros_counteven([3, 1, 2]) == 1\nassert op_add10_dropzeros_counteven([10]) == 1\nassert op_add10_dropzeros_counteven([2, 4, 6]) == 3\nassert op_add10_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_padto3_takewhilepos_rev", "entry_point": "op_padto3_takewhilepos_rev", "primitives": ["padto3", "takewhilepos", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take values while they are positive, then reverse the order.", "solution": "def op_padto3_takewhilepos_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_takewhilepos_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_takewhilepos_rev([]) == []\nassert op_padto3_takewhilepos_rev([-2, -1, 0, 1, 2]) == []\nassert op_padto3_takewhilepos_rev([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_takewhilepos_rev([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_takewhilepos_rev([10]) == [10]\nassert op_padto3_takewhilepos_rev([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_takewhilepos_rev([-7, 12, -7]) == []"}
{"id": "op_dropwhileneg_sortabs_haszero", "entry_point": "op_dropwhileneg_sortabs_haszero", "primitives": ["dropwhileneg", "sortabs", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort by absolute value, then return whether the list contains a zero.", "solution": "def op_dropwhileneg_sortabs_haszero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return 0 in r", "tests": "assert op_dropwhileneg_sortabs_haszero([1, 2, 3, 4]) == False\nassert op_dropwhileneg_sortabs_haszero([]) == False\nassert op_dropwhileneg_sortabs_haszero([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_sortabs_haszero([5, 5, 5]) == False\nassert op_dropwhileneg_sortabs_haszero([3, 1, 2]) == False\nassert op_dropwhileneg_sortabs_haszero([10]) == False\nassert op_dropwhileneg_sortabs_haszero([2, 4, 6]) == False\nassert op_dropwhileneg_sortabs_haszero([-7, 12, -7]) == False"}
{"id": "op_oremptyzero_sorta_gt5", "entry_point": "op_oremptyzero_sorta_gt5", "primitives": ["oremptyzero", "sorta", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then keep values greater than five.", "solution": "def op_oremptyzero_sorta_gt5(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_oremptyzero_sorta_gt5([1, 2, 3, 4]) == []\nassert op_oremptyzero_sorta_gt5([]) == []\nassert op_oremptyzero_sorta_gt5([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_sorta_gt5([5, 5, 5]) == []\nassert op_oremptyzero_sorta_gt5([3, 1, 2]) == []\nassert op_oremptyzero_sorta_gt5([10]) == [10]\nassert op_oremptyzero_sorta_gt5([2, 4, 6]) == [6]\nassert op_oremptyzero_sorta_gt5([-7, 12, -7]) == [12]"}
{"id": "op_sortd_neg_evens", "entry_point": "op_sortd_neg_evens", "primitives": ["sortd", "neg", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the negative numbers, then keep the even numbers.", "solution": "def op_sortd_neg_evens(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortd_neg_evens([1, 2, 3, 4]) == []\nassert op_sortd_neg_evens([]) == []\nassert op_sortd_neg_evens([-2, -1, 0, 1, 2]) == [-2]\nassert op_sortd_neg_evens([5, 5, 5]) == []\nassert op_sortd_neg_evens([3, 1, 2]) == []\nassert op_sortd_neg_evens([10]) == []\nassert op_sortd_neg_evens([2, 4, 6]) == []\nassert op_sortd_neg_evens([-7, 12, -7]) == []"}
{"id": "op_gt5_pos_last3", "entry_point": "op_gt5_pos_last3", "primitives": ["gt5", "pos", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the positive numbers, then keep only the last three.", "solution": "def op_gt5_pos_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    r = r[-3:]\n    return r", "tests": "assert op_gt5_pos_last3([1, 2, 3, 4]) == []\nassert op_gt5_pos_last3([]) == []\nassert op_gt5_pos_last3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_pos_last3([5, 5, 5]) == []\nassert op_gt5_pos_last3([3, 1, 2]) == []\nassert op_gt5_pos_last3([10]) == [10]\nassert op_gt5_pos_last3([2, 4, 6]) == [6]\nassert op_gt5_pos_last3([-7, 12, -7]) == [12]"}
{"id": "op_absval_dropwhileneg_pos", "entry_point": "op_absval_dropwhileneg_pos", "primitives": ["absval", "dropwhileneg", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then keep the positive numbers.", "solution": "def op_absval_dropwhileneg_pos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_absval_dropwhileneg_pos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_absval_dropwhileneg_pos([]) == []\nassert op_absval_dropwhileneg_pos([-2, -1, 0, 1, 2]) == [2, 1, 1, 2]\nassert op_absval_dropwhileneg_pos([5, 5, 5]) == [5, 5, 5]\nassert op_absval_dropwhileneg_pos([3, 1, 2]) == [3, 1, 2]\nassert op_absval_dropwhileneg_pos([10]) == [10]\nassert op_absval_dropwhileneg_pos([2, 4, 6]) == [2, 4, 6]\nassert op_absval_dropwhileneg_pos([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_negate_uniq_square", "entry_point": "op_negate_uniq_square", "primitives": ["negate", "uniq", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop duplicates keeping first occurrence, then square each.", "solution": "def op_negate_uniq_square(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_negate_uniq_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_negate_uniq_square([]) == []\nassert op_negate_uniq_square([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_negate_uniq_square([5, 5, 5]) == [25]\nassert op_negate_uniq_square([3, 1, 2]) == [9, 1, 4]\nassert op_negate_uniq_square([10]) == [100]\nassert op_negate_uniq_square([2, 4, 6]) == [4, 16, 36]\nassert op_negate_uniq_square([-7, 12, -7]) == [49, 144]"}
{"id": "op_sortd_beforezero_clamp10", "entry_point": "op_sortd_beforezero_clamp10", "primitives": ["sortd", "beforezero", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_sortd_beforezero_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortd_beforezero_clamp10([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_beforezero_clamp10([]) == []\nassert op_sortd_beforezero_clamp10([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_beforezero_clamp10([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_beforezero_clamp10([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_beforezero_clamp10([10]) == [10]\nassert op_sortd_beforezero_clamp10([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_beforezero_clamp10([-7, 12, -7]) == [10, -7, -7]"}
{"id": "op_beforezero_first3_dropwhileneg", "entry_point": "op_beforezero_first3_dropwhileneg", "primitives": ["beforezero", "first3", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then drop the leading negative values.", "solution": "def op_beforezero_first3_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_beforezero_first3_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_dropwhileneg([]) == []\nassert op_beforezero_first3_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_first3_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_dropwhileneg([10]) == [10]\nassert op_beforezero_first3_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_sortabs_oremptyzero_sum", "entry_point": "op_sortabs_oremptyzero_sum", "primitives": ["sortabs", "oremptyzero", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then return their sum.", "solution": "def op_sortabs_oremptyzero_sum(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return sum(r)", "tests": "assert op_sortabs_oremptyzero_sum([1, 2, 3, 4]) == 10\nassert op_sortabs_oremptyzero_sum([]) == 0\nassert op_sortabs_oremptyzero_sum([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_oremptyzero_sum([5, 5, 5]) == 15\nassert op_sortabs_oremptyzero_sum([3, 1, 2]) == 6\nassert op_sortabs_oremptyzero_sum([10]) == 10\nassert op_sortabs_oremptyzero_sum([2, 4, 6]) == 12\nassert op_sortabs_oremptyzero_sum([-7, 12, -7]) == -2"}
{"id": "op_odds_inc_absval", "entry_point": "op_odds_inc_absval", "primitives": ["odds", "inc", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then add one to each, then take the absolute value of each.", "solution": "def op_odds_inc_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_odds_inc_absval([1, 2, 3, 4]) == [2, 4]\nassert op_odds_inc_absval([]) == []\nassert op_odds_inc_absval([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_odds_inc_absval([5, 5, 5]) == [6, 6, 6]\nassert op_odds_inc_absval([3, 1, 2]) == [4, 2]\nassert op_odds_inc_absval([10]) == []\nassert op_odds_inc_absval([2, 4, 6]) == []\nassert op_odds_inc_absval([-7, 12, -7]) == [6, 6]"}
{"id": "op_add10_gt5_pos", "entry_point": "op_add10_gt5_pos", "primitives": ["add10", "gt5", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then keep the positive numbers.", "solution": "def op_add10_gt5_pos(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_add10_gt5_pos([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_gt5_pos([]) == []\nassert op_add10_gt5_pos([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_gt5_pos([5, 5, 5]) == [15, 15, 15]\nassert op_add10_gt5_pos([3, 1, 2]) == [13, 11, 12]\nassert op_add10_gt5_pos([10]) == [20]\nassert op_add10_gt5_pos([2, 4, 6]) == [12, 14, 16]\nassert op_add10_gt5_pos([-7, 12, -7]) == [22]"}
{"id": "op_absval_dropwhileneg_haszero", "entry_point": "op_absval_dropwhileneg_haszero", "primitives": ["absval", "dropwhileneg", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then return whether the list contains a zero.", "solution": "def op_absval_dropwhileneg_haszero(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return 0 in r", "tests": "assert op_absval_dropwhileneg_haszero([1, 2, 3, 4]) == False\nassert op_absval_dropwhileneg_haszero([]) == False\nassert op_absval_dropwhileneg_haszero([-2, -1, 0, 1, 2]) == True\nassert op_absval_dropwhileneg_haszero([5, 5, 5]) == False\nassert op_absval_dropwhileneg_haszero([3, 1, 2]) == False\nassert op_absval_dropwhileneg_haszero([10]) == False\nassert op_absval_dropwhileneg_haszero([2, 4, 6]) == False\nassert op_absval_dropwhileneg_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_div3_sorta", "entry_point": "op_sortd_div3_sorta", "primitives": ["sortd", "div3", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep multiples of three, then sort ascending.", "solution": "def op_sortd_div3_sorta(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r)\n    return r", "tests": "assert op_sortd_div3_sorta([1, 2, 3, 4]) == [3]\nassert op_sortd_div3_sorta([]) == []\nassert op_sortd_div3_sorta([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_div3_sorta([5, 5, 5]) == []\nassert op_sortd_div3_sorta([3, 1, 2]) == [3]\nassert op_sortd_div3_sorta([10]) == []\nassert op_sortd_div3_sorta([2, 4, 6]) == [6]\nassert op_sortd_div3_sorta([-7, 12, -7]) == [12]"}
{"id": "op_padto3_dec_anyeven", "entry_point": "op_padto3_dec_anyeven", "primitives": ["padto3", "dec", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then subtract one from each, then return whether any value is even.", "solution": "def op_padto3_dec_anyeven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x - 1 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_padto3_dec_anyeven([1, 2, 3, 4]) == True\nassert op_padto3_dec_anyeven([]) == False\nassert op_padto3_dec_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_padto3_dec_anyeven([5, 5, 5]) == True\nassert op_padto3_dec_anyeven([3, 1, 2]) == True\nassert op_padto3_dec_anyeven([10]) == False\nassert op_padto3_dec_anyeven([2, 4, 6]) == False\nassert op_padto3_dec_anyeven([-7, 12, -7]) == True"}
{"id": "op_square_trimends_absval", "entry_point": "op_square_trimends_absval", "primitives": ["square", "trimends", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first and last elements, then take the absolute value of each.", "solution": "def op_square_trimends_absval(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:-1]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_square_trimends_absval([1, 2, 3, 4]) == [4, 9]\nassert op_square_trimends_absval([]) == []\nassert op_square_trimends_absval([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_square_trimends_absval([5, 5, 5]) == [25]\nassert op_square_trimends_absval([3, 1, 2]) == [1]\nassert op_square_trimends_absval([10]) == []\nassert op_square_trimends_absval([2, 4, 6]) == [16]\nassert op_square_trimends_absval([-7, 12, -7]) == [144]"}
{"id": "op_padto3_inc_prod", "entry_point": "op_padto3_inc_prod", "primitives": ["padto3", "inc", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then add one to each, then return their product.", "solution": "def op_padto3_inc_prod(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_padto3_inc_prod([1, 2, 3, 4]) == 120\nassert op_padto3_inc_prod([]) == 1\nassert op_padto3_inc_prod([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_inc_prod([5, 5, 5]) == 216\nassert op_padto3_inc_prod([3, 1, 2]) == 24\nassert op_padto3_inc_prod([10]) == 11\nassert op_padto3_inc_prod([2, 4, 6]) == 105\nassert op_padto3_inc_prod([-7, 12, -7]) == 468"}
{"id": "op_oremptyzero_div3_counteven", "entry_point": "op_oremptyzero_div3_counteven", "primitives": ["oremptyzero", "div3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep multiples of three, then return how many values are even.", "solution": "def op_oremptyzero_div3_counteven(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_oremptyzero_div3_counteven([1, 2, 3, 4]) == 0\nassert op_oremptyzero_div3_counteven([]) == 1\nassert op_oremptyzero_div3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_oremptyzero_div3_counteven([5, 5, 5]) == 0\nassert op_oremptyzero_div3_counteven([3, 1, 2]) == 0\nassert op_oremptyzero_div3_counteven([10]) == 0\nassert op_oremptyzero_div3_counteven([2, 4, 6]) == 1\nassert op_oremptyzero_div3_counteven([-7, 12, -7]) == 1"}
{"id": "op_sortabs_double_pos", "entry_point": "op_sortabs_double_pos", "primitives": ["sortabs", "double", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then double each, then keep the positive numbers.", "solution": "def op_sortabs_double_pos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_sortabs_double_pos([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_sortabs_double_pos([]) == []\nassert op_sortabs_double_pos([-2, -1, 0, 1, 2]) == [2, 4]\nassert op_sortabs_double_pos([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_double_pos([3, 1, 2]) == [2, 4, 6]\nassert op_sortabs_double_pos([10]) == [20]\nassert op_sortabs_double_pos([2, 4, 6]) == [4, 8, 12]\nassert op_sortabs_double_pos([-7, 12, -7]) == [24]"}
{"id": "op_pos_dec_beforezero", "entry_point": "op_pos_dec_beforezero", "primitives": ["pos", "dec", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then subtract one from each, then keep everything before the first zero.", "solution": "def op_pos_dec_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x - 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_dec_beforezero([1, 2, 3, 4]) == []\nassert op_pos_dec_beforezero([]) == []\nassert op_pos_dec_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_pos_dec_beforezero([5, 5, 5]) == [4, 4, 4]\nassert op_pos_dec_beforezero([3, 1, 2]) == [2]\nassert op_pos_dec_beforezero([10]) == [9]\nassert op_pos_dec_beforezero([2, 4, 6]) == [1, 3, 5]\nassert op_pos_dec_beforezero([-7, 12, -7]) == [11]"}
{"id": "op_dropwhileneg_trimends_alldistinct", "entry_point": "op_dropwhileneg_trimends_alldistinct", "primitives": ["dropwhileneg", "trimends", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_dropwhileneg_trimends_alldistinct(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_dropwhileneg_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_dropwhileneg_trimends_alldistinct([]) == True\nassert op_dropwhileneg_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_dropwhileneg_trimends_alldistinct([5, 5, 5]) == True\nassert op_dropwhileneg_trimends_alldistinct([3, 1, 2]) == True\nassert op_dropwhileneg_trimends_alldistinct([10]) == True\nassert op_dropwhileneg_trimends_alldistinct([2, 4, 6]) == True\nassert op_dropwhileneg_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_pos_uniq_clamp10", "entry_point": "op_pos_uniq_clamp10", "primitives": ["pos", "uniq", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_pos_uniq_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_pos_uniq_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_uniq_clamp10([]) == []\nassert op_pos_uniq_clamp10([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_pos_uniq_clamp10([5, 5, 5]) == [5]\nassert op_pos_uniq_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_pos_uniq_clamp10([10]) == [10]\nassert op_pos_uniq_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_pos_uniq_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_inc_add10_max", "entry_point": "op_inc_add10_max", "primitives": ["inc", "add10", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return the maximum (0 if empty).", "solution": "def op_inc_add10_max(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return max(r) if r else 0", "tests": "assert op_inc_add10_max([1, 2, 3, 4]) == 15\nassert op_inc_add10_max([]) == 0\nassert op_inc_add10_max([-2, -1, 0, 1, 2]) == 13\nassert op_inc_add10_max([5, 5, 5]) == 16\nassert op_inc_add10_max([3, 1, 2]) == 14\nassert op_inc_add10_max([10]) == 21\nassert op_inc_add10_max([2, 4, 6]) == 17\nassert op_inc_add10_max([-7, 12, -7]) == 23"}
{"id": "op_neg_dropzeros_prod", "entry_point": "op_neg_dropzeros_prod", "primitives": ["neg", "dropzeros", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the zeros, then return their product.", "solution": "def op_neg_dropzeros_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x != 0]\n    return __import__('math').prod(r)", "tests": "assert op_neg_dropzeros_prod([1, 2, 3, 4]) == 1\nassert op_neg_dropzeros_prod([]) == 1\nassert op_neg_dropzeros_prod([-2, -1, 0, 1, 2]) == 2\nassert op_neg_dropzeros_prod([5, 5, 5]) == 1\nassert op_neg_dropzeros_prod([3, 1, 2]) == 1\nassert op_neg_dropzeros_prod([10]) == 1\nassert op_neg_dropzeros_prod([2, 4, 6]) == 1\nassert op_neg_dropzeros_prod([-7, 12, -7]) == 49"}
{"id": "op_sortabs_first3_negate", "entry_point": "op_sortabs_first3_negate", "primitives": ["sortabs", "first3", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep only the first three, then negate each.", "solution": "def op_sortabs_first3_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:3]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_first3_negate([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_sortabs_first3_negate([]) == []\nassert op_sortabs_first3_negate([-2, -1, 0, 1, 2]) == [0, 1, -1]\nassert op_sortabs_first3_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_first3_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_first3_negate([10]) == [-10]\nassert op_sortabs_first3_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_first3_negate([-7, 12, -7]) == [7, 7, -12]"}
{"id": "op_evens_sorta_counteven", "entry_point": "op_evens_sorta_counteven", "primitives": ["evens", "sorta", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then return how many values are even.", "solution": "def op_evens_sorta_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_evens_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_evens_sorta_counteven([]) == 0\nassert op_evens_sorta_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_evens_sorta_counteven([5, 5, 5]) == 0\nassert op_evens_sorta_counteven([3, 1, 2]) == 1\nassert op_evens_sorta_counteven([10]) == 1\nassert op_evens_sorta_counteven([2, 4, 6]) == 3\nassert op_evens_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropzeros_evens_max", "entry_point": "op_dropzeros_evens_max", "primitives": ["dropzeros", "evens", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_dropzeros_evens_max(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_dropzeros_evens_max([1, 2, 3, 4]) == 4\nassert op_dropzeros_evens_max([]) == 0\nassert op_dropzeros_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_evens_max([5, 5, 5]) == 0\nassert op_dropzeros_evens_max([3, 1, 2]) == 2\nassert op_dropzeros_evens_max([10]) == 10\nassert op_dropzeros_evens_max([2, 4, 6]) == 6\nassert op_dropzeros_evens_max([-7, 12, -7]) == 12"}
{"id": "op_neg_add10_div3", "entry_point": "op_neg_add10_div3", "primitives": ["neg", "add10", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then keep multiples of three.", "solution": "def op_neg_add10_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_neg_add10_div3([1, 2, 3, 4]) == []\nassert op_neg_add10_div3([]) == []\nassert op_neg_add10_div3([-2, -1, 0, 1, 2]) == [9]\nassert op_neg_add10_div3([5, 5, 5]) == []\nassert op_neg_add10_div3([3, 1, 2]) == []\nassert op_neg_add10_div3([10]) == []\nassert op_neg_add10_div3([2, 4, 6]) == []\nassert op_neg_add10_div3([-7, 12, -7]) == [3, 3]"}
{"id": "op_takewhilepos_pos_counteven", "entry_point": "op_takewhilepos_pos_counteven", "primitives": ["takewhilepos", "pos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep the positive numbers, then return how many values are even.", "solution": "def op_takewhilepos_pos_counteven(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_takewhilepos_pos_counteven([1, 2, 3, 4]) == 2\nassert op_takewhilepos_pos_counteven([]) == 0\nassert op_takewhilepos_pos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_pos_counteven([5, 5, 5]) == 0\nassert op_takewhilepos_pos_counteven([3, 1, 2]) == 1\nassert op_takewhilepos_pos_counteven([10]) == 1\nassert op_takewhilepos_pos_counteven([2, 4, 6]) == 3\nassert op_takewhilepos_pos_counteven([-7, 12, -7]) == 0"}
{"id": "op_takewhilepos_negate_sum", "entry_point": "op_takewhilepos_negate_sum", "primitives": ["takewhilepos", "negate", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then return their sum.", "solution": "def op_takewhilepos_negate_sum(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    return sum(r)", "tests": "assert op_takewhilepos_negate_sum([1, 2, 3, 4]) == -10\nassert op_takewhilepos_negate_sum([]) == 0\nassert op_takewhilepos_negate_sum([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_negate_sum([5, 5, 5]) == -15\nassert op_takewhilepos_negate_sum([3, 1, 2]) == -6\nassert op_takewhilepos_negate_sum([10]) == -10\nassert op_takewhilepos_negate_sum([2, 4, 6]) == -12\nassert op_takewhilepos_negate_sum([-7, 12, -7]) == 0"}
{"id": "op_uniq_first3_anyeven", "entry_point": "op_uniq_first3_anyeven", "primitives": ["uniq", "first3", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then keep only the first three, then return whether any value is even.", "solution": "def op_uniq_first3_anyeven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[:3]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_uniq_first3_anyeven([1, 2, 3, 4]) == True\nassert op_uniq_first3_anyeven([]) == False\nassert op_uniq_first3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_uniq_first3_anyeven([5, 5, 5]) == False\nassert op_uniq_first3_anyeven([3, 1, 2]) == True\nassert op_uniq_first3_anyeven([10]) == True\nassert op_uniq_first3_anyeven([2, 4, 6]) == True\nassert op_uniq_first3_anyeven([-7, 12, -7]) == True"}
{"id": "op_padto3_sorta_div3", "entry_point": "op_padto3_sorta_div3", "primitives": ["padto3", "sorta", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then sort ascending, then keep multiples of three.", "solution": "def op_padto3_sorta_div3(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_padto3_sorta_div3([1, 2, 3, 4]) == [3]\nassert op_padto3_sorta_div3([]) == [0, 0, 0]\nassert op_padto3_sorta_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_sorta_div3([5, 5, 5]) == []\nassert op_padto3_sorta_div3([3, 1, 2]) == [3]\nassert op_padto3_sorta_div3([10]) == [0, 0]\nassert op_padto3_sorta_div3([2, 4, 6]) == [6]\nassert op_padto3_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_trimends_padto3_alldistinct", "entry_point": "op_trimends_padto3_alldistinct", "primitives": ["trimends", "padto3", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then return whether all values are distinct.", "solution": "def op_trimends_padto3_alldistinct(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r) == len(set(r))", "tests": "assert op_trimends_padto3_alldistinct([1, 2, 3, 4]) == True\nassert op_trimends_padto3_alldistinct([]) == False\nassert op_trimends_padto3_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_trimends_padto3_alldistinct([5, 5, 5]) == False\nassert op_trimends_padto3_alldistinct([3, 1, 2]) == False\nassert op_trimends_padto3_alldistinct([10]) == False\nassert op_trimends_padto3_alldistinct([2, 4, 6]) == False\nassert op_trimends_padto3_alldistinct([-7, 12, -7]) == False"}
{"id": "op_lower_sortlen_dropshort", "entry_point": "op_lower_sortlen_dropshort", "primitives": ["lower", "sortlen", "dropshort"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then sort by length, shortest first, then drop strings shorter than three characters.", "solution": "def op_lower_sortlen_dropshort(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_lower_sortlen_dropshort(['Hello', 'world']) == ['hello', 'world']\nassert op_lower_sortlen_dropshort([]) == []\nassert op_lower_sortlen_dropshort(['  a ', '', 'BC', 'bc']) == ['  a ']\nassert op_lower_sortlen_dropshort(['one', 'one', 'Two']) == ['one', 'one', 'two']\nassert op_lower_sortlen_dropshort(['x']) == []\nassert op_lower_sortlen_dropshort(['abc', 'de', '']) == ['abc']"}
{"id": "op_pos_evens_beforezero", "entry_point": "op_pos_evens_beforezero", "primitives": ["pos", "evens", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then keep everything before the first zero.", "solution": "def op_pos_evens_beforezero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_pos_evens_beforezero([1, 2, 3, 4]) == [2, 4]\nassert op_pos_evens_beforezero([]) == []\nassert op_pos_evens_beforezero([-2, -1, 0, 1, 2]) == [2]\nassert op_pos_evens_beforezero([5, 5, 5]) == []\nassert op_pos_evens_beforezero([3, 1, 2]) == [2]\nassert op_pos_evens_beforezero([10]) == [10]\nassert op_pos_evens_beforezero([2, 4, 6]) == [2, 4, 6]\nassert op_pos_evens_beforezero([-7, 12, -7]) == [12]"}
{"id": "op_add10_dec_trimends", "entry_point": "op_add10_dec_trimends", "primitives": ["add10", "dec", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then subtract one from each, then drop the first and last elements.", "solution": "def op_add10_dec_trimends(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_add10_dec_trimends([1, 2, 3, 4]) == [11, 12]\nassert op_add10_dec_trimends([]) == []\nassert op_add10_dec_trimends([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_add10_dec_trimends([5, 5, 5]) == [14]\nassert op_add10_dec_trimends([3, 1, 2]) == [10]\nassert op_add10_dec_trimends([10]) == []\nassert op_add10_dec_trimends([2, 4, 6]) == [13]\nassert op_add10_dec_trimends([-7, 12, -7]) == [21]"}
{"id": "op_rev_add10_double", "entry_point": "op_rev_add10_double", "primitives": ["rev", "add10", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add ten to each, then double each.", "solution": "def op_rev_add10_double(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_rev_add10_double([1, 2, 3, 4]) == [28, 26, 24, 22]\nassert op_rev_add10_double([]) == []\nassert op_rev_add10_double([-2, -1, 0, 1, 2]) == [24, 22, 20, 18, 16]\nassert op_rev_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_rev_add10_double([3, 1, 2]) == [24, 22, 26]\nassert op_rev_add10_double([10]) == [40]\nassert op_rev_add10_double([2, 4, 6]) == [32, 28, 24]\nassert op_rev_add10_double([-7, 12, -7]) == [6, 44, 6]"}
{"id": "op_rev_uniq_len", "entry_point": "op_rev_uniq_len", "primitives": ["rev", "uniq", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then drop duplicates keeping first occurrence, then return how many remain.", "solution": "def op_rev_uniq_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = list(dict.fromkeys(r))\n    return len(r)", "tests": "assert op_rev_uniq_len([1, 2, 3, 4]) == 4\nassert op_rev_uniq_len([]) == 0\nassert op_rev_uniq_len([-2, -1, 0, 1, 2]) == 5\nassert op_rev_uniq_len([5, 5, 5]) == 1\nassert op_rev_uniq_len([3, 1, 2]) == 3\nassert op_rev_uniq_len([10]) == 1\nassert op_rev_uniq_len([2, 4, 6]) == 3\nassert op_rev_uniq_len([-7, 12, -7]) == 2"}
{"id": "op_sortd_beforezero_gt5", "entry_point": "op_sortd_beforezero_gt5", "primitives": ["sortd", "beforezero", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then keep values greater than five.", "solution": "def op_sortd_beforezero_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_beforezero_gt5([1, 2, 3, 4]) == []\nassert op_sortd_beforezero_gt5([]) == []\nassert op_sortd_beforezero_gt5([-2, -1, 0, 1, 2]) == []\nassert op_sortd_beforezero_gt5([5, 5, 5]) == []\nassert op_sortd_beforezero_gt5([3, 1, 2]) == []\nassert op_sortd_beforezero_gt5([10]) == [10]\nassert op_sortd_beforezero_gt5([2, 4, 6]) == [6]\nassert op_sortd_beforezero_gt5([-7, 12, -7]) == [12]"}
{"id": "op_trimends_odds_max", "entry_point": "op_trimends_odds_max", "primitives": ["trimends", "odds", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the odd numbers, then return the maximum (0 if empty).", "solution": "def op_trimends_odds_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 2 != 0]\n    return max(r) if r else 0", "tests": "assert op_trimends_odds_max([1, 2, 3, 4]) == 3\nassert op_trimends_odds_max([]) == 0\nassert op_trimends_odds_max([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_odds_max([5, 5, 5]) == 5\nassert op_trimends_odds_max([3, 1, 2]) == 1\nassert op_trimends_odds_max([10]) == 0\nassert op_trimends_odds_max([2, 4, 6]) == 0\nassert op_trimends_odds_max([-7, 12, -7]) == 0"}
{"id": "op_inc_beforezero_evens", "entry_point": "op_inc_beforezero_evens", "primitives": ["inc", "beforezero", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero, then keep the even numbers.", "solution": "def op_inc_beforezero_evens(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_inc_beforezero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_inc_beforezero_evens([]) == []\nassert op_inc_beforezero_evens([-2, -1, 0, 1, 2]) == []\nassert op_inc_beforezero_evens([5, 5, 5]) == [6, 6, 6]\nassert op_inc_beforezero_evens([3, 1, 2]) == [4, 2]\nassert op_inc_beforezero_evens([10]) == []\nassert op_inc_beforezero_evens([2, 4, 6]) == []\nassert op_inc_beforezero_evens([-7, 12, -7]) == [-6, -6]"}
{"id": "op_padto3_absval_rev", "entry_point": "op_padto3_absval_rev", "primitives": ["padto3", "absval", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then take the absolute value of each, then reverse the order.", "solution": "def op_padto3_absval_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_absval_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_padto3_absval_rev([]) == [0, 0, 0]\nassert op_padto3_absval_rev([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_padto3_absval_rev([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_absval_rev([3, 1, 2]) == [2, 1, 3]\nassert op_padto3_absval_rev([10]) == [0, 0, 10]\nassert op_padto3_absval_rev([2, 4, 6]) == [6, 4, 2]\nassert op_padto3_absval_rev([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_inc_odds_div3", "entry_point": "op_inc_odds_div3", "primitives": ["inc", "odds", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the odd numbers, then keep multiples of three.", "solution": "def op_inc_odds_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_odds_div3([1, 2, 3, 4]) == [3]\nassert op_inc_odds_div3([]) == []\nassert op_inc_odds_div3([-2, -1, 0, 1, 2]) == [3]\nassert op_inc_odds_div3([5, 5, 5]) == []\nassert op_inc_odds_div3([3, 1, 2]) == [3]\nassert op_inc_odds_div3([10]) == []\nassert op_inc_odds_div3([2, 4, 6]) == [3]\nassert op_inc_odds_div3([-7, 12, -7]) == []"}
{"id": "op_last3_absval_sorta", "entry_point": "op_last3_absval_sorta", "primitives": ["last3", "absval", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then take the absolute value of each, then sort ascending.", "solution": "def op_last3_absval_sorta(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_last3_absval_sorta([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_absval_sorta([]) == []\nassert op_last3_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_last3_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_last3_absval_sorta([10]) == [10]\nassert op_last3_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_last3_absval_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_neg_odds_alldistinct", "entry_point": "op_neg_odds_alldistinct", "primitives": ["neg", "odds", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep the odd numbers, then return whether all values are distinct.", "solution": "def op_neg_odds_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 2 != 0]\n    return len(r) == len(set(r))", "tests": "assert op_neg_odds_alldistinct([1, 2, 3, 4]) == True\nassert op_neg_odds_alldistinct([]) == True\nassert op_neg_odds_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_neg_odds_alldistinct([5, 5, 5]) == True\nassert op_neg_odds_alldistinct([3, 1, 2]) == True\nassert op_neg_odds_alldistinct([10]) == True\nassert op_neg_odds_alldistinct([2, 4, 6]) == True\nassert op_neg_odds_alldistinct([-7, 12, -7]) == False"}
{"id": "op_div3_negate_odds", "entry_point": "op_div3_negate_odds", "primitives": ["div3", "negate", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then negate each, then keep the odd numbers.", "solution": "def op_div3_negate_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_div3_negate_odds([1, 2, 3, 4]) == [-3]\nassert op_div3_negate_odds([]) == []\nassert op_div3_negate_odds([-2, -1, 0, 1, 2]) == []\nassert op_div3_negate_odds([5, 5, 5]) == []\nassert op_div3_negate_odds([3, 1, 2]) == [-3]\nassert op_div3_negate_odds([10]) == []\nassert op_div3_negate_odds([2, 4, 6]) == []\nassert op_div3_negate_odds([-7, 12, -7]) == []"}
{"id": "op_inc_dropzeros_haszero", "entry_point": "op_inc_dropzeros_haszero", "primitives": ["inc", "dropzeros", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the zeros, then return whether the list contains a zero.", "solution": "def op_inc_dropzeros_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x != 0]\n    return 0 in r", "tests": "assert op_inc_dropzeros_haszero([1, 2, 3, 4]) == False\nassert op_inc_dropzeros_haszero([]) == False\nassert op_inc_dropzeros_haszero([-2, -1, 0, 1, 2]) == False\nassert op_inc_dropzeros_haszero([5, 5, 5]) == False\nassert op_inc_dropzeros_haszero([3, 1, 2]) == False\nassert op_inc_dropzeros_haszero([10]) == False\nassert op_inc_dropzeros_haszero([2, 4, 6]) == False\nassert op_inc_dropzeros_haszero([-7, 12, -7]) == False"}
{"id": "op_dec_sortd_min", "entry_point": "op_dec_sortd_min", "primitives": ["dec", "sortd", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort descending, then return the minimum (0 if empty).", "solution": "def op_dec_sortd_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, reverse=True)\n    return min(r) if r else 0", "tests": "assert op_dec_sortd_min([1, 2, 3, 4]) == 0\nassert op_dec_sortd_min([]) == 0\nassert op_dec_sortd_min([-2, -1, 0, 1, 2]) == -3\nassert op_dec_sortd_min([5, 5, 5]) == 4\nassert op_dec_sortd_min([3, 1, 2]) == 0\nassert op_dec_sortd_min([10]) == 9\nassert op_dec_sortd_min([2, 4, 6]) == 1\nassert op_dec_sortd_min([-7, 12, -7]) == -8"}
{"id": "op_last3_first3_min", "entry_point": "op_last3_first3_min", "primitives": ["last3", "first3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_last3_first3_min(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_last3_first3_min([1, 2, 3, 4]) == 2\nassert op_last3_first3_min([]) == 0\nassert op_last3_first3_min([-2, -1, 0, 1, 2]) == 0\nassert op_last3_first3_min([5, 5, 5]) == 5\nassert op_last3_first3_min([3, 1, 2]) == 1\nassert op_last3_first3_min([10]) == 10\nassert op_last3_first3_min([2, 4, 6]) == 2\nassert op_last3_first3_min([-7, 12, -7]) == -7"}
{"id": "op_inc_dec_max", "entry_point": "op_inc_dec_max", "primitives": ["inc", "dec", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then subtract one from each, then return the maximum (0 if empty).", "solution": "def op_inc_dec_max(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x - 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_inc_dec_max([1, 2, 3, 4]) == 4\nassert op_inc_dec_max([]) == 0\nassert op_inc_dec_max([-2, -1, 0, 1, 2]) == 2\nassert op_inc_dec_max([5, 5, 5]) == 5\nassert op_inc_dec_max([3, 1, 2]) == 3\nassert op_inc_dec_max([10]) == 10\nassert op_inc_dec_max([2, 4, 6]) == 6\nassert op_inc_dec_max([-7, 12, -7]) == 12"}
{"id": "op_uniq_add10_double", "entry_point": "op_uniq_add10_double", "primitives": ["uniq", "add10", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then add ten to each, then double each.", "solution": "def op_uniq_add10_double(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_uniq_add10_double([1, 2, 3, 4]) == [22, 24, 26, 28]\nassert op_uniq_add10_double([]) == []\nassert op_uniq_add10_double([-2, -1, 0, 1, 2]) == [16, 18, 20, 22, 24]\nassert op_uniq_add10_double([5, 5, 5]) == [30]\nassert op_uniq_add10_double([3, 1, 2]) == [26, 22, 24]\nassert op_uniq_add10_double([10]) == [40]\nassert op_uniq_add10_double([2, 4, 6]) == [24, 28, 32]\nassert op_uniq_add10_double([-7, 12, -7]) == [6, 44]"}
{"id": "op_add10_dropzeros_uniq", "entry_point": "op_add10_dropzeros_uniq", "primitives": ["add10", "dropzeros", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then drop duplicates keeping first occurrence.", "solution": "def op_add10_dropzeros_uniq(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_add10_dropzeros_uniq([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_dropzeros_uniq([]) == []\nassert op_add10_dropzeros_uniq([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_dropzeros_uniq([5, 5, 5]) == [15]\nassert op_add10_dropzeros_uniq([3, 1, 2]) == [13, 11, 12]\nassert op_add10_dropzeros_uniq([10]) == [20]\nassert op_add10_dropzeros_uniq([2, 4, 6]) == [12, 14, 16]\nassert op_add10_dropzeros_uniq([-7, 12, -7]) == [3, 22]"}
{"id": "op_rev_sortd_oremptyzero", "entry_point": "op_rev_sortd_oremptyzero", "primitives": ["rev", "sortd", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then sort descending, then if empty, use a single zero.", "solution": "def op_rev_sortd_oremptyzero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    return r", "tests": "assert op_rev_sortd_oremptyzero([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_sortd_oremptyzero([]) == [0]\nassert op_rev_sortd_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_sortd_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_rev_sortd_oremptyzero([3, 1, 2]) == [3, 2, 1]\nassert op_rev_sortd_oremptyzero([10]) == [10]\nassert op_rev_sortd_oremptyzero([2, 4, 6]) == [6, 4, 2]\nassert op_rev_sortd_oremptyzero([-7, 12, -7]) == [12, -7, -7]"}
{"id": "op_gt5_double_anyeven", "entry_point": "op_gt5_double_anyeven", "primitives": ["gt5", "double", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then double each, then return whether any value is even.", "solution": "def op_gt5_double_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x * 2 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_gt5_double_anyeven([1, 2, 3, 4]) == False\nassert op_gt5_double_anyeven([]) == False\nassert op_gt5_double_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_gt5_double_anyeven([5, 5, 5]) == False\nassert op_gt5_double_anyeven([3, 1, 2]) == False\nassert op_gt5_double_anyeven([10]) == True\nassert op_gt5_double_anyeven([2, 4, 6]) == True\nassert op_gt5_double_anyeven([-7, 12, -7]) == True"}
{"id": "op_negate_takewhilepos_last3", "entry_point": "op_negate_takewhilepos_last3", "primitives": ["negate", "takewhilepos", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then keep only the last three.", "solution": "def op_negate_takewhilepos_last3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    return r", "tests": "assert op_negate_takewhilepos_last3([1, 2, 3, 4]) == []\nassert op_negate_takewhilepos_last3([]) == []\nassert op_negate_takewhilepos_last3([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_takewhilepos_last3([5, 5, 5]) == []\nassert op_negate_takewhilepos_last3([3, 1, 2]) == []\nassert op_negate_takewhilepos_last3([10]) == []\nassert op_negate_takewhilepos_last3([2, 4, 6]) == []\nassert op_negate_takewhilepos_last3([-7, 12, -7]) == [7]"}
{"id": "op_gt5_padto3_square", "entry_point": "op_gt5_padto3_square", "primitives": ["gt5", "padto3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then square each.", "solution": "def op_gt5_padto3_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * x for x in r]\n    return r", "tests": "assert op_gt5_padto3_square([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_padto3_square([]) == [0, 0, 0]\nassert op_gt5_padto3_square([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_square([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_padto3_square([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_square([10]) == [100, 0, 0]\nassert op_gt5_padto3_square([2, 4, 6]) == [36, 0, 0]\nassert op_gt5_padto3_square([-7, 12, -7]) == [144, 0, 0]"}
{"id": "op_dropfirst_dropwhileneg_trimends", "entry_point": "op_dropfirst_dropwhileneg_trimends", "primitives": ["dropfirst", "dropwhileneg", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then drop the first and last elements.", "solution": "def op_dropfirst_dropwhileneg_trimends(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:-1]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_trimends([1, 2, 3, 4]) == [3]\nassert op_dropfirst_dropwhileneg_trimends([]) == []\nassert op_dropfirst_dropwhileneg_trimends([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_dropwhileneg_trimends([5, 5, 5]) == []\nassert op_dropfirst_dropwhileneg_trimends([3, 1, 2]) == []\nassert op_dropfirst_dropwhileneg_trimends([10]) == []\nassert op_dropfirst_dropwhileneg_trimends([2, 4, 6]) == []\nassert op_dropfirst_dropwhileneg_trimends([-7, 12, -7]) == []"}
{"id": "op_gt5_inc_haszero", "entry_point": "op_gt5_inc_haszero", "primitives": ["gt5", "inc", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add one to each, then return whether the list contains a zero.", "solution": "def op_gt5_inc_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 1 for x in r]\n    return 0 in r", "tests": "assert op_gt5_inc_haszero([1, 2, 3, 4]) == False\nassert op_gt5_inc_haszero([]) == False\nassert op_gt5_inc_haszero([-2, -1, 0, 1, 2]) == False\nassert op_gt5_inc_haszero([5, 5, 5]) == False\nassert op_gt5_inc_haszero([3, 1, 2]) == False\nassert op_gt5_inc_haszero([10]) == False\nassert op_gt5_inc_haszero([2, 4, 6]) == False\nassert op_gt5_inc_haszero([-7, 12, -7]) == False"}
{"id": "op_rev_inc_clamp10", "entry_point": "op_rev_inc_clamp10", "primitives": ["rev", "inc", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then add one to each, then cap each value at 10.", "solution": "def op_rev_inc_clamp10(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x + 1 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_rev_inc_clamp10([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_rev_inc_clamp10([]) == []\nassert op_rev_inc_clamp10([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_rev_inc_clamp10([5, 5, 5]) == [6, 6, 6]\nassert op_rev_inc_clamp10([3, 1, 2]) == [3, 2, 4]\nassert op_rev_inc_clamp10([10]) == [10]\nassert op_rev_inc_clamp10([2, 4, 6]) == [7, 5, 3]\nassert op_rev_inc_clamp10([-7, 12, -7]) == [-6, 10, -6]"}
{"id": "op_beforezero_first3_takewhilepos", "entry_point": "op_beforezero_first3_takewhilepos", "primitives": ["beforezero", "first3", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then take values while they are positive.", "solution": "def op_beforezero_first3_takewhilepos(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_beforezero_first3_takewhilepos([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_takewhilepos([]) == []\nassert op_beforezero_first3_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_first3_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_takewhilepos([10]) == [10]\nassert op_beforezero_first3_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_sortd_beforezero_dec", "entry_point": "op_sortd_beforezero_dec", "primitives": ["sortd", "beforezero", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep everything before the first zero, then subtract one from each.", "solution": "def op_sortd_beforezero_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_beforezero_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortd_beforezero_dec([]) == []\nassert op_sortd_beforezero_dec([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_sortd_beforezero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_beforezero_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_beforezero_dec([10]) == [9]\nassert op_sortd_beforezero_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_beforezero_dec([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_odds_div3_dec", "entry_point": "op_odds_div3_dec", "primitives": ["odds", "div3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then subtract one from each.", "solution": "def op_odds_div3_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_odds_div3_dec([1, 2, 3, 4]) == [2]\nassert op_odds_div3_dec([]) == []\nassert op_odds_div3_dec([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_dec([5, 5, 5]) == []\nassert op_odds_div3_dec([3, 1, 2]) == [2]\nassert op_odds_div3_dec([10]) == []\nassert op_odds_div3_dec([2, 4, 6]) == []\nassert op_odds_div3_dec([-7, 12, -7]) == []"}
{"id": "op_double_dropwhileneg_absval", "entry_point": "op_double_dropwhileneg_absval", "primitives": ["double", "dropwhileneg", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then take the absolute value of each.", "solution": "def op_double_dropwhileneg_absval(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_double_dropwhileneg_absval([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_double_dropwhileneg_absval([]) == []\nassert op_double_dropwhileneg_absval([-2, -1, 0, 1, 2]) == [0, 2, 4]\nassert op_double_dropwhileneg_absval([5, 5, 5]) == [10, 10, 10]\nassert op_double_dropwhileneg_absval([3, 1, 2]) == [6, 2, 4]\nassert op_double_dropwhileneg_absval([10]) == [20]\nassert op_double_dropwhileneg_absval([2, 4, 6]) == [4, 8, 12]\nassert op_double_dropwhileneg_absval([-7, 12, -7]) == [24, 14]"}
{"id": "op_first3_add10_gt5", "entry_point": "op_first3_add10_gt5", "primitives": ["first3", "add10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add ten to each, then keep values greater than five.", "solution": "def op_first3_add10_gt5(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_first3_add10_gt5([1, 2, 3, 4]) == [11, 12, 13]\nassert op_first3_add10_gt5([]) == []\nassert op_first3_add10_gt5([-2, -1, 0, 1, 2]) == [8, 9, 10]\nassert op_first3_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_first3_add10_gt5([3, 1, 2]) == [13, 11, 12]\nassert op_first3_add10_gt5([10]) == [20]\nassert op_first3_add10_gt5([2, 4, 6]) == [12, 14, 16]\nassert op_first3_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_clamp10_trimends_sortd", "entry_point": "op_clamp10_trimends_sortd", "primitives": ["clamp10", "trimends", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the first and last elements, then sort descending.", "solution": "def op_clamp10_trimends_sortd(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_clamp10_trimends_sortd([1, 2, 3, 4]) == [3, 2]\nassert op_clamp10_trimends_sortd([]) == []\nassert op_clamp10_trimends_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_clamp10_trimends_sortd([5, 5, 5]) == [5]\nassert op_clamp10_trimends_sortd([3, 1, 2]) == [1]\nassert op_clamp10_trimends_sortd([10]) == []\nassert op_clamp10_trimends_sortd([2, 4, 6]) == [4]\nassert op_clamp10_trimends_sortd([-7, 12, -7]) == [10]"}
{"id": "op_last3_dropfirst_negate", "entry_point": "op_last3_dropfirst_negate", "primitives": ["last3", "dropfirst", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then negate each.", "solution": "def op_last3_dropfirst_negate(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_last3_dropfirst_negate([1, 2, 3, 4]) == [-3, -4]\nassert op_last3_dropfirst_negate([]) == []\nassert op_last3_dropfirst_negate([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_last3_dropfirst_negate([5, 5, 5]) == [-5, -5]\nassert op_last3_dropfirst_negate([3, 1, 2]) == [-1, -2]\nassert op_last3_dropfirst_negate([10]) == []\nassert op_last3_dropfirst_negate([2, 4, 6]) == [-4, -6]\nassert op_last3_dropfirst_negate([-7, 12, -7]) == [-12, 7]"}
{"id": "op_oremptyzero_evens_sortabs", "entry_point": "op_oremptyzero_evens_sortabs", "primitives": ["oremptyzero", "evens", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the even numbers, then sort by absolute value.", "solution": "def op_oremptyzero_evens_sortabs(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_oremptyzero_evens_sortabs([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_evens_sortabs([]) == [0]\nassert op_oremptyzero_evens_sortabs([-2, -1, 0, 1, 2]) == [0, -2, 2]\nassert op_oremptyzero_evens_sortabs([5, 5, 5]) == []\nassert op_oremptyzero_evens_sortabs([3, 1, 2]) == [2]\nassert op_oremptyzero_evens_sortabs([10]) == [10]\nassert op_oremptyzero_evens_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_evens_sortabs([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_padto3_dropfirst", "entry_point": "op_sortabs_padto3_dropfirst", "primitives": ["sortabs", "padto3", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then pad with zeros to at least three elements, then drop the first element.", "solution": "def op_sortabs_padto3_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_padto3_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_sortabs_padto3_dropfirst([]) == [0, 0]\nassert op_sortabs_padto3_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, -2, 2]\nassert op_sortabs_padto3_dropfirst([5, 5, 5]) == [5, 5]\nassert op_sortabs_padto3_dropfirst([3, 1, 2]) == [2, 3]\nassert op_sortabs_padto3_dropfirst([10]) == [0, 0]\nassert op_sortabs_padto3_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sortabs_padto3_dropfirst([-7, 12, -7]) == [-7, 12]"}
{"id": "op_double_div3_dropfirst", "entry_point": "op_double_div3_dropfirst", "primitives": ["double", "div3", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep multiples of three, then drop the first element.", "solution": "def op_double_div3_dropfirst(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_double_div3_dropfirst([1, 2, 3, 4]) == []\nassert op_double_div3_dropfirst([]) == []\nassert op_double_div3_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_double_div3_dropfirst([5, 5, 5]) == []\nassert op_double_div3_dropfirst([3, 1, 2]) == []\nassert op_double_div3_dropfirst([10]) == []\nassert op_double_div3_dropfirst([2, 4, 6]) == []\nassert op_double_div3_dropfirst([-7, 12, -7]) == []"}
{"id": "op_uniq_dropzeros_counteven", "entry_point": "op_uniq_dropzeros_counteven", "primitives": ["uniq", "dropzeros", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the zeros, then return how many values are even.", "solution": "def op_uniq_dropzeros_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_dropzeros_counteven([1, 2, 3, 4]) == 2\nassert op_uniq_dropzeros_counteven([]) == 0\nassert op_uniq_dropzeros_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_uniq_dropzeros_counteven([5, 5, 5]) == 0\nassert op_uniq_dropzeros_counteven([3, 1, 2]) == 1\nassert op_uniq_dropzeros_counteven([10]) == 1\nassert op_uniq_dropzeros_counteven([2, 4, 6]) == 3\nassert op_uniq_dropzeros_counteven([-7, 12, -7]) == 1"}
{"id": "op_oremptyzero_uniq_clamp10", "entry_point": "op_oremptyzero_uniq_clamp10", "primitives": ["oremptyzero", "uniq", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence, then cap each value at 10.", "solution": "def op_oremptyzero_uniq_clamp10(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_oremptyzero_uniq_clamp10([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_uniq_clamp10([]) == [0]\nassert op_oremptyzero_uniq_clamp10([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_uniq_clamp10([5, 5, 5]) == [5]\nassert op_oremptyzero_uniq_clamp10([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_uniq_clamp10([10]) == [10]\nassert op_oremptyzero_uniq_clamp10([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_uniq_clamp10([-7, 12, -7]) == [-7, 10]"}
{"id": "op_square_gt5_beforezero", "entry_point": "op_square_gt5_beforezero", "primitives": ["square", "gt5", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep values greater than five, then keep everything before the first zero.", "solution": "def op_square_gt5_beforezero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_square_gt5_beforezero([1, 2, 3, 4]) == [9, 16]\nassert op_square_gt5_beforezero([]) == []\nassert op_square_gt5_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_square_gt5_beforezero([5, 5, 5]) == [25, 25, 25]\nassert op_square_gt5_beforezero([3, 1, 2]) == [9]\nassert op_square_gt5_beforezero([10]) == [100]\nassert op_square_gt5_beforezero([2, 4, 6]) == [16, 36]\nassert op_square_gt5_beforezero([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_clamp10_sorta_prod", "entry_point": "op_clamp10_sorta_prod", "primitives": ["clamp10", "sorta", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then return their product.", "solution": "def op_clamp10_sorta_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_sorta_prod([1, 2, 3, 4]) == 24\nassert op_clamp10_sorta_prod([]) == 1\nassert op_clamp10_sorta_prod([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_sorta_prod([5, 5, 5]) == 125\nassert op_clamp10_sorta_prod([3, 1, 2]) == 6\nassert op_clamp10_sorta_prod([10]) == 10\nassert op_clamp10_sorta_prod([2, 4, 6]) == 48\nassert op_clamp10_sorta_prod([-7, 12, -7]) == 490"}
{"id": "op_inc_gt5_counteven", "entry_point": "op_inc_gt5_counteven", "primitives": ["inc", "gt5", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep values greater than five, then return how many values are even.", "solution": "def op_inc_gt5_counteven(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_inc_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_inc_gt5_counteven([]) == 0\nassert op_inc_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_inc_gt5_counteven([5, 5, 5]) == 3\nassert op_inc_gt5_counteven([3, 1, 2]) == 0\nassert op_inc_gt5_counteven([10]) == 0\nassert op_inc_gt5_counteven([2, 4, 6]) == 0\nassert op_inc_gt5_counteven([-7, 12, -7]) == 0"}
{"id": "op_dec_square_neg", "entry_point": "op_dec_square_neg", "primitives": ["dec", "square", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then square each, then keep the negative numbers.", "solution": "def op_dec_square_neg(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dec_square_neg([1, 2, 3, 4]) == []\nassert op_dec_square_neg([]) == []\nassert op_dec_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_dec_square_neg([5, 5, 5]) == []\nassert op_dec_square_neg([3, 1, 2]) == []\nassert op_dec_square_neg([10]) == []\nassert op_dec_square_neg([2, 4, 6]) == []\nassert op_dec_square_neg([-7, 12, -7]) == []"}
{"id": "op_gt5_sortabs_uniq", "entry_point": "op_gt5_sortabs_uniq", "primitives": ["gt5", "sortabs", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then drop duplicates keeping first occurrence.", "solution": "def op_gt5_sortabs_uniq(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_gt5_sortabs_uniq([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_uniq([]) == []\nassert op_gt5_sortabs_uniq([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_uniq([5, 5, 5]) == []\nassert op_gt5_sortabs_uniq([3, 1, 2]) == []\nassert op_gt5_sortabs_uniq([10]) == [10]\nassert op_gt5_sortabs_uniq([2, 4, 6]) == [6]\nassert op_gt5_sortabs_uniq([-7, 12, -7]) == [12]"}
{"id": "op_takewhilepos_dec_sortabs", "entry_point": "op_takewhilepos_dec_sortabs", "primitives": ["takewhilepos", "dec", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then subtract one from each, then sort by absolute value.", "solution": "def op_takewhilepos_dec_sortabs(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_takewhilepos_dec_sortabs([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_takewhilepos_dec_sortabs([]) == []\nassert op_takewhilepos_dec_sortabs([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dec_sortabs([5, 5, 5]) == [4, 4, 4]\nassert op_takewhilepos_dec_sortabs([3, 1, 2]) == [0, 1, 2]\nassert op_takewhilepos_dec_sortabs([10]) == [9]\nassert op_takewhilepos_dec_sortabs([2, 4, 6]) == [1, 3, 5]\nassert op_takewhilepos_dec_sortabs([-7, 12, -7]) == []"}
{"id": "op_sortd_gt5_dropwhileneg", "entry_point": "op_sortd_gt5_dropwhileneg", "primitives": ["sortd", "gt5", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep values greater than five, then drop the leading negative values.", "solution": "def op_sortd_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortd_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_sortd_gt5_dropwhileneg([]) == []\nassert op_sortd_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_sortd_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_sortd_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_sortd_gt5_dropwhileneg([10]) == [10]\nassert op_sortd_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_sortd_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_double_dropzeros_square", "entry_point": "op_double_dropzeros_square", "primitives": ["double", "dropzeros", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the zeros, then square each.", "solution": "def op_double_dropzeros_square(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_double_dropzeros_square([1, 2, 3, 4]) == [4, 16, 36, 64]\nassert op_double_dropzeros_square([]) == []\nassert op_double_dropzeros_square([-2, -1, 0, 1, 2]) == [16, 4, 4, 16]\nassert op_double_dropzeros_square([5, 5, 5]) == [100, 100, 100]\nassert op_double_dropzeros_square([3, 1, 2]) == [36, 4, 16]\nassert op_double_dropzeros_square([10]) == [400]\nassert op_double_dropzeros_square([2, 4, 6]) == [16, 64, 144]\nassert op_double_dropzeros_square([-7, 12, -7]) == [196, 576, 196]"}
{"id": "op_dropfirst_pos_odds", "entry_point": "op_dropfirst_pos_odds", "primitives": ["dropfirst", "pos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_dropfirst_pos_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_pos_odds([1, 2, 3, 4]) == [3]\nassert op_dropfirst_pos_odds([]) == []\nassert op_dropfirst_pos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_dropfirst_pos_odds([5, 5, 5]) == [5, 5]\nassert op_dropfirst_pos_odds([3, 1, 2]) == [1]\nassert op_dropfirst_pos_odds([10]) == []\nassert op_dropfirst_pos_odds([2, 4, 6]) == []\nassert op_dropfirst_pos_odds([-7, 12, -7]) == []"}
{"id": "op_pos_padto3_absval", "entry_point": "op_pos_padto3_absval", "primitives": ["pos", "padto3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then pad with zeros to at least three elements, then take the absolute value of each.", "solution": "def op_pos_padto3_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_pos_padto3_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_pos_padto3_absval([]) == [0, 0, 0]\nassert op_pos_padto3_absval([-2, -1, 0, 1, 2]) == [1, 2, 0]\nassert op_pos_padto3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_pos_padto3_absval([3, 1, 2]) == [3, 1, 2]\nassert op_pos_padto3_absval([10]) == [10, 0, 0]\nassert op_pos_padto3_absval([2, 4, 6]) == [2, 4, 6]\nassert op_pos_padto3_absval([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_dropzeros_rev_neg", "entry_point": "op_dropzeros_rev_neg", "primitives": ["dropzeros", "rev", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then reverse the order, then keep the negative numbers.", "solution": "def op_dropzeros_rev_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_dropzeros_rev_neg([1, 2, 3, 4]) == []\nassert op_dropzeros_rev_neg([]) == []\nassert op_dropzeros_rev_neg([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_dropzeros_rev_neg([5, 5, 5]) == []\nassert op_dropzeros_rev_neg([3, 1, 2]) == []\nassert op_dropzeros_rev_neg([10]) == []\nassert op_dropzeros_rev_neg([2, 4, 6]) == []\nassert op_dropzeros_rev_neg([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sorta_takewhilepos_dec", "entry_point": "op_sorta_takewhilepos_dec", "primitives": ["sorta", "takewhilepos", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then take values while they are positive, then subtract one from each.", "solution": "def op_sorta_takewhilepos_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_takewhilepos_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sorta_takewhilepos_dec([]) == []\nassert op_sorta_takewhilepos_dec([-2, -1, 0, 1, 2]) == []\nassert op_sorta_takewhilepos_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_takewhilepos_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sorta_takewhilepos_dec([10]) == [9]\nassert op_sorta_takewhilepos_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sorta_takewhilepos_dec([-7, 12, -7]) == []"}
{"id": "op_sortd_inc_max", "entry_point": "op_sortd_inc_max", "primitives": ["sortd", "inc", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add one to each, then return the maximum (0 if empty).", "solution": "def op_sortd_inc_max(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 1 for x in r]\n    return max(r) if r else 0", "tests": "assert op_sortd_inc_max([1, 2, 3, 4]) == 5\nassert op_sortd_inc_max([]) == 0\nassert op_sortd_inc_max([-2, -1, 0, 1, 2]) == 3\nassert op_sortd_inc_max([5, 5, 5]) == 6\nassert op_sortd_inc_max([3, 1, 2]) == 4\nassert op_sortd_inc_max([10]) == 11\nassert op_sortd_inc_max([2, 4, 6]) == 7\nassert op_sortd_inc_max([-7, 12, -7]) == 13"}
{"id": "op_first3_oremptyzero_dropwhileneg", "entry_point": "op_first3_oremptyzero_dropwhileneg", "primitives": ["first3", "oremptyzero", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then if empty, use a single zero, then drop the leading negative values.", "solution": "def op_first3_oremptyzero_dropwhileneg(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_first3_oremptyzero_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_oremptyzero_dropwhileneg([]) == [0]\nassert op_first3_oremptyzero_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_first3_oremptyzero_dropwhileneg([5, 5, 5]) == [5, 5, 5]\nassert op_first3_oremptyzero_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_first3_oremptyzero_dropwhileneg([10]) == [10]\nassert op_first3_oremptyzero_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_first3_oremptyzero_dropwhileneg([-7, 12, -7]) == [12, -7]"}
{"id": "op_square_double_odds", "entry_point": "op_square_double_odds", "primitives": ["square", "double", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then double each, then keep the odd numbers.", "solution": "def op_square_double_odds(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_square_double_odds([1, 2, 3, 4]) == []\nassert op_square_double_odds([]) == []\nassert op_square_double_odds([-2, -1, 0, 1, 2]) == []\nassert op_square_double_odds([5, 5, 5]) == []\nassert op_square_double_odds([3, 1, 2]) == []\nassert op_square_double_odds([10]) == []\nassert op_square_double_odds([2, 4, 6]) == []\nassert op_square_double_odds([-7, 12, -7]) == []"}
{"id": "op_sortd_add10_gt5", "entry_point": "op_sortd_add10_gt5", "primitives": ["sortd", "add10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then keep values greater than five.", "solution": "def op_sortd_add10_gt5(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortd_add10_gt5([1, 2, 3, 4]) == [14, 13, 12, 11]\nassert op_sortd_add10_gt5([]) == []\nassert op_sortd_add10_gt5([-2, -1, 0, 1, 2]) == [12, 11, 10, 9, 8]\nassert op_sortd_add10_gt5([5, 5, 5]) == [15, 15, 15]\nassert op_sortd_add10_gt5([3, 1, 2]) == [13, 12, 11]\nassert op_sortd_add10_gt5([10]) == [20]\nassert op_sortd_add10_gt5([2, 4, 6]) == [16, 14, 12]\nassert op_sortd_add10_gt5([-7, 12, -7]) == [22]"}
{"id": "op_dec_padto3_len", "entry_point": "op_dec_padto3_len", "primitives": ["dec", "padto3", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then pad with zeros to at least three elements, then return how many remain.", "solution": "def op_dec_padto3_len(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return len(r)", "tests": "assert op_dec_padto3_len([1, 2, 3, 4]) == 4\nassert op_dec_padto3_len([]) == 3\nassert op_dec_padto3_len([-2, -1, 0, 1, 2]) == 5\nassert op_dec_padto3_len([5, 5, 5]) == 3\nassert op_dec_padto3_len([3, 1, 2]) == 3\nassert op_dec_padto3_len([10]) == 3\nassert op_dec_padto3_len([2, 4, 6]) == 3\nassert op_dec_padto3_len([-7, 12, -7]) == 3"}
{"id": "op_sorta_dropzeros_dec", "entry_point": "op_sorta_dropzeros_dec", "primitives": ["sorta", "dropzeros", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then drop the zeros, then subtract one from each.", "solution": "def op_sorta_dropzeros_dec(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x for x in r if x != 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sorta_dropzeros_dec([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_sorta_dropzeros_dec([]) == []\nassert op_sorta_dropzeros_dec([-2, -1, 0, 1, 2]) == [-3, -2, 0, 1]\nassert op_sorta_dropzeros_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sorta_dropzeros_dec([3, 1, 2]) == [0, 1, 2]\nassert op_sorta_dropzeros_dec([10]) == [9]\nassert op_sorta_dropzeros_dec([2, 4, 6]) == [1, 3, 5]\nassert op_sorta_dropzeros_dec([-7, 12, -7]) == [-8, -8, 11]"}
{"id": "op_ages_dropfirst_trimends", "entry_point": "op_ages_dropfirst_trimends", "primitives": ["ages", "dropfirst", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then drop the first element, then drop the first and last elements.", "solution": "def op_ages_dropfirst_trimends(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[1:]\n    r = r[1:-1]\n    return r", "tests": "assert op_ages_dropfirst_trimends([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_dropfirst_trimends([]) == []\nassert op_ages_dropfirst_trimends([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == []\nassert op_ages_dropfirst_trimends([{'name': 'Fi', 'age': 41}]) == []"}
{"id": "op_negate_dropzeros_firsteven", "entry_point": "op_negate_dropzeros_firsteven", "primitives": ["negate", "dropzeros", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then return the first even value (0 if none).", "solution": "def op_negate_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_dropzeros_firsteven([1, 2, 3, 4]) == -2\nassert op_negate_dropzeros_firsteven([]) == 0\nassert op_negate_dropzeros_firsteven([-2, -1, 0, 1, 2]) == 2\nassert op_negate_dropzeros_firsteven([5, 5, 5]) == 0\nassert op_negate_dropzeros_firsteven([3, 1, 2]) == -2\nassert op_negate_dropzeros_firsteven([10]) == -10\nassert op_negate_dropzeros_firsteven([2, 4, 6]) == -2\nassert op_negate_dropzeros_firsteven([-7, 12, -7]) == -12"}
{"id": "op_absval_double_inc", "entry_point": "op_absval_double_inc", "primitives": ["absval", "double", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then double each, then add one to each.", "solution": "def op_absval_double_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * 2 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_double_inc([1, 2, 3, 4]) == [3, 5, 7, 9]\nassert op_absval_double_inc([]) == []\nassert op_absval_double_inc([-2, -1, 0, 1, 2]) == [5, 3, 1, 3, 5]\nassert op_absval_double_inc([5, 5, 5]) == [11, 11, 11]\nassert op_absval_double_inc([3, 1, 2]) == [7, 3, 5]\nassert op_absval_double_inc([10]) == [21]\nassert op_absval_double_inc([2, 4, 6]) == [5, 9, 13]\nassert op_absval_double_inc([-7, 12, -7]) == [15, 25, 15]"}
{"id": "op_padto3_div3_rev", "entry_point": "op_padto3_div3_rev", "primitives": ["padto3", "div3", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep multiples of three, then reverse the order.", "solution": "def op_padto3_div3_rev(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_padto3_div3_rev([1, 2, 3, 4]) == [3]\nassert op_padto3_div3_rev([]) == [0, 0, 0]\nassert op_padto3_div3_rev([-2, -1, 0, 1, 2]) == [0]\nassert op_padto3_div3_rev([5, 5, 5]) == []\nassert op_padto3_div3_rev([3, 1, 2]) == [3]\nassert op_padto3_div3_rev([10]) == [0, 0]\nassert op_padto3_div3_rev([2, 4, 6]) == [6]\nassert op_padto3_div3_rev([-7, 12, -7]) == [12]"}
{"id": "op_pos_evens_max", "entry_point": "op_pos_evens_max", "primitives": ["pos", "evens", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep the even numbers, then return the maximum (0 if empty).", "solution": "def op_pos_evens_max(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 == 0]\n    return max(r) if r else 0", "tests": "assert op_pos_evens_max([1, 2, 3, 4]) == 4\nassert op_pos_evens_max([]) == 0\nassert op_pos_evens_max([-2, -1, 0, 1, 2]) == 2\nassert op_pos_evens_max([5, 5, 5]) == 0\nassert op_pos_evens_max([3, 1, 2]) == 2\nassert op_pos_evens_max([10]) == 10\nassert op_pos_evens_max([2, 4, 6]) == 6\nassert op_pos_evens_max([-7, 12, -7]) == 12"}
{"id": "op_evens_add10_trimends", "entry_point": "op_evens_add10_trimends", "primitives": ["evens", "add10", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then drop the first and last elements.", "solution": "def op_evens_add10_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_evens_add10_trimends([1, 2, 3, 4]) == []\nassert op_evens_add10_trimends([]) == []\nassert op_evens_add10_trimends([-2, -1, 0, 1, 2]) == [10]\nassert op_evens_add10_trimends([5, 5, 5]) == []\nassert op_evens_add10_trimends([3, 1, 2]) == []\nassert op_evens_add10_trimends([10]) == []\nassert op_evens_add10_trimends([2, 4, 6]) == [14]\nassert op_evens_add10_trimends([-7, 12, -7]) == []"}
{"id": "op_absval_last3_allpos", "entry_point": "op_absval_last3_allpos", "primitives": ["absval", "last3", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then return whether all values are positive.", "solution": "def op_absval_last3_allpos(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return all(x > 0 for x in r)", "tests": "assert op_absval_last3_allpos([1, 2, 3, 4]) == True\nassert op_absval_last3_allpos([]) == True\nassert op_absval_last3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_absval_last3_allpos([5, 5, 5]) == True\nassert op_absval_last3_allpos([3, 1, 2]) == True\nassert op_absval_last3_allpos([10]) == True\nassert op_absval_last3_allpos([2, 4, 6]) == True\nassert op_absval_last3_allpos([-7, 12, -7]) == True"}
{"id": "op_negate_pos_inc", "entry_point": "op_negate_pos_inc", "primitives": ["negate", "pos", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then add one to each.", "solution": "def op_negate_pos_inc(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_negate_pos_inc([1, 2, 3, 4]) == []\nassert op_negate_pos_inc([]) == []\nassert op_negate_pos_inc([-2, -1, 0, 1, 2]) == [3, 2]\nassert op_negate_pos_inc([5, 5, 5]) == []\nassert op_negate_pos_inc([3, 1, 2]) == []\nassert op_negate_pos_inc([10]) == []\nassert op_negate_pos_inc([2, 4, 6]) == []\nassert op_negate_pos_inc([-7, 12, -7]) == [8, 8]"}
{"id": "op_sortd_padto3_inc", "entry_point": "op_sortd_padto3_inc", "primitives": ["sortd", "padto3", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then pad with zeros to at least three elements, then add one to each.", "solution": "def op_sortd_padto3_inc(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sortd_padto3_inc([1, 2, 3, 4]) == [5, 4, 3, 2]\nassert op_sortd_padto3_inc([]) == [1, 1, 1]\nassert op_sortd_padto3_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sortd_padto3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sortd_padto3_inc([3, 1, 2]) == [4, 3, 2]\nassert op_sortd_padto3_inc([10]) == [11, 1, 1]\nassert op_sortd_padto3_inc([2, 4, 6]) == [7, 5, 3]\nassert op_sortd_padto3_inc([-7, 12, -7]) == [13, -6, -6]"}
{"id": "op_square_first3_padto3", "entry_point": "op_square_first3_padto3", "primitives": ["square", "first3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_square_first3_padto3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_square_first3_padto3([1, 2, 3, 4]) == [1, 4, 9]\nassert op_square_first3_padto3([]) == [0, 0, 0]\nassert op_square_first3_padto3([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_first3_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_square_first3_padto3([3, 1, 2]) == [9, 1, 4]\nassert op_square_first3_padto3([10]) == [100, 0, 0]\nassert op_square_first3_padto3([2, 4, 6]) == [4, 16, 36]\nassert op_square_first3_padto3([-7, 12, -7]) == [49, 144, 49]"}
{"id": "op_neg_sortabs_oremptyzero", "entry_point": "op_neg_sortabs_oremptyzero", "primitives": ["neg", "sortabs", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_neg_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_neg_sortabs_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_neg_sortabs_oremptyzero([]) == [0]\nassert op_neg_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_neg_sortabs_oremptyzero([5, 5, 5]) == [0]\nassert op_neg_sortabs_oremptyzero([3, 1, 2]) == [0]\nassert op_neg_sortabs_oremptyzero([10]) == [0]\nassert op_neg_sortabs_oremptyzero([2, 4, 6]) == [0]\nassert op_neg_sortabs_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_last3_dropfirst_anyeven", "entry_point": "op_last3_dropfirst_anyeven", "primitives": ["last3", "dropfirst", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then return whether any value is even.", "solution": "def op_last3_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_last3_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_last3_dropfirst_anyeven([]) == False\nassert op_last3_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_last3_dropfirst_anyeven([5, 5, 5]) == False\nassert op_last3_dropfirst_anyeven([3, 1, 2]) == True\nassert op_last3_dropfirst_anyeven([10]) == False\nassert op_last3_dropfirst_anyeven([2, 4, 6]) == True\nassert op_last3_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_beforezero_dropwhileneg_sum", "entry_point": "op_beforezero_dropwhileneg_sum", "primitives": ["beforezero", "dropwhileneg", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop the leading negative values, then return their sum.", "solution": "def op_beforezero_dropwhileneg_sum(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(r)", "tests": "assert op_beforezero_dropwhileneg_sum([1, 2, 3, 4]) == 10\nassert op_beforezero_dropwhileneg_sum([]) == 0\nassert op_beforezero_dropwhileneg_sum([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_dropwhileneg_sum([5, 5, 5]) == 15\nassert op_beforezero_dropwhileneg_sum([3, 1, 2]) == 6\nassert op_beforezero_dropwhileneg_sum([10]) == 10\nassert op_beforezero_dropwhileneg_sum([2, 4, 6]) == 12\nassert op_beforezero_dropwhileneg_sum([-7, 12, -7]) == 5"}
{"id": "op_oremptyzero_odds_inc", "entry_point": "op_oremptyzero_odds_inc", "primitives": ["oremptyzero", "odds", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the odd numbers, then add one to each.", "solution": "def op_oremptyzero_odds_inc(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_odds_inc([1, 2, 3, 4]) == [2, 4]\nassert op_oremptyzero_odds_inc([]) == []\nassert op_oremptyzero_odds_inc([-2, -1, 0, 1, 2]) == [0, 2]\nassert op_oremptyzero_odds_inc([5, 5, 5]) == [6, 6, 6]\nassert op_oremptyzero_odds_inc([3, 1, 2]) == [4, 2]\nassert op_oremptyzero_odds_inc([10]) == []\nassert op_oremptyzero_odds_inc([2, 4, 6]) == []\nassert op_oremptyzero_odds_inc([-7, 12, -7]) == [-6, -6]"}
{"id": "op_odds_div3_clamp10", "entry_point": "op_odds_div3_clamp10", "primitives": ["odds", "div3", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep multiples of three, then cap each value at 10.", "solution": "def op_odds_div3_clamp10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_odds_div3_clamp10([1, 2, 3, 4]) == [3]\nassert op_odds_div3_clamp10([]) == []\nassert op_odds_div3_clamp10([-2, -1, 0, 1, 2]) == []\nassert op_odds_div3_clamp10([5, 5, 5]) == []\nassert op_odds_div3_clamp10([3, 1, 2]) == [3]\nassert op_odds_div3_clamp10([10]) == []\nassert op_odds_div3_clamp10([2, 4, 6]) == []\nassert op_odds_div3_clamp10([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_last3_first3", "entry_point": "op_takewhilepos_last3_first3", "primitives": ["takewhilepos", "last3", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then keep only the first three.", "solution": "def op_takewhilepos_last3_first3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_takewhilepos_last3_first3([1, 2, 3, 4]) == [2, 3, 4]\nassert op_takewhilepos_last3_first3([]) == []\nassert op_takewhilepos_last3_first3([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_first3([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_last3_first3([3, 1, 2]) == [3, 1, 2]\nassert op_takewhilepos_last3_first3([10]) == [10]\nassert op_takewhilepos_last3_first3([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_last3_first3([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_negate_square", "entry_point": "op_takewhilepos_negate_square", "primitives": ["takewhilepos", "negate", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then square each.", "solution": "def op_takewhilepos_negate_square(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_takewhilepos_negate_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_negate_square([]) == []\nassert op_takewhilepos_negate_square([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_square([5, 5, 5]) == [25, 25, 25]\nassert op_takewhilepos_negate_square([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_negate_square([10]) == [100]\nassert op_takewhilepos_negate_square([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_negate_square([-7, 12, -7]) == []"}
{"id": "op_double_gt5_negate", "entry_point": "op_double_gt5_negate", "primitives": ["double", "gt5", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then negate each.", "solution": "def op_double_gt5_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_gt5_negate([1, 2, 3, 4]) == [-6, -8]\nassert op_double_gt5_negate([]) == []\nassert op_double_gt5_negate([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_negate([5, 5, 5]) == [-10, -10, -10]\nassert op_double_gt5_negate([3, 1, 2]) == [-6]\nassert op_double_gt5_negate([10]) == [-20]\nassert op_double_gt5_negate([2, 4, 6]) == [-8, -12]\nassert op_double_gt5_negate([-7, 12, -7]) == [-24]"}
{"id": "op_evens_double_min", "entry_point": "op_evens_double_min", "primitives": ["evens", "double", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then double each, then return the minimum (0 if empty).", "solution": "def op_evens_double_min(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x * 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_evens_double_min([1, 2, 3, 4]) == 4\nassert op_evens_double_min([]) == 0\nassert op_evens_double_min([-2, -1, 0, 1, 2]) == -4\nassert op_evens_double_min([5, 5, 5]) == 0\nassert op_evens_double_min([3, 1, 2]) == 4\nassert op_evens_double_min([10]) == 20\nassert op_evens_double_min([2, 4, 6]) == 4\nassert op_evens_double_min([-7, 12, -7]) == 24"}
{"id": "op_dec_evens_oremptyzero", "entry_point": "op_dec_evens_oremptyzero", "primitives": ["dec", "evens", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then if empty, use a single zero.", "solution": "def op_dec_evens_oremptyzero(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_dec_evens_oremptyzero([1, 2, 3, 4]) == [0, 2]\nassert op_dec_evens_oremptyzero([]) == [0]\nassert op_dec_evens_oremptyzero([-2, -1, 0, 1, 2]) == [-2, 0]\nassert op_dec_evens_oremptyzero([5, 5, 5]) == [4, 4, 4]\nassert op_dec_evens_oremptyzero([3, 1, 2]) == [2, 0]\nassert op_dec_evens_oremptyzero([10]) == [0]\nassert op_dec_evens_oremptyzero([2, 4, 6]) == [0]\nassert op_dec_evens_oremptyzero([-7, 12, -7]) == [-8, -8]"}
{"id": "op_absval_square_sortd", "entry_point": "op_absval_square_sortd", "primitives": ["absval", "square", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then square each, then sort descending.", "solution": "def op_absval_square_sortd(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_absval_square_sortd([1, 2, 3, 4]) == [16, 9, 4, 1]\nassert op_absval_square_sortd([]) == []\nassert op_absval_square_sortd([-2, -1, 0, 1, 2]) == [4, 4, 1, 1, 0]\nassert op_absval_square_sortd([5, 5, 5]) == [25, 25, 25]\nassert op_absval_square_sortd([3, 1, 2]) == [9, 4, 1]\nassert op_absval_square_sortd([10]) == [100]\nassert op_absval_square_sortd([2, 4, 6]) == [36, 16, 4]\nassert op_absval_square_sortd([-7, 12, -7]) == [144, 49, 49]"}
{"id": "op_double_uniq_div3", "entry_point": "op_double_uniq_div3", "primitives": ["double", "uniq", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then keep multiples of three.", "solution": "def op_double_uniq_div3(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_double_uniq_div3([1, 2, 3, 4]) == [6]\nassert op_double_uniq_div3([]) == []\nassert op_double_uniq_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_double_uniq_div3([5, 5, 5]) == []\nassert op_double_uniq_div3([3, 1, 2]) == [6]\nassert op_double_uniq_div3([10]) == []\nassert op_double_uniq_div3([2, 4, 6]) == [12]\nassert op_double_uniq_div3([-7, 12, -7]) == [24]"}
{"id": "op_rev_oremptyzero_absval", "entry_point": "op_rev_oremptyzero_absval", "primitives": ["rev", "oremptyzero", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then if empty, use a single zero, then take the absolute value of each.", "solution": "def op_rev_oremptyzero_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_oremptyzero_absval([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_oremptyzero_absval([]) == [0]\nassert op_rev_oremptyzero_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_rev_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_oremptyzero_absval([3, 1, 2]) == [2, 1, 3]\nassert op_rev_oremptyzero_absval([10]) == [10]\nassert op_rev_oremptyzero_absval([2, 4, 6]) == [6, 4, 2]\nassert op_rev_oremptyzero_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_sorta_square_padto3", "entry_point": "op_sorta_square_padto3", "primitives": ["sorta", "square", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then square each, then pad with zeros to at least three elements.", "solution": "def op_sorta_square_padto3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sorta_square_padto3([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sorta_square_padto3([]) == [0, 0, 0]\nassert op_sorta_square_padto3([-2, -1, 0, 1, 2]) == [4, 1, 0, 1, 4]\nassert op_sorta_square_padto3([5, 5, 5]) == [25, 25, 25]\nassert op_sorta_square_padto3([3, 1, 2]) == [1, 4, 9]\nassert op_sorta_square_padto3([10]) == [100, 0, 0]\nassert op_sorta_square_padto3([2, 4, 6]) == [4, 16, 36]\nassert op_sorta_square_padto3([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_dropfirst_dec_inc", "entry_point": "op_dropfirst_dec_inc", "primitives": ["dropfirst", "dec", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then subtract one from each, then add one to each.", "solution": "def op_dropfirst_dec_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_dec_inc([1, 2, 3, 4]) == [2, 3, 4]\nassert op_dropfirst_dec_inc([]) == []\nassert op_dropfirst_dec_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_dropfirst_dec_inc([5, 5, 5]) == [5, 5]\nassert op_dropfirst_dec_inc([3, 1, 2]) == [1, 2]\nassert op_dropfirst_dec_inc([10]) == []\nassert op_dropfirst_dec_inc([2, 4, 6]) == [4, 6]\nassert op_dropfirst_dec_inc([-7, 12, -7]) == [12, -7]"}
{"id": "op_square_clamp10_gt5", "entry_point": "op_square_clamp10_gt5", "primitives": ["square", "clamp10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then cap each value at 10, then keep values greater than five.", "solution": "def op_square_clamp10_gt5(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_square_clamp10_gt5([1, 2, 3, 4]) == [9, 10]\nassert op_square_clamp10_gt5([]) == []\nassert op_square_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_square_clamp10_gt5([5, 5, 5]) == [10, 10, 10]\nassert op_square_clamp10_gt5([3, 1, 2]) == [9]\nassert op_square_clamp10_gt5([10]) == [10]\nassert op_square_clamp10_gt5([2, 4, 6]) == [10, 10]\nassert op_square_clamp10_gt5([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_negate_double_counteven", "entry_point": "op_negate_double_counteven", "primitives": ["negate", "double", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then return how many values are even.", "solution": "def op_negate_double_counteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_negate_double_counteven([1, 2, 3, 4]) == 4\nassert op_negate_double_counteven([]) == 0\nassert op_negate_double_counteven([-2, -1, 0, 1, 2]) == 5\nassert op_negate_double_counteven([5, 5, 5]) == 3\nassert op_negate_double_counteven([3, 1, 2]) == 3\nassert op_negate_double_counteven([10]) == 1\nassert op_negate_double_counteven([2, 4, 6]) == 3\nassert op_negate_double_counteven([-7, 12, -7]) == 3"}
{"id": "op_square_dec_padto3", "entry_point": "op_square_dec_padto3", "primitives": ["square", "dec", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then subtract one from each, then pad with zeros to at least three elements.", "solution": "def op_square_dec_padto3(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x - 1 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_square_dec_padto3([1, 2, 3, 4]) == [0, 3, 8, 15]\nassert op_square_dec_padto3([]) == [0, 0, 0]\nassert op_square_dec_padto3([-2, -1, 0, 1, 2]) == [3, 0, -1, 0, 3]\nassert op_square_dec_padto3([5, 5, 5]) == [24, 24, 24]\nassert op_square_dec_padto3([3, 1, 2]) == [8, 0, 3]\nassert op_square_dec_padto3([10]) == [99, 0, 0]\nassert op_square_dec_padto3([2, 4, 6]) == [3, 15, 35]\nassert op_square_dec_padto3([-7, 12, -7]) == [48, 143, 48]"}
{"id": "op_clamp10_uniq_dropwhileneg", "entry_point": "op_clamp10_uniq_dropwhileneg", "primitives": ["clamp10", "uniq", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_clamp10_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_clamp10_uniq_dropwhileneg([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_uniq_dropwhileneg([]) == []\nassert op_clamp10_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_uniq_dropwhileneg([5, 5, 5]) == [5]\nassert op_clamp10_uniq_dropwhileneg([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_uniq_dropwhileneg([10]) == [10]\nassert op_clamp10_uniq_dropwhileneg([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_uniq_dropwhileneg([-7, 12, -7]) == [10]"}
{"id": "op_pos_add10_oremptyzero", "entry_point": "op_pos_add10_oremptyzero", "primitives": ["pos", "add10", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add ten to each, then if empty, use a single zero.", "solution": "def op_pos_add10_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_pos_add10_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_pos_add10_oremptyzero([]) == [0]\nassert op_pos_add10_oremptyzero([-2, -1, 0, 1, 2]) == [11, 12]\nassert op_pos_add10_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_pos_add10_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_pos_add10_oremptyzero([10]) == [20]\nassert op_pos_add10_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_pos_add10_oremptyzero([-7, 12, -7]) == [22]"}
{"id": "op_takewhilepos_last3_odds", "entry_point": "op_takewhilepos_last3_odds", "primitives": ["takewhilepos", "last3", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the last three, then keep the odd numbers.", "solution": "def op_takewhilepos_last3_odds(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[-3:]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_takewhilepos_last3_odds([1, 2, 3, 4]) == [3]\nassert op_takewhilepos_last3_odds([]) == []\nassert op_takewhilepos_last3_odds([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_last3_odds([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_last3_odds([3, 1, 2]) == [3, 1]\nassert op_takewhilepos_last3_odds([10]) == []\nassert op_takewhilepos_last3_odds([2, 4, 6]) == []\nassert op_takewhilepos_last3_odds([-7, 12, -7]) == []"}
{"id": "op_padto3_dropwhileneg_neg", "entry_point": "op_padto3_dropwhileneg_neg", "primitives": ["padto3", "dropwhileneg", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the leading negative values, then keep the negative numbers.", "solution": "def op_padto3_dropwhileneg_neg(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_padto3_dropwhileneg_neg([1, 2, 3, 4]) == []\nassert op_padto3_dropwhileneg_neg([]) == []\nassert op_padto3_dropwhileneg_neg([-2, -1, 0, 1, 2]) == []\nassert op_padto3_dropwhileneg_neg([5, 5, 5]) == []\nassert op_padto3_dropwhileneg_neg([3, 1, 2]) == []\nassert op_padto3_dropwhileneg_neg([10]) == []\nassert op_padto3_dropwhileneg_neg([2, 4, 6]) == []\nassert op_padto3_dropwhileneg_neg([-7, 12, -7]) == [-7]"}
{"id": "op_div3_rev_absval", "entry_point": "op_div3_rev_absval", "primitives": ["div3", "rev", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then take the absolute value of each.", "solution": "def op_div3_rev_absval(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_div3_rev_absval([1, 2, 3, 4]) == [3]\nassert op_div3_rev_absval([]) == []\nassert op_div3_rev_absval([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_rev_absval([5, 5, 5]) == []\nassert op_div3_rev_absval([3, 1, 2]) == [3]\nassert op_div3_rev_absval([10]) == []\nassert op_div3_rev_absval([2, 4, 6]) == [6]\nassert op_div3_rev_absval([-7, 12, -7]) == [12]"}
{"id": "op_first3_uniq_oremptyzero", "entry_point": "op_first3_uniq_oremptyzero", "primitives": ["first3", "uniq", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then drop duplicates keeping first occurrence, then if empty, use a single zero.", "solution": "def op_first3_uniq_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_uniq_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_first3_uniq_oremptyzero([]) == [0]\nassert op_first3_uniq_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_first3_uniq_oremptyzero([5, 5, 5]) == [5]\nassert op_first3_uniq_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_first3_uniq_oremptyzero([10]) == [10]\nassert op_first3_uniq_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_first3_uniq_oremptyzero([-7, 12, -7]) == [-7, 12]"}
{"id": "op_trimends_div3_max", "entry_point": "op_trimends_div3_max", "primitives": ["trimends", "div3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep multiples of three, then return the maximum (0 if empty).", "solution": "def op_trimends_div3_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return max(r) if r else 0", "tests": "assert op_trimends_div3_max([1, 2, 3, 4]) == 3\nassert op_trimends_div3_max([]) == 0\nassert op_trimends_div3_max([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_div3_max([5, 5, 5]) == 0\nassert op_trimends_div3_max([3, 1, 2]) == 0\nassert op_trimends_div3_max([10]) == 0\nassert op_trimends_div3_max([2, 4, 6]) == 0\nassert op_trimends_div3_max([-7, 12, -7]) == 12"}
{"id": "op_negate_dropfirst_inc", "entry_point": "op_negate_dropfirst_inc", "primitives": ["negate", "dropfirst", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the first element, then add one to each.", "solution": "def op_negate_dropfirst_inc(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[1:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_negate_dropfirst_inc([1, 2, 3, 4]) == [-1, -2, -3]\nassert op_negate_dropfirst_inc([]) == []\nassert op_negate_dropfirst_inc([-2, -1, 0, 1, 2]) == [2, 1, 0, -1]\nassert op_negate_dropfirst_inc([5, 5, 5]) == [-4, -4]\nassert op_negate_dropfirst_inc([3, 1, 2]) == [0, -1]\nassert op_negate_dropfirst_inc([10]) == []\nassert op_negate_dropfirst_inc([2, 4, 6]) == [-3, -5]\nassert op_negate_dropfirst_inc([-7, 12, -7]) == [-11, 8]"}
{"id": "op_dropwhileneg_div3_max", "entry_point": "op_dropwhileneg_div3_max", "primitives": ["dropwhileneg", "div3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then return the maximum (0 if empty).", "solution": "def op_dropwhileneg_div3_max(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return max(r) if r else 0", "tests": "assert op_dropwhileneg_div3_max([1, 2, 3, 4]) == 3\nassert op_dropwhileneg_div3_max([]) == 0\nassert op_dropwhileneg_div3_max([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_div3_max([5, 5, 5]) == 0\nassert op_dropwhileneg_div3_max([3, 1, 2]) == 3\nassert op_dropwhileneg_div3_max([10]) == 0\nassert op_dropwhileneg_div3_max([2, 4, 6]) == 6\nassert op_dropwhileneg_div3_max([-7, 12, -7]) == 12"}
{"id": "op_trimends_padto3_neg", "entry_point": "op_trimends_padto3_neg", "primitives": ["trimends", "padto3", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then keep the negative numbers.", "solution": "def op_trimends_padto3_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_padto3_neg([1, 2, 3, 4]) == []\nassert op_trimends_padto3_neg([]) == []\nassert op_trimends_padto3_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_padto3_neg([5, 5, 5]) == []\nassert op_trimends_padto3_neg([3, 1, 2]) == []\nassert op_trimends_padto3_neg([10]) == []\nassert op_trimends_padto3_neg([2, 4, 6]) == []\nassert op_trimends_padto3_neg([-7, 12, -7]) == []"}
{"id": "op_last3_sorta_uniq", "entry_point": "op_last3_sorta_uniq", "primitives": ["last3", "sorta", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort ascending, then drop duplicates keeping first occurrence.", "solution": "def op_last3_sorta_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_sorta_uniq([1, 2, 3, 4]) == [2, 3, 4]\nassert op_last3_sorta_uniq([]) == []\nassert op_last3_sorta_uniq([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_last3_sorta_uniq([5, 5, 5]) == [5]\nassert op_last3_sorta_uniq([3, 1, 2]) == [1, 2, 3]\nassert op_last3_sorta_uniq([10]) == [10]\nassert op_last3_sorta_uniq([2, 4, 6]) == [2, 4, 6]\nassert op_last3_sorta_uniq([-7, 12, -7]) == [-7, 12]"}
{"id": "op_odds_dropwhileneg_negate", "entry_point": "op_odds_dropwhileneg_negate", "primitives": ["odds", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the leading negative values, then negate each.", "solution": "def op_odds_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_odds_dropwhileneg_negate([1, 2, 3, 4]) == [-1, -3]\nassert op_odds_dropwhileneg_negate([]) == []\nassert op_odds_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_dropwhileneg_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_odds_dropwhileneg_negate([3, 1, 2]) == [-3, -1]\nassert op_odds_dropwhileneg_negate([10]) == []\nassert op_odds_dropwhileneg_negate([2, 4, 6]) == []\nassert op_odds_dropwhileneg_negate([-7, 12, -7]) == []"}
{"id": "op_sortabs_absval_sorta", "entry_point": "op_sortabs_absval_sorta", "primitives": ["sortabs", "absval", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then sort ascending.", "solution": "def op_sortabs_absval_sorta(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_sortabs_absval_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_absval_sorta([]) == []\nassert op_sortabs_absval_sorta([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_sortabs_absval_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_absval_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_absval_sorta([10]) == [10]\nassert op_sortabs_absval_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_absval_sorta([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_clamp10_dropwhileneg_sortabs", "entry_point": "op_clamp10_dropwhileneg_sortabs", "primitives": ["clamp10", "dropwhileneg", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the leading negative values, then sort by absolute value.", "solution": "def op_clamp10_dropwhileneg_sortabs(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_clamp10_dropwhileneg_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_dropwhileneg_sortabs([]) == []\nassert op_clamp10_dropwhileneg_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_clamp10_dropwhileneg_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_dropwhileneg_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_dropwhileneg_sortabs([10]) == [10]\nassert op_clamp10_dropwhileneg_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_dropwhileneg_sortabs([-7, 12, -7]) == [-7, 10]"}
{"id": "op_add10_takewhilepos_sorta", "entry_point": "op_add10_takewhilepos_sorta", "primitives": ["add10", "takewhilepos", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then take values while they are positive, then sort ascending.", "solution": "def op_add10_takewhilepos_sorta(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r)\n    return r", "tests": "assert op_add10_takewhilepos_sorta([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_takewhilepos_sorta([]) == []\nassert op_add10_takewhilepos_sorta([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_takewhilepos_sorta([5, 5, 5]) == [15, 15, 15]\nassert op_add10_takewhilepos_sorta([3, 1, 2]) == [11, 12, 13]\nassert op_add10_takewhilepos_sorta([10]) == [20]\nassert op_add10_takewhilepos_sorta([2, 4, 6]) == [12, 14, 16]\nassert op_add10_takewhilepos_sorta([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_sortabs_clamp10_negate", "entry_point": "op_sortabs_clamp10_negate", "primitives": ["sortabs", "clamp10", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cap each value at 10, then negate each.", "solution": "def op_sortabs_clamp10_negate(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_sortabs_clamp10_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_sortabs_clamp10_negate([]) == []\nassert op_sortabs_clamp10_negate([-2, -1, 0, 1, 2]) == [0, 1, -1, 2, -2]\nassert op_sortabs_clamp10_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_sortabs_clamp10_negate([3, 1, 2]) == [-1, -2, -3]\nassert op_sortabs_clamp10_negate([10]) == [-10]\nassert op_sortabs_clamp10_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_sortabs_clamp10_negate([-7, 12, -7]) == [7, 7, -10]"}
{"id": "op_last3_sortd_uniq", "entry_point": "op_last3_sortd_uniq", "primitives": ["last3", "sortd", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then drop duplicates keeping first occurrence.", "solution": "def op_last3_sortd_uniq(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_last3_sortd_uniq([1, 2, 3, 4]) == [4, 3, 2]\nassert op_last3_sortd_uniq([]) == []\nassert op_last3_sortd_uniq([-2, -1, 0, 1, 2]) == [2, 1, 0]\nassert op_last3_sortd_uniq([5, 5, 5]) == [5]\nassert op_last3_sortd_uniq([3, 1, 2]) == [3, 2, 1]\nassert op_last3_sortd_uniq([10]) == [10]\nassert op_last3_sortd_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_last3_sortd_uniq([-7, 12, -7]) == [12, -7]"}
{"id": "op_negate_takewhilepos_haszero", "entry_point": "op_negate_takewhilepos_haszero", "primitives": ["negate", "takewhilepos", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then take values while they are positive, then return whether the list contains a zero.", "solution": "def op_negate_takewhilepos_haszero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return 0 in r", "tests": "assert op_negate_takewhilepos_haszero([1, 2, 3, 4]) == False\nassert op_negate_takewhilepos_haszero([]) == False\nassert op_negate_takewhilepos_haszero([-2, -1, 0, 1, 2]) == False\nassert op_negate_takewhilepos_haszero([5, 5, 5]) == False\nassert op_negate_takewhilepos_haszero([3, 1, 2]) == False\nassert op_negate_takewhilepos_haszero([10]) == False\nassert op_negate_takewhilepos_haszero([2, 4, 6]) == False\nassert op_negate_takewhilepos_haszero([-7, 12, -7]) == False"}
{"id": "op_dropfirst_sorta_anyeven", "entry_point": "op_dropfirst_sorta_anyeven", "primitives": ["dropfirst", "sorta", "anyeven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then sort ascending, then return whether any value is even.", "solution": "def op_dropfirst_sorta_anyeven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = sorted(r)\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropfirst_sorta_anyeven([1, 2, 3, 4]) == True\nassert op_dropfirst_sorta_anyeven([]) == False\nassert op_dropfirst_sorta_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropfirst_sorta_anyeven([5, 5, 5]) == False\nassert op_dropfirst_sorta_anyeven([3, 1, 2]) == True\nassert op_dropfirst_sorta_anyeven([10]) == False\nassert op_dropfirst_sorta_anyeven([2, 4, 6]) == True\nassert op_dropfirst_sorta_anyeven([-7, 12, -7]) == True"}
{"id": "op_inc_trimends_sortabs", "entry_point": "op_inc_trimends_sortabs", "primitives": ["inc", "trimends", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then sort by absolute value.", "solution": "def op_inc_trimends_sortabs(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_inc_trimends_sortabs([1, 2, 3, 4]) == [3, 4]\nassert op_inc_trimends_sortabs([]) == []\nassert op_inc_trimends_sortabs([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_inc_trimends_sortabs([5, 5, 5]) == [6]\nassert op_inc_trimends_sortabs([3, 1, 2]) == [2]\nassert op_inc_trimends_sortabs([10]) == []\nassert op_inc_trimends_sortabs([2, 4, 6]) == [5]\nassert op_inc_trimends_sortabs([-7, 12, -7]) == [13]"}
{"id": "op_absval_evens_issorted", "entry_point": "op_absval_evens_issorted", "primitives": ["absval", "evens", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then return whether the list is sorted ascending.", "solution": "def op_absval_evens_issorted(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r == sorted(r)", "tests": "assert op_absval_evens_issorted([1, 2, 3, 4]) == True\nassert op_absval_evens_issorted([]) == True\nassert op_absval_evens_issorted([-2, -1, 0, 1, 2]) == False\nassert op_absval_evens_issorted([5, 5, 5]) == True\nassert op_absval_evens_issorted([3, 1, 2]) == True\nassert op_absval_evens_issorted([10]) == True\nassert op_absval_evens_issorted([2, 4, 6]) == True\nassert op_absval_evens_issorted([-7, 12, -7]) == True"}
{"id": "op_padto3_gt5_counteven", "entry_point": "op_padto3_gt5_counteven", "primitives": ["padto3", "gt5", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep values greater than five, then return how many values are even.", "solution": "def op_padto3_gt5_counteven(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 5]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_padto3_gt5_counteven([1, 2, 3, 4]) == 0\nassert op_padto3_gt5_counteven([]) == 0\nassert op_padto3_gt5_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_padto3_gt5_counteven([5, 5, 5]) == 0\nassert op_padto3_gt5_counteven([3, 1, 2]) == 0\nassert op_padto3_gt5_counteven([10]) == 1\nassert op_padto3_gt5_counteven([2, 4, 6]) == 1\nassert op_padto3_gt5_counteven([-7, 12, -7]) == 1"}
{"id": "op_neg_absval_rev", "entry_point": "op_neg_absval_rev", "primitives": ["neg", "absval", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then take the absolute value of each, then reverse the order.", "solution": "def op_neg_absval_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_neg_absval_rev([1, 2, 3, 4]) == []\nassert op_neg_absval_rev([]) == []\nassert op_neg_absval_rev([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_neg_absval_rev([5, 5, 5]) == []\nassert op_neg_absval_rev([3, 1, 2]) == []\nassert op_neg_absval_rev([10]) == []\nassert op_neg_absval_rev([2, 4, 6]) == []\nassert op_neg_absval_rev([-7, 12, -7]) == [7, 7]"}
{"id": "op_negate_double_prod", "entry_point": "op_negate_double_prod", "primitives": ["negate", "double", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then double each, then return their product.", "solution": "def op_negate_double_prod(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_negate_double_prod([1, 2, 3, 4]) == 384\nassert op_negate_double_prod([]) == 1\nassert op_negate_double_prod([-2, -1, 0, 1, 2]) == 0\nassert op_negate_double_prod([5, 5, 5]) == -1000\nassert op_negate_double_prod([3, 1, 2]) == -48\nassert op_negate_double_prod([10]) == -20\nassert op_negate_double_prod([2, 4, 6]) == -384\nassert op_negate_double_prod([-7, 12, -7]) == -4704"}
{"id": "op_first3_padto3_min", "entry_point": "op_first3_padto3_min", "primitives": ["first3", "padto3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then return the minimum (0 if empty).", "solution": "def op_first3_padto3_min(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return min(r) if r else 0", "tests": "assert op_first3_padto3_min([1, 2, 3, 4]) == 1\nassert op_first3_padto3_min([]) == 0\nassert op_first3_padto3_min([-2, -1, 0, 1, 2]) == -2\nassert op_first3_padto3_min([5, 5, 5]) == 5\nassert op_first3_padto3_min([3, 1, 2]) == 1\nassert op_first3_padto3_min([10]) == 0\nassert op_first3_padto3_min([2, 4, 6]) == 2\nassert op_first3_padto3_min([-7, 12, -7]) == -7"}
{"id": "op_dropwhileneg_neg_prod", "entry_point": "op_dropwhileneg_neg_prod", "primitives": ["dropwhileneg", "neg", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep the negative numbers, then return their product.", "solution": "def op_dropwhileneg_neg_prod(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x < 0]\n    return __import__('math').prod(r)", "tests": "assert op_dropwhileneg_neg_prod([1, 2, 3, 4]) == 1\nassert op_dropwhileneg_neg_prod([]) == 1\nassert op_dropwhileneg_neg_prod([-2, -1, 0, 1, 2]) == 1\nassert op_dropwhileneg_neg_prod([5, 5, 5]) == 1\nassert op_dropwhileneg_neg_prod([3, 1, 2]) == 1\nassert op_dropwhileneg_neg_prod([10]) == 1\nassert op_dropwhileneg_neg_prod([2, 4, 6]) == 1\nassert op_dropwhileneg_neg_prod([-7, 12, -7]) == -7"}
{"id": "op_sorta_inc_sortabs", "entry_point": "op_sorta_inc_sortabs", "primitives": ["sorta", "inc", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then sort by absolute value.", "solution": "def op_sorta_inc_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_inc_sortabs([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_inc_sortabs([]) == []\nassert op_sorta_inc_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, 2, 3]\nassert op_sorta_inc_sortabs([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_sortabs([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_inc_sortabs([10]) == [11]\nassert op_sorta_inc_sortabs([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_inc_sortabs([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_odds_square_len", "entry_point": "op_odds_square_len", "primitives": ["odds", "square", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then return how many remain.", "solution": "def op_odds_square_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return len(r)", "tests": "assert op_odds_square_len([1, 2, 3, 4]) == 2\nassert op_odds_square_len([]) == 0\nassert op_odds_square_len([-2, -1, 0, 1, 2]) == 2\nassert op_odds_square_len([5, 5, 5]) == 3\nassert op_odds_square_len([3, 1, 2]) == 2\nassert op_odds_square_len([10]) == 0\nassert op_odds_square_len([2, 4, 6]) == 0\nassert op_odds_square_len([-7, 12, -7]) == 2"}
{"id": "op_ages_padto3_sortd", "entry_point": "op_ages_padto3_sortd", "primitives": ["ages", "padto3", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then pad with zeros to at least three elements, then sort descending.", "solution": "def op_ages_padto3_sortd(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_ages_padto3_sortd([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12, 0]\nassert op_ages_padto3_sortd([]) == [0, 0, 0]\nassert op_ages_padto3_sortd([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [65, 18, 17]\nassert op_ages_padto3_sortd([{'name': 'Fi', 'age': 41}]) == [41, 0, 0]"}
{"id": "op_takewhilepos_sortabs_dropzeros", "entry_point": "op_takewhilepos_sortabs_dropzeros", "primitives": ["takewhilepos", "sortabs", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then sort by absolute value, then drop the zeros.", "solution": "def op_takewhilepos_sortabs_dropzeros(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = sorted(r, key=abs)\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_takewhilepos_sortabs_dropzeros([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_takewhilepos_sortabs_dropzeros([]) == []\nassert op_takewhilepos_sortabs_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_sortabs_dropzeros([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_sortabs_dropzeros([3, 1, 2]) == [1, 2, 3]\nassert op_takewhilepos_sortabs_dropzeros([10]) == [10]\nassert op_takewhilepos_sortabs_dropzeros([2, 4, 6]) == [2, 4, 6]\nassert op_takewhilepos_sortabs_dropzeros([-7, 12, -7]) == []"}
{"id": "op_sortd_pos_double", "entry_point": "op_sortd_pos_double", "primitives": ["sortd", "pos", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then double each.", "solution": "def op_sortd_pos_double(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortd_pos_double([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_sortd_pos_double([]) == []\nassert op_sortd_pos_double([-2, -1, 0, 1, 2]) == [4, 2]\nassert op_sortd_pos_double([5, 5, 5]) == [10, 10, 10]\nassert op_sortd_pos_double([3, 1, 2]) == [6, 4, 2]\nassert op_sortd_pos_double([10]) == [20]\nassert op_sortd_pos_double([2, 4, 6]) == [12, 8, 4]\nassert op_sortd_pos_double([-7, 12, -7]) == [24]"}
{"id": "op_nonempty_lower_lens", "entry_point": "op_nonempty_lower_lens", "primitives": ["nonempty", "lower", "lens"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then lowercase each string, then return the total number of characters.", "solution": "def op_nonempty_lower_lens(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.lower() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_nonempty_lower_lens(['Hello', 'world']) == 10\nassert op_nonempty_lower_lens([]) == 0\nassert op_nonempty_lower_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_nonempty_lower_lens(['one', 'one', 'Two']) == 9\nassert op_nonempty_lower_lens(['x']) == 1\nassert op_nonempty_lower_lens(['abc', 'de', '']) == 5"}
{"id": "op_absval_dropfirst_counteven", "entry_point": "op_absval_dropfirst_counteven", "primitives": ["absval", "dropfirst", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the first element, then return how many values are even.", "solution": "def op_absval_dropfirst_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_dropfirst_counteven([1, 2, 3, 4]) == 2\nassert op_absval_dropfirst_counteven([]) == 0\nassert op_absval_dropfirst_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_absval_dropfirst_counteven([5, 5, 5]) == 0\nassert op_absval_dropfirst_counteven([3, 1, 2]) == 1\nassert op_absval_dropfirst_counteven([10]) == 0\nassert op_absval_dropfirst_counteven([2, 4, 6]) == 2\nassert op_absval_dropfirst_counteven([-7, 12, -7]) == 1"}
{"id": "op_trimends_negate_dropwhileneg", "entry_point": "op_trimends_negate_dropwhileneg", "primitives": ["trimends", "negate", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then negate each, then drop the leading negative values.", "solution": "def op_trimends_negate_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [-x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_trimends_negate_dropwhileneg([1, 2, 3, 4]) == []\nassert op_trimends_negate_dropwhileneg([]) == []\nassert op_trimends_negate_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_trimends_negate_dropwhileneg([5, 5, 5]) == []\nassert op_trimends_negate_dropwhileneg([3, 1, 2]) == []\nassert op_trimends_negate_dropwhileneg([10]) == []\nassert op_trimends_negate_dropwhileneg([2, 4, 6]) == []\nassert op_trimends_negate_dropwhileneg([-7, 12, -7]) == []"}
{"id": "op_strip_firstchar_sortalpha", "entry_point": "op_strip_firstchar_sortalpha", "primitives": ["strip", "firstchar", "sortalpha"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then keep the first character of each (dropping empties), then sort alphabetically.", "solution": "def op_strip_firstchar_sortalpha(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s[0] for s in r if s]\n    r = sorted(r)\n    return r", "tests": "assert op_strip_firstchar_sortalpha(['Hello', 'world']) == ['H', 'w']\nassert op_strip_firstchar_sortalpha([]) == []\nassert op_strip_firstchar_sortalpha(['  a ', '', 'BC', 'bc']) == ['B', 'a', 'b']\nassert op_strip_firstchar_sortalpha(['one', 'one', 'Two']) == ['T', 'o', 'o']\nassert op_strip_firstchar_sortalpha(['x']) == ['x']\nassert op_strip_firstchar_sortalpha(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_dec_inc_sortabs", "entry_point": "op_dec_inc_sortabs", "primitives": ["dec", "inc", "sortabs"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then add one to each, then sort by absolute value.", "solution": "def op_dec_inc_sortabs(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x + 1 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_dec_inc_sortabs([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_dec_inc_sortabs([]) == []\nassert op_dec_inc_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, 2]\nassert op_dec_inc_sortabs([5, 5, 5]) == [5, 5, 5]\nassert op_dec_inc_sortabs([3, 1, 2]) == [1, 2, 3]\nassert op_dec_inc_sortabs([10]) == [10]\nassert op_dec_inc_sortabs([2, 4, 6]) == [2, 4, 6]\nassert op_dec_inc_sortabs([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_upper_sortlen_strip", "entry_point": "op_upper_sortlen_strip", "primitives": ["upper", "sortlen", "strip"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then sort by length, shortest first, then trim whitespace from each.", "solution": "def op_upper_sortlen_strip(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_upper_sortlen_strip(['Hello', 'world']) == ['HELLO', 'WORLD']\nassert op_upper_sortlen_strip([]) == []\nassert op_upper_sortlen_strip(['  a ', '', 'BC', 'bc']) == ['', 'BC', 'BC', 'A']\nassert op_upper_sortlen_strip(['one', 'one', 'Two']) == ['ONE', 'ONE', 'TWO']\nassert op_upper_sortlen_strip(['x']) == ['X']\nassert op_upper_sortlen_strip(['abc', 'de', '']) == ['', 'DE', 'ABC']"}
{"id": "op_odds_uniq_trimends", "entry_point": "op_odds_uniq_trimends", "primitives": ["odds", "uniq", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop duplicates keeping first occurrence, then drop the first and last elements.", "solution": "def op_odds_uniq_trimends(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return r", "tests": "assert op_odds_uniq_trimends([1, 2, 3, 4]) == []\nassert op_odds_uniq_trimends([]) == []\nassert op_odds_uniq_trimends([-2, -1, 0, 1, 2]) == []\nassert op_odds_uniq_trimends([5, 5, 5]) == []\nassert op_odds_uniq_trimends([3, 1, 2]) == []\nassert op_odds_uniq_trimends([10]) == []\nassert op_odds_uniq_trimends([2, 4, 6]) == []\nassert op_odds_uniq_trimends([-7, 12, -7]) == []"}
{"id": "op_beforezero_negate_gt5", "entry_point": "op_beforezero_negate_gt5", "primitives": ["beforezero", "negate", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then negate each, then keep values greater than five.", "solution": "def op_beforezero_negate_gt5(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_beforezero_negate_gt5([1, 2, 3, 4]) == []\nassert op_beforezero_negate_gt5([]) == []\nassert op_beforezero_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_negate_gt5([5, 5, 5]) == []\nassert op_beforezero_negate_gt5([3, 1, 2]) == []\nassert op_beforezero_negate_gt5([10]) == []\nassert op_beforezero_negate_gt5([2, 4, 6]) == []\nassert op_beforezero_negate_gt5([-7, 12, -7]) == [7, 7]"}
{"id": "op_pos_negate_last3", "entry_point": "op_pos_negate_last3", "primitives": ["pos", "negate", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then negate each, then keep only the last three.", "solution": "def op_pos_negate_last3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [-x for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_pos_negate_last3([1, 2, 3, 4]) == [-2, -3, -4]\nassert op_pos_negate_last3([]) == []\nassert op_pos_negate_last3([-2, -1, 0, 1, 2]) == [-1, -2]\nassert op_pos_negate_last3([5, 5, 5]) == [-5, -5, -5]\nassert op_pos_negate_last3([3, 1, 2]) == [-3, -1, -2]\nassert op_pos_negate_last3([10]) == [-10]\nassert op_pos_negate_last3([2, 4, 6]) == [-2, -4, -6]\nassert op_pos_negate_last3([-7, 12, -7]) == [-12]"}
{"id": "op_add10_gt5_issorted", "entry_point": "op_add10_gt5_issorted", "primitives": ["add10", "gt5", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_add10_gt5_issorted(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_add10_gt5_issorted([1, 2, 3, 4]) == True\nassert op_add10_gt5_issorted([]) == True\nassert op_add10_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_add10_gt5_issorted([5, 5, 5]) == True\nassert op_add10_gt5_issorted([3, 1, 2]) == False\nassert op_add10_gt5_issorted([10]) == True\nassert op_add10_gt5_issorted([2, 4, 6]) == True\nassert op_add10_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_padto3_inc", "entry_point": "op_sorta_padto3_inc", "primitives": ["sorta", "padto3", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then pad with zeros to at least three elements, then add one to each.", "solution": "def op_sorta_padto3_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_padto3_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_padto3_inc([]) == [1, 1, 1]\nassert op_sorta_padto3_inc([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2, 3]\nassert op_sorta_padto3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_padto3_inc([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_padto3_inc([10]) == [11, 1, 1]\nassert op_sorta_padto3_inc([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_padto3_inc([-7, 12, -7]) == [-6, -6, 13]"}
{"id": "op_oremptyzero_sortd_negate", "entry_point": "op_oremptyzero_sortd_negate", "primitives": ["oremptyzero", "sortd", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending, then negate each.", "solution": "def op_oremptyzero_sortd_negate(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r", "tests": "assert op_oremptyzero_sortd_negate([1, 2, 3, 4]) == [-4, -3, -2, -1]\nassert op_oremptyzero_sortd_negate([]) == [0]\nassert op_oremptyzero_sortd_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_oremptyzero_sortd_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_oremptyzero_sortd_negate([3, 1, 2]) == [-3, -2, -1]\nassert op_oremptyzero_sortd_negate([10]) == [-10]\nassert op_oremptyzero_sortd_negate([2, 4, 6]) == [-6, -4, -2]\nassert op_oremptyzero_sortd_negate([-7, 12, -7]) == [-12, 7, 7]"}
{"id": "op_add10_sortd_odds", "entry_point": "op_add10_sortd_odds", "primitives": ["add10", "sortd", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort descending, then keep the odd numbers.", "solution": "def op_add10_sortd_odds(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_add10_sortd_odds([1, 2, 3, 4]) == [13, 11]\nassert op_add10_sortd_odds([]) == []\nassert op_add10_sortd_odds([-2, -1, 0, 1, 2]) == [11, 9]\nassert op_add10_sortd_odds([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortd_odds([3, 1, 2]) == [13, 11]\nassert op_add10_sortd_odds([10]) == []\nassert op_add10_sortd_odds([2, 4, 6]) == []\nassert op_add10_sortd_odds([-7, 12, -7]) == [3, 3]"}
{"id": "op_square_first3_min", "entry_point": "op_square_first3_min", "primitives": ["square", "first3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_square_first3_min(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_square_first3_min([1, 2, 3, 4]) == 1\nassert op_square_first3_min([]) == 0\nassert op_square_first3_min([-2, -1, 0, 1, 2]) == 0\nassert op_square_first3_min([5, 5, 5]) == 25\nassert op_square_first3_min([3, 1, 2]) == 1\nassert op_square_first3_min([10]) == 100\nassert op_square_first3_min([2, 4, 6]) == 4\nassert op_square_first3_min([-7, 12, -7]) == 49"}
{"id": "op_oremptyzero_pos_takewhilepos", "entry_point": "op_oremptyzero_pos_takewhilepos", "primitives": ["oremptyzero", "pos", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep the positive numbers, then take values while they are positive.", "solution": "def op_oremptyzero_pos_takewhilepos(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_oremptyzero_pos_takewhilepos([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_pos_takewhilepos([]) == []\nassert op_oremptyzero_pos_takewhilepos([-2, -1, 0, 1, 2]) == [1, 2]\nassert op_oremptyzero_pos_takewhilepos([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_pos_takewhilepos([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_pos_takewhilepos([10]) == [10]\nassert op_oremptyzero_pos_takewhilepos([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_pos_takewhilepos([-7, 12, -7]) == [12]"}
{"id": "op_dropfirst_clamp10_inc", "entry_point": "op_dropfirst_clamp10_inc", "primitives": ["dropfirst", "clamp10", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cap each value at 10, then add one to each.", "solution": "def op_dropfirst_clamp10_inc(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [min(x, 10) for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_dropfirst_clamp10_inc([1, 2, 3, 4]) == [3, 4, 5]\nassert op_dropfirst_clamp10_inc([]) == []\nassert op_dropfirst_clamp10_inc([-2, -1, 0, 1, 2]) == [0, 1, 2, 3]\nassert op_dropfirst_clamp10_inc([5, 5, 5]) == [6, 6]\nassert op_dropfirst_clamp10_inc([3, 1, 2]) == [2, 3]\nassert op_dropfirst_clamp10_inc([10]) == []\nassert op_dropfirst_clamp10_inc([2, 4, 6]) == [5, 7]\nassert op_dropfirst_clamp10_inc([-7, 12, -7]) == [11, -6]"}
{"id": "op_clamp10_sorta_oremptyzero", "entry_point": "op_clamp10_sorta_oremptyzero", "primitives": ["clamp10", "sorta", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then sort ascending, then if empty, use a single zero.", "solution": "def op_clamp10_sorta_oremptyzero(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = sorted(r)\n    r = r if r else [0]\n    return r", "tests": "assert op_clamp10_sorta_oremptyzero([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_sorta_oremptyzero([]) == [0]\nassert op_clamp10_sorta_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_sorta_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_sorta_oremptyzero([3, 1, 2]) == [1, 2, 3]\nassert op_clamp10_sorta_oremptyzero([10]) == [10]\nassert op_clamp10_sorta_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_sorta_oremptyzero([-7, 12, -7]) == [-7, -7, 10]"}
{"id": "op_inc_double_last3", "entry_point": "op_inc_double_last3", "primitives": ["inc", "double", "last3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then double each, then keep only the last three.", "solution": "def op_inc_double_last3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    return r", "tests": "assert op_inc_double_last3([1, 2, 3, 4]) == [6, 8, 10]\nassert op_inc_double_last3([]) == []\nassert op_inc_double_last3([-2, -1, 0, 1, 2]) == [2, 4, 6]\nassert op_inc_double_last3([5, 5, 5]) == [12, 12, 12]\nassert op_inc_double_last3([3, 1, 2]) == [8, 4, 6]\nassert op_inc_double_last3([10]) == [22]\nassert op_inc_double_last3([2, 4, 6]) == [6, 10, 14]\nassert op_inc_double_last3([-7, 12, -7]) == [-12, 26, -12]"}
{"id": "op_gt5_div3_negate", "entry_point": "op_gt5_div3_negate", "primitives": ["gt5", "div3", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep multiples of three, then negate each.", "solution": "def op_gt5_div3_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 3 == 0]\n    r = [-x for x in r]\n    return r", "tests": "assert op_gt5_div3_negate([1, 2, 3, 4]) == []\nassert op_gt5_div3_negate([]) == []\nassert op_gt5_div3_negate([-2, -1, 0, 1, 2]) == []\nassert op_gt5_div3_negate([5, 5, 5]) == []\nassert op_gt5_div3_negate([3, 1, 2]) == []\nassert op_gt5_div3_negate([10]) == []\nassert op_gt5_div3_negate([2, 4, 6]) == [-6]\nassert op_gt5_div3_negate([-7, 12, -7]) == [-12]"}
{"id": "op_ages_square_gt5", "entry_point": "op_ages_square_gt5", "primitives": ["ages", "square", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then keep values greater than five.", "solution": "def op_ages_square_gt5(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_ages_square_gt5([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1296, 144]\nassert op_ages_square_gt5([]) == []\nassert op_ages_square_gt5([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [324, 4225, 289]\nassert op_ages_square_gt5([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_sorta_oremptyzero_evens", "entry_point": "op_sorta_oremptyzero_evens", "primitives": ["sorta", "oremptyzero", "evens"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then keep the even numbers.", "solution": "def op_sorta_oremptyzero_evens(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sorta_oremptyzero_evens([1, 2, 3, 4]) == [2, 4]\nassert op_sorta_oremptyzero_evens([]) == [0]\nassert op_sorta_oremptyzero_evens([-2, -1, 0, 1, 2]) == [-2, 0, 2]\nassert op_sorta_oremptyzero_evens([5, 5, 5]) == []\nassert op_sorta_oremptyzero_evens([3, 1, 2]) == [2]\nassert op_sorta_oremptyzero_evens([10]) == [10]\nassert op_sorta_oremptyzero_evens([2, 4, 6]) == [2, 4, 6]\nassert op_sorta_oremptyzero_evens([-7, 12, -7]) == [12]"}
{"id": "op_neg_double_square", "entry_point": "op_neg_double_square", "primitives": ["neg", "double", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then double each, then square each.", "solution": "def op_neg_double_square(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_neg_double_square([1, 2, 3, 4]) == []\nassert op_neg_double_square([]) == []\nassert op_neg_double_square([-2, -1, 0, 1, 2]) == [16, 4]\nassert op_neg_double_square([5, 5, 5]) == []\nassert op_neg_double_square([3, 1, 2]) == []\nassert op_neg_double_square([10]) == []\nassert op_neg_double_square([2, 4, 6]) == []\nassert op_neg_double_square([-7, 12, -7]) == [196, 196]"}
{"id": "op_rev_div3_trimends", "entry_point": "op_rev_div3_trimends", "primitives": ["rev", "div3", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep multiples of three, then drop the first and last elements.", "solution": "def op_rev_div3_trimends(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 3 == 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_rev_div3_trimends([1, 2, 3, 4]) == []\nassert op_rev_div3_trimends([]) == []\nassert op_rev_div3_trimends([-2, -1, 0, 1, 2]) == []\nassert op_rev_div3_trimends([5, 5, 5]) == []\nassert op_rev_div3_trimends([3, 1, 2]) == []\nassert op_rev_div3_trimends([10]) == []\nassert op_rev_div3_trimends([2, 4, 6]) == []\nassert op_rev_div3_trimends([-7, 12, -7]) == []"}
{"id": "op_oremptyzero_negate_absval", "entry_point": "op_oremptyzero_negate_absval", "primitives": ["oremptyzero", "negate", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then negate each, then take the absolute value of each.", "solution": "def op_oremptyzero_negate_absval(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [-x for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_oremptyzero_negate_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_oremptyzero_negate_absval([]) == [0]\nassert op_oremptyzero_negate_absval([-2, -1, 0, 1, 2]) == [2, 1, 0, 1, 2]\nassert op_oremptyzero_negate_absval([5, 5, 5]) == [5, 5, 5]\nassert op_oremptyzero_negate_absval([3, 1, 2]) == [3, 1, 2]\nassert op_oremptyzero_negate_absval([10]) == [10]\nassert op_oremptyzero_negate_absval([2, 4, 6]) == [2, 4, 6]\nassert op_oremptyzero_negate_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_rev_first3_inc", "entry_point": "op_rev_first3_inc", "primitives": ["rev", "first3", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the first three, then add one to each.", "solution": "def op_rev_first3_inc(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:3]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_rev_first3_inc([1, 2, 3, 4]) == [5, 4, 3]\nassert op_rev_first3_inc([]) == []\nassert op_rev_first3_inc([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_rev_first3_inc([5, 5, 5]) == [6, 6, 6]\nassert op_rev_first3_inc([3, 1, 2]) == [3, 2, 4]\nassert op_rev_first3_inc([10]) == [11]\nassert op_rev_first3_inc([2, 4, 6]) == [7, 5, 3]\nassert op_rev_first3_inc([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_sortd_oremptyzero_dec", "entry_point": "op_sortd_oremptyzero_dec", "primitives": ["sortd", "oremptyzero", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then if empty, use a single zero, then subtract one from each.", "solution": "def op_sortd_oremptyzero_dec(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r if r else [0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_sortd_oremptyzero_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_sortd_oremptyzero_dec([]) == [-1]\nassert op_sortd_oremptyzero_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, -2, -3]\nassert op_sortd_oremptyzero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_sortd_oremptyzero_dec([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_oremptyzero_dec([10]) == [9]\nassert op_sortd_oremptyzero_dec([2, 4, 6]) == [5, 3, 1]\nassert op_sortd_oremptyzero_dec([-7, 12, -7]) == [11, -8, -8]"}
{"id": "op_gt5_sortabs_sortd", "entry_point": "op_gt5_sortabs_sortd", "primitives": ["gt5", "sortabs", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then sort by absolute value, then sort descending.", "solution": "def op_gt5_sortabs_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = sorted(r, key=abs)\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_gt5_sortabs_sortd([1, 2, 3, 4]) == []\nassert op_gt5_sortabs_sortd([]) == []\nassert op_gt5_sortabs_sortd([-2, -1, 0, 1, 2]) == []\nassert op_gt5_sortabs_sortd([5, 5, 5]) == []\nassert op_gt5_sortabs_sortd([3, 1, 2]) == []\nassert op_gt5_sortabs_sortd([10]) == [10]\nassert op_gt5_sortabs_sortd([2, 4, 6]) == [6]\nassert op_gt5_sortabs_sortd([-7, 12, -7]) == [12]"}
{"id": "op_uniq_oremptyzero_dropfirst", "entry_point": "op_uniq_oremptyzero_dropfirst", "primitives": ["uniq", "oremptyzero", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then if empty, use a single zero, then drop the first element.", "solution": "def op_uniq_oremptyzero_dropfirst(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r if r else [0]\n    r = r[1:]\n    return r", "tests": "assert op_uniq_oremptyzero_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_uniq_oremptyzero_dropfirst([]) == []\nassert op_uniq_oremptyzero_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_uniq_oremptyzero_dropfirst([5, 5, 5]) == []\nassert op_uniq_oremptyzero_dropfirst([3, 1, 2]) == [1, 2]\nassert op_uniq_oremptyzero_dropfirst([10]) == []\nassert op_uniq_oremptyzero_dropfirst([2, 4, 6]) == [4, 6]\nassert op_uniq_oremptyzero_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_oremptyzero_square", "entry_point": "op_sortabs_oremptyzero_square", "primitives": ["sortabs", "oremptyzero", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then square each.", "solution": "def op_sortabs_oremptyzero_square(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_sortabs_oremptyzero_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_sortabs_oremptyzero_square([]) == [0]\nassert op_sortabs_oremptyzero_square([-2, -1, 0, 1, 2]) == [0, 1, 1, 4, 4]\nassert op_sortabs_oremptyzero_square([5, 5, 5]) == [25, 25, 25]\nassert op_sortabs_oremptyzero_square([3, 1, 2]) == [1, 4, 9]\nassert op_sortabs_oremptyzero_square([10]) == [100]\nassert op_sortabs_oremptyzero_square([2, 4, 6]) == [4, 16, 36]\nassert op_sortabs_oremptyzero_square([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_trimends_neg_dec", "entry_point": "op_trimends_neg_dec", "primitives": ["trimends", "neg", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the negative numbers, then subtract one from each.", "solution": "def op_trimends_neg_dec(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_trimends_neg_dec([1, 2, 3, 4]) == []\nassert op_trimends_neg_dec([]) == []\nassert op_trimends_neg_dec([-2, -1, 0, 1, 2]) == [-2]\nassert op_trimends_neg_dec([5, 5, 5]) == []\nassert op_trimends_neg_dec([3, 1, 2]) == []\nassert op_trimends_neg_dec([10]) == []\nassert op_trimends_neg_dec([2, 4, 6]) == []\nassert op_trimends_neg_dec([-7, 12, -7]) == []"}
{"id": "op_div3_pos_counteven", "entry_point": "op_div3_pos_counteven", "primitives": ["div3", "pos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the positive numbers, then return how many values are even.", "solution": "def op_div3_pos_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_div3_pos_counteven([1, 2, 3, 4]) == 0\nassert op_div3_pos_counteven([]) == 0\nassert op_div3_pos_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_pos_counteven([5, 5, 5]) == 0\nassert op_div3_pos_counteven([3, 1, 2]) == 0\nassert op_div3_pos_counteven([10]) == 0\nassert op_div3_pos_counteven([2, 4, 6]) == 1\nassert op_div3_pos_counteven([-7, 12, -7]) == 1"}
{"id": "op_sorta_sortd_div3", "entry_point": "op_sorta_sortd_div3", "primitives": ["sorta", "sortd", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then sort descending, then keep multiples of three.", "solution": "def op_sorta_sortd_div3(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sorta_sortd_div3([1, 2, 3, 4]) == [3]\nassert op_sorta_sortd_div3([]) == []\nassert op_sorta_sortd_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sorta_sortd_div3([5, 5, 5]) == []\nassert op_sorta_sortd_div3([3, 1, 2]) == [3]\nassert op_sorta_sortd_div3([10]) == []\nassert op_sorta_sortd_div3([2, 4, 6]) == [6]\nassert op_sorta_sortd_div3([-7, 12, -7]) == [12]"}
{"id": "op_neg_beforezero_oremptyzero", "entry_point": "op_neg_beforezero_oremptyzero", "primitives": ["neg", "beforezero", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then keep everything before the first zero, then if empty, use a single zero.", "solution": "def op_neg_beforezero_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r if r else [0]\n    return r", "tests": "assert op_neg_beforezero_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_neg_beforezero_oremptyzero([]) == [0]\nassert op_neg_beforezero_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1]\nassert op_neg_beforezero_oremptyzero([5, 5, 5]) == [0]\nassert op_neg_beforezero_oremptyzero([3, 1, 2]) == [0]\nassert op_neg_beforezero_oremptyzero([10]) == [0]\nassert op_neg_beforezero_oremptyzero([2, 4, 6]) == [0]\nassert op_neg_beforezero_oremptyzero([-7, 12, -7]) == [-7, -7]"}
{"id": "op_sortabs_inc_neg", "entry_point": "op_sortabs_inc_neg", "primitives": ["sortabs", "inc", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then add one to each, then keep the negative numbers.", "solution": "def op_sortabs_inc_neg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortabs_inc_neg([1, 2, 3, 4]) == []\nassert op_sortabs_inc_neg([]) == []\nassert op_sortabs_inc_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_sortabs_inc_neg([5, 5, 5]) == []\nassert op_sortabs_inc_neg([3, 1, 2]) == []\nassert op_sortabs_inc_neg([10]) == []\nassert op_sortabs_inc_neg([2, 4, 6]) == []\nassert op_sortabs_inc_neg([-7, 12, -7]) == [-6, -6]"}
{"id": "op_takewhilepos_beforezero_prod", "entry_point": "op_takewhilepos_beforezero_prod", "primitives": ["takewhilepos", "beforezero", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep everything before the first zero, then return their product.", "solution": "def op_takewhilepos_beforezero_prod(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:r.index(0)] if 0 in r else r\n    return __import__('math').prod(r)", "tests": "assert op_takewhilepos_beforezero_prod([1, 2, 3, 4]) == 24\nassert op_takewhilepos_beforezero_prod([]) == 1\nassert op_takewhilepos_beforezero_prod([-2, -1, 0, 1, 2]) == 1\nassert op_takewhilepos_beforezero_prod([5, 5, 5]) == 125\nassert op_takewhilepos_beforezero_prod([3, 1, 2]) == 6\nassert op_takewhilepos_beforezero_prod([10]) == 10\nassert op_takewhilepos_beforezero_prod([2, 4, 6]) == 48\nassert op_takewhilepos_beforezero_prod([-7, 12, -7]) == 1"}
{"id": "op_dec_evens_min", "entry_point": "op_dec_evens_min", "primitives": ["dec", "evens", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep the even numbers, then return the minimum (0 if empty).", "solution": "def op_dec_evens_min(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return min(r) if r else 0", "tests": "assert op_dec_evens_min([1, 2, 3, 4]) == 0\nassert op_dec_evens_min([]) == 0\nassert op_dec_evens_min([-2, -1, 0, 1, 2]) == -2\nassert op_dec_evens_min([5, 5, 5]) == 4\nassert op_dec_evens_min([3, 1, 2]) == 0\nassert op_dec_evens_min([10]) == 0\nassert op_dec_evens_min([2, 4, 6]) == 0\nassert op_dec_evens_min([-7, 12, -7]) == -8"}
{"id": "op_padto3_last3_dec", "entry_point": "op_padto3_last3_dec", "primitives": ["padto3", "last3", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep only the last three, then subtract one from each.", "solution": "def op_padto3_last3_dec(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[-3:]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_padto3_last3_dec([1, 2, 3, 4]) == [1, 2, 3]\nassert op_padto3_last3_dec([]) == [-1, -1, -1]\nassert op_padto3_last3_dec([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_padto3_last3_dec([5, 5, 5]) == [4, 4, 4]\nassert op_padto3_last3_dec([3, 1, 2]) == [2, 0, 1]\nassert op_padto3_last3_dec([10]) == [9, -1, -1]\nassert op_padto3_last3_dec([2, 4, 6]) == [1, 3, 5]\nassert op_padto3_last3_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_dropwhileneg_clamp10_gt5", "entry_point": "op_dropwhileneg_clamp10_gt5", "primitives": ["dropwhileneg", "clamp10", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cap each value at 10, then keep values greater than five.", "solution": "def op_dropwhileneg_clamp10_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_clamp10_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_clamp10_gt5([]) == []\nassert op_dropwhileneg_clamp10_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_clamp10_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_clamp10_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_clamp10_gt5([10]) == [10]\nassert op_dropwhileneg_clamp10_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_clamp10_gt5([-7, 12, -7]) == [10]"}
{"id": "op_dropfirst_trimends_first3", "entry_point": "op_dropfirst_trimends_first3", "primitives": ["dropfirst", "trimends", "first3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the first and last elements, then keep only the first three.", "solution": "def op_dropfirst_trimends_first3(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[1:-1]\n    r = r[:3]\n    return r", "tests": "assert op_dropfirst_trimends_first3([1, 2, 3, 4]) == [3]\nassert op_dropfirst_trimends_first3([]) == []\nassert op_dropfirst_trimends_first3([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_dropfirst_trimends_first3([5, 5, 5]) == []\nassert op_dropfirst_trimends_first3([3, 1, 2]) == []\nassert op_dropfirst_trimends_first3([10]) == []\nassert op_dropfirst_trimends_first3([2, 4, 6]) == []\nassert op_dropfirst_trimends_first3([-7, 12, -7]) == []"}
{"id": "op_square_dropwhileneg_add10", "entry_point": "op_square_dropwhileneg_add10", "primitives": ["square", "dropwhileneg", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the leading negative values, then add ten to each.", "solution": "def op_square_dropwhileneg_add10(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_square_dropwhileneg_add10([1, 2, 3, 4]) == [11, 14, 19, 26]\nassert op_square_dropwhileneg_add10([]) == []\nassert op_square_dropwhileneg_add10([-2, -1, 0, 1, 2]) == [14, 11, 10, 11, 14]\nassert op_square_dropwhileneg_add10([5, 5, 5]) == [35, 35, 35]\nassert op_square_dropwhileneg_add10([3, 1, 2]) == [19, 11, 14]\nassert op_square_dropwhileneg_add10([10]) == [110]\nassert op_square_dropwhileneg_add10([2, 4, 6]) == [14, 26, 46]\nassert op_square_dropwhileneg_add10([-7, 12, -7]) == [59, 154, 59]"}
{"id": "op_dropwhileneg_div3_min", "entry_point": "op_dropwhileneg_div3_min", "primitives": ["dropwhileneg", "div3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_dropwhileneg_div3_min(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_dropwhileneg_div3_min([1, 2, 3, 4]) == 3\nassert op_dropwhileneg_div3_min([]) == 0\nassert op_dropwhileneg_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_dropwhileneg_div3_min([5, 5, 5]) == 0\nassert op_dropwhileneg_div3_min([3, 1, 2]) == 3\nassert op_dropwhileneg_div3_min([10]) == 0\nassert op_dropwhileneg_div3_min([2, 4, 6]) == 6\nassert op_dropwhileneg_div3_min([-7, 12, -7]) == 12"}
{"id": "op_dropzeros_first3_firsteven", "entry_point": "op_dropzeros_first3_firsteven", "primitives": ["dropzeros", "first3", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then return the first even value (0 if none).", "solution": "def op_dropzeros_first3_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_dropzeros_first3_firsteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_first3_firsteven([]) == 0\nassert op_dropzeros_first3_firsteven([-2, -1, 0, 1, 2]) == -2\nassert op_dropzeros_first3_firsteven([5, 5, 5]) == 0\nassert op_dropzeros_first3_firsteven([3, 1, 2]) == 2\nassert op_dropzeros_first3_firsteven([10]) == 10\nassert op_dropzeros_first3_firsteven([2, 4, 6]) == 2\nassert op_dropzeros_first3_firsteven([-7, 12, -7]) == 12"}
{"id": "op_odds_trimends_neg", "entry_point": "op_odds_trimends_neg", "primitives": ["odds", "trimends", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_odds_trimends_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_trimends_neg([1, 2, 3, 4]) == []\nassert op_odds_trimends_neg([]) == []\nassert op_odds_trimends_neg([-2, -1, 0, 1, 2]) == []\nassert op_odds_trimends_neg([5, 5, 5]) == []\nassert op_odds_trimends_neg([3, 1, 2]) == []\nassert op_odds_trimends_neg([10]) == []\nassert op_odds_trimends_neg([2, 4, 6]) == []\nassert op_odds_trimends_neg([-7, 12, -7]) == []"}
{"id": "op_rev_odds_len", "entry_point": "op_rev_odds_len", "primitives": ["rev", "odds", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the odd numbers, then return how many remain.", "solution": "def op_rev_odds_len(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_rev_odds_len([1, 2, 3, 4]) == 2\nassert op_rev_odds_len([]) == 0\nassert op_rev_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_rev_odds_len([5, 5, 5]) == 3\nassert op_rev_odds_len([3, 1, 2]) == 2\nassert op_rev_odds_len([10]) == 0\nassert op_rev_odds_len([2, 4, 6]) == 0\nassert op_rev_odds_len([-7, 12, -7]) == 2"}
{"id": "op_sorta_inc_absval", "entry_point": "op_sorta_inc_absval", "primitives": ["sorta", "inc", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then add one to each, then take the absolute value of each.", "solution": "def op_sorta_inc_absval(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sorta_inc_absval([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_sorta_inc_absval([]) == []\nassert op_sorta_inc_absval([-2, -1, 0, 1, 2]) == [1, 0, 1, 2, 3]\nassert op_sorta_inc_absval([5, 5, 5]) == [6, 6, 6]\nassert op_sorta_inc_absval([3, 1, 2]) == [2, 3, 4]\nassert op_sorta_inc_absval([10]) == [11]\nassert op_sorta_inc_absval([2, 4, 6]) == [3, 5, 7]\nassert op_sorta_inc_absval([-7, 12, -7]) == [6, 6, 13]"}
{"id": "op_firstchar_nonempty_longest", "entry_point": "op_firstchar_nonempty_longest", "primitives": ["firstchar", "nonempty", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then drop empty strings, then return the longest string (empty if none).", "solution": "def op_firstchar_nonempty_longest(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_firstchar_nonempty_longest(['Hello', 'world']) == 'H'\nassert op_firstchar_nonempty_longest([]) == ''\nassert op_firstchar_nonempty_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_firstchar_nonempty_longest(['one', 'one', 'Two']) == 'o'\nassert op_firstchar_nonempty_longest(['x']) == 'x'\nassert op_firstchar_nonempty_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_inc_trimends_haszero", "entry_point": "op_inc_trimends_haszero", "primitives": ["inc", "trimends", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then return whether the list contains a zero.", "solution": "def op_inc_trimends_haszero(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    return 0 in r", "tests": "assert op_inc_trimends_haszero([1, 2, 3, 4]) == False\nassert op_inc_trimends_haszero([]) == False\nassert op_inc_trimends_haszero([-2, -1, 0, 1, 2]) == True\nassert op_inc_trimends_haszero([5, 5, 5]) == False\nassert op_inc_trimends_haszero([3, 1, 2]) == False\nassert op_inc_trimends_haszero([10]) == False\nassert op_inc_trimends_haszero([2, 4, 6]) == False\nassert op_inc_trimends_haszero([-7, 12, -7]) == False"}
{"id": "op_sorta_negate_inc", "entry_point": "op_sorta_negate_inc", "primitives": ["sorta", "negate", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then add one to each.", "solution": "def op_sorta_negate_inc(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_sorta_negate_inc([1, 2, 3, 4]) == [0, -1, -2, -3]\nassert op_sorta_negate_inc([]) == []\nassert op_sorta_negate_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 0, -1]\nassert op_sorta_negate_inc([5, 5, 5]) == [-4, -4, -4]\nassert op_sorta_negate_inc([3, 1, 2]) == [0, -1, -2]\nassert op_sorta_negate_inc([10]) == [-9]\nassert op_sorta_negate_inc([2, 4, 6]) == [-1, -3, -5]\nassert op_sorta_negate_inc([-7, 12, -7]) == [8, 8, -11]"}
{"id": "op_first3_beforezero_dec", "entry_point": "op_first3_beforezero_dec", "primitives": ["first3", "beforezero", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then keep everything before the first zero, then subtract one from each.", "solution": "def op_first3_beforezero_dec(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_first3_beforezero_dec([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_beforezero_dec([]) == []\nassert op_first3_beforezero_dec([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_first3_beforezero_dec([5, 5, 5]) == [4, 4, 4]\nassert op_first3_beforezero_dec([3, 1, 2]) == [2, 0, 1]\nassert op_first3_beforezero_dec([10]) == [9]\nassert op_first3_beforezero_dec([2, 4, 6]) == [1, 3, 5]\nassert op_first3_beforezero_dec([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_negate_square_max", "entry_point": "op_negate_square_max", "primitives": ["negate", "square", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then square each, then return the maximum (0 if empty).", "solution": "def op_negate_square_max(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x * x for x in r]\n    return max(r) if r else 0", "tests": "assert op_negate_square_max([1, 2, 3, 4]) == 16\nassert op_negate_square_max([]) == 0\nassert op_negate_square_max([-2, -1, 0, 1, 2]) == 4\nassert op_negate_square_max([5, 5, 5]) == 25\nassert op_negate_square_max([3, 1, 2]) == 9\nassert op_negate_square_max([10]) == 100\nassert op_negate_square_max([2, 4, 6]) == 36\nassert op_negate_square_max([-7, 12, -7]) == 144"}
{"id": "op_dec_sortabs_clamp10", "entry_point": "op_dec_sortabs_clamp10", "primitives": ["dec", "sortabs", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then sort by absolute value, then cap each value at 10.", "solution": "def op_dec_sortabs_clamp10(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = sorted(r, key=abs)\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_dec_sortabs_clamp10([1, 2, 3, 4]) == [0, 1, 2, 3]\nassert op_dec_sortabs_clamp10([]) == []\nassert op_dec_sortabs_clamp10([-2, -1, 0, 1, 2]) == [0, -1, 1, -2, -3]\nassert op_dec_sortabs_clamp10([5, 5, 5]) == [4, 4, 4]\nassert op_dec_sortabs_clamp10([3, 1, 2]) == [0, 1, 2]\nassert op_dec_sortabs_clamp10([10]) == [9]\nassert op_dec_sortabs_clamp10([2, 4, 6]) == [1, 3, 5]\nassert op_dec_sortabs_clamp10([-7, 12, -7]) == [-8, -8, 10]"}
{"id": "op_sortd_clamp10_odds", "entry_point": "op_sortd_clamp10_odds", "primitives": ["sortd", "clamp10", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then cap each value at 10, then keep the odd numbers.", "solution": "def op_sortd_clamp10_odds(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortd_clamp10_odds([1, 2, 3, 4]) == [3, 1]\nassert op_sortd_clamp10_odds([]) == []\nassert op_sortd_clamp10_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_sortd_clamp10_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortd_clamp10_odds([3, 1, 2]) == [3, 1]\nassert op_sortd_clamp10_odds([10]) == []\nassert op_sortd_clamp10_odds([2, 4, 6]) == []\nassert op_sortd_clamp10_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_uniqs_sortalpha_longest", "entry_point": "op_uniqs_sortalpha_longest", "primitives": ["uniqs", "sortalpha", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort alphabetically, then return the longest string (empty if none).", "solution": "def op_uniqs_sortalpha_longest(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r)\n    return max(r, key=len) if r else ''", "tests": "assert op_uniqs_sortalpha_longest(['Hello', 'world']) == 'Hello'\nassert op_uniqs_sortalpha_longest([]) == ''\nassert op_uniqs_sortalpha_longest(['  a ', '', 'BC', 'bc']) == '  a '\nassert op_uniqs_sortalpha_longest(['one', 'one', 'Two']) == 'Two'\nassert op_uniqs_sortalpha_longest(['x']) == 'x'\nassert op_uniqs_sortalpha_longest(['abc', 'de', '']) == 'abc'"}
{"id": "op_gt5_rev_min", "entry_point": "op_gt5_rev_min", "primitives": ["gt5", "rev", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then reverse the order, then return the minimum (0 if empty).", "solution": "def op_gt5_rev_min(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(reversed(r))\n    return min(r) if r else 0", "tests": "assert op_gt5_rev_min([1, 2, 3, 4]) == 0\nassert op_gt5_rev_min([]) == 0\nassert op_gt5_rev_min([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_rev_min([5, 5, 5]) == 0\nassert op_gt5_rev_min([3, 1, 2]) == 0\nassert op_gt5_rev_min([10]) == 10\nassert op_gt5_rev_min([2, 4, 6]) == 6\nassert op_gt5_rev_min([-7, 12, -7]) == 12"}
{"id": "op_sortd_takewhilepos_alldistinct", "entry_point": "op_sortd_takewhilepos_alldistinct", "primitives": ["sortd", "takewhilepos", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then return whether all values are distinct.", "solution": "def op_sortd_takewhilepos_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_takewhilepos_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_takewhilepos_alldistinct([]) == True\nassert op_sortd_takewhilepos_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_takewhilepos_alldistinct([5, 5, 5]) == False\nassert op_sortd_takewhilepos_alldistinct([3, 1, 2]) == True\nassert op_sortd_takewhilepos_alldistinct([10]) == True\nassert op_sortd_takewhilepos_alldistinct([2, 4, 6]) == True\nassert op_sortd_takewhilepos_alldistinct([-7, 12, -7]) == True"}
{"id": "op_strip_sortlen_prefixup", "entry_point": "op_strip_sortlen_prefixup", "primitives": ["strip", "sortlen", "prefixup"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then sort by length, shortest first, then prefix each with a hash.", "solution": "def op_strip_sortlen_prefixup(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_strip_sortlen_prefixup(['Hello', 'world']) == ['#Hello', '#world']\nassert op_strip_sortlen_prefixup([]) == []\nassert op_strip_sortlen_prefixup(['  a ', '', 'BC', 'bc']) == ['#', '#a', '#BC', '#bc']\nassert op_strip_sortlen_prefixup(['one', 'one', 'Two']) == ['#one', '#one', '#Two']\nassert op_strip_sortlen_prefixup(['x']) == ['#x']\nassert op_strip_sortlen_prefixup(['abc', 'de', '']) == ['#', '#de', '#abc']"}
{"id": "op_double_padto3_counteven", "entry_point": "op_double_padto3_counteven", "primitives": ["double", "padto3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_double_padto3_counteven(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_double_padto3_counteven([1, 2, 3, 4]) == 4\nassert op_double_padto3_counteven([]) == 3\nassert op_double_padto3_counteven([-2, -1, 0, 1, 2]) == 5\nassert op_double_padto3_counteven([5, 5, 5]) == 3\nassert op_double_padto3_counteven([3, 1, 2]) == 3\nassert op_double_padto3_counteven([10]) == 3\nassert op_double_padto3_counteven([2, 4, 6]) == 3\nassert op_double_padto3_counteven([-7, 12, -7]) == 3"}
{"id": "op_gt5_dropzeros_neg", "entry_point": "op_gt5_dropzeros_neg", "primitives": ["gt5", "dropzeros", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the zeros, then keep the negative numbers.", "solution": "def op_gt5_dropzeros_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_gt5_dropzeros_neg([1, 2, 3, 4]) == []\nassert op_gt5_dropzeros_neg([]) == []\nassert op_gt5_dropzeros_neg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_dropzeros_neg([5, 5, 5]) == []\nassert op_gt5_dropzeros_neg([3, 1, 2]) == []\nassert op_gt5_dropzeros_neg([10]) == []\nassert op_gt5_dropzeros_neg([2, 4, 6]) == []\nassert op_gt5_dropzeros_neg([-7, 12, -7]) == []"}
{"id": "op_sortlen_firstchar_anyempty", "entry_point": "op_sortlen_firstchar_anyempty", "primitives": ["sortlen", "firstchar", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then keep the first character of each (dropping empties), then return whether any string is empty.", "solution": "def op_sortlen_firstchar_anyempty(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    return any(s == '' for s in r)", "tests": "assert op_sortlen_firstchar_anyempty(['Hello', 'world']) == False\nassert op_sortlen_firstchar_anyempty([]) == False\nassert op_sortlen_firstchar_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_sortlen_firstchar_anyempty(['one', 'one', 'Two']) == False\nassert op_sortlen_firstchar_anyempty(['x']) == False\nassert op_sortlen_firstchar_anyempty(['abc', 'de', '']) == False"}
{"id": "op_beforezero_uniq_odds", "entry_point": "op_beforezero_uniq_odds", "primitives": ["beforezero", "uniq", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then drop duplicates keeping first occurrence, then keep the odd numbers.", "solution": "def op_beforezero_uniq_odds(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_beforezero_uniq_odds([1, 2, 3, 4]) == [1, 3]\nassert op_beforezero_uniq_odds([]) == []\nassert op_beforezero_uniq_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_beforezero_uniq_odds([5, 5, 5]) == [5]\nassert op_beforezero_uniq_odds([3, 1, 2]) == [3, 1]\nassert op_beforezero_uniq_odds([10]) == []\nassert op_beforezero_uniq_odds([2, 4, 6]) == []\nassert op_beforezero_uniq_odds([-7, 12, -7]) == [-7]"}
{"id": "op_add10_evens_oremptyzero", "entry_point": "op_add10_evens_oremptyzero", "primitives": ["add10", "evens", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then keep the even numbers, then if empty, use a single zero.", "solution": "def op_add10_evens_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_evens_oremptyzero([1, 2, 3, 4]) == [12, 14]\nassert op_add10_evens_oremptyzero([]) == [0]\nassert op_add10_evens_oremptyzero([-2, -1, 0, 1, 2]) == [8, 10, 12]\nassert op_add10_evens_oremptyzero([5, 5, 5]) == [0]\nassert op_add10_evens_oremptyzero([3, 1, 2]) == [12]\nassert op_add10_evens_oremptyzero([10]) == [20]\nassert op_add10_evens_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_evens_oremptyzero([-7, 12, -7]) == [22]"}
{"id": "op_negate_add10_neg", "entry_point": "op_negate_add10_neg", "primitives": ["negate", "add10", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then add ten to each, then keep the negative numbers.", "solution": "def op_negate_add10_neg(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_negate_add10_neg([1, 2, 3, 4]) == []\nassert op_negate_add10_neg([]) == []\nassert op_negate_add10_neg([-2, -1, 0, 1, 2]) == []\nassert op_negate_add10_neg([5, 5, 5]) == []\nassert op_negate_add10_neg([3, 1, 2]) == []\nassert op_negate_add10_neg([10]) == []\nassert op_negate_add10_neg([2, 4, 6]) == []\nassert op_negate_add10_neg([-7, 12, -7]) == [-2]"}
{"id": "op_trimends_padto3_dropzeros", "entry_point": "op_trimends_padto3_dropzeros", "primitives": ["trimends", "padto3", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then pad with zeros to at least three elements, then drop the zeros.", "solution": "def op_trimends_padto3_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_padto3_dropzeros([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_padto3_dropzeros([]) == []\nassert op_trimends_padto3_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_trimends_padto3_dropzeros([5, 5, 5]) == [5]\nassert op_trimends_padto3_dropzeros([3, 1, 2]) == [1]\nassert op_trimends_padto3_dropzeros([10]) == []\nassert op_trimends_padto3_dropzeros([2, 4, 6]) == [4]\nassert op_trimends_padto3_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_absval_dropwhileneg_inc", "entry_point": "op_absval_dropwhileneg_inc", "primitives": ["absval", "dropwhileneg", "inc"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then add one to each.", "solution": "def op_absval_dropwhileneg_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_dropwhileneg_inc([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_absval_dropwhileneg_inc([]) == []\nassert op_absval_dropwhileneg_inc([-2, -1, 0, 1, 2]) == [3, 2, 1, 2, 3]\nassert op_absval_dropwhileneg_inc([5, 5, 5]) == [6, 6, 6]\nassert op_absval_dropwhileneg_inc([3, 1, 2]) == [4, 2, 3]\nassert op_absval_dropwhileneg_inc([10]) == [11]\nassert op_absval_dropwhileneg_inc([2, 4, 6]) == [3, 5, 7]\nassert op_absval_dropwhileneg_inc([-7, 12, -7]) == [8, 13, 8]"}
{"id": "op_pos_inc_negate", "entry_point": "op_pos_inc_negate", "primitives": ["pos", "inc", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then negate each.", "solution": "def op_pos_inc_negate(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_pos_inc_negate([1, 2, 3, 4]) == [-2, -3, -4, -5]\nassert op_pos_inc_negate([]) == []\nassert op_pos_inc_negate([-2, -1, 0, 1, 2]) == [-2, -3]\nassert op_pos_inc_negate([5, 5, 5]) == [-6, -6, -6]\nassert op_pos_inc_negate([3, 1, 2]) == [-4, -2, -3]\nassert op_pos_inc_negate([10]) == [-11]\nassert op_pos_inc_negate([2, 4, 6]) == [-3, -5, -7]\nassert op_pos_inc_negate([-7, 12, -7]) == [-13]"}
{"id": "op_first3_dec_absval", "entry_point": "op_first3_dec_absval", "primitives": ["first3", "dec", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then take the absolute value of each.", "solution": "def op_first3_dec_absval(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_first3_dec_absval([1, 2, 3, 4]) == [0, 1, 2]\nassert op_first3_dec_absval([]) == []\nassert op_first3_dec_absval([-2, -1, 0, 1, 2]) == [3, 2, 1]\nassert op_first3_dec_absval([5, 5, 5]) == [4, 4, 4]\nassert op_first3_dec_absval([3, 1, 2]) == [2, 0, 1]\nassert op_first3_dec_absval([10]) == [9]\nassert op_first3_dec_absval([2, 4, 6]) == [1, 3, 5]\nassert op_first3_dec_absval([-7, 12, -7]) == [8, 11, 8]"}
{"id": "op_sorta_beforezero_allpos", "entry_point": "op_sorta_beforezero_allpos", "primitives": ["sorta", "beforezero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort ascending, then keep everything before the first zero, then return whether all values are positive.", "solution": "def op_sorta_beforezero_allpos(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r[:r.index(0)] if 0 in r else r\n    return all(x > 0 for x in r)", "tests": "assert op_sorta_beforezero_allpos([1, 2, 3, 4]) == True\nassert op_sorta_beforezero_allpos([]) == True\nassert op_sorta_beforezero_allpos([-2, -1, 0, 1, 2]) == False\nassert op_sorta_beforezero_allpos([5, 5, 5]) == True\nassert op_sorta_beforezero_allpos([3, 1, 2]) == True\nassert op_sorta_beforezero_allpos([10]) == True\nassert op_sorta_beforezero_allpos([2, 4, 6]) == True\nassert op_sorta_beforezero_allpos([-7, 12, -7]) == False"}
{"id": "op_dropwhileneg_div3_gt5", "entry_point": "op_dropwhileneg_div3_gt5", "primitives": ["dropwhileneg", "div3", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then keep multiples of three, then keep values greater than five.", "solution": "def op_dropwhileneg_div3_gt5(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropwhileneg_div3_gt5([1, 2, 3, 4]) == []\nassert op_dropwhileneg_div3_gt5([]) == []\nassert op_dropwhileneg_div3_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_div3_gt5([5, 5, 5]) == []\nassert op_dropwhileneg_div3_gt5([3, 1, 2]) == []\nassert op_dropwhileneg_div3_gt5([10]) == []\nassert op_dropwhileneg_div3_gt5([2, 4, 6]) == [6]\nassert op_dropwhileneg_div3_gt5([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_sortabs_counteven", "entry_point": "op_dropzeros_sortabs_counteven", "primitives": ["dropzeros", "sortabs", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort by absolute value, then return how many values are even.", "solution": "def op_dropzeros_sortabs_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropzeros_sortabs_counteven([1, 2, 3, 4]) == 2\nassert op_dropzeros_sortabs_counteven([]) == 0\nassert op_dropzeros_sortabs_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropzeros_sortabs_counteven([5, 5, 5]) == 0\nassert op_dropzeros_sortabs_counteven([3, 1, 2]) == 1\nassert op_dropzeros_sortabs_counteven([10]) == 1\nassert op_dropzeros_sortabs_counteven([2, 4, 6]) == 3\nassert op_dropzeros_sortabs_counteven([-7, 12, -7]) == 1"}
{"id": "op_trimends_gt5_dropzeros", "entry_point": "op_trimends_gt5_dropzeros", "primitives": ["trimends", "gt5", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep values greater than five, then drop the zeros.", "solution": "def op_trimends_gt5_dropzeros(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_trimends_gt5_dropzeros([1, 2, 3, 4]) == []\nassert op_trimends_gt5_dropzeros([]) == []\nassert op_trimends_gt5_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_trimends_gt5_dropzeros([5, 5, 5]) == []\nassert op_trimends_gt5_dropzeros([3, 1, 2]) == []\nassert op_trimends_gt5_dropzeros([10]) == []\nassert op_trimends_gt5_dropzeros([2, 4, 6]) == []\nassert op_trimends_gt5_dropzeros([-7, 12, -7]) == [12]"}
{"id": "op_square_odds_len", "entry_point": "op_square_odds_len", "primitives": ["square", "odds", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep the odd numbers, then return how many remain.", "solution": "def op_square_odds_len(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return len(r)", "tests": "assert op_square_odds_len([1, 2, 3, 4]) == 2\nassert op_square_odds_len([]) == 0\nassert op_square_odds_len([-2, -1, 0, 1, 2]) == 2\nassert op_square_odds_len([5, 5, 5]) == 3\nassert op_square_odds_len([3, 1, 2]) == 2\nassert op_square_odds_len([10]) == 0\nassert op_square_odds_len([2, 4, 6]) == 0\nassert op_square_odds_len([-7, 12, -7]) == 2"}
{"id": "op_takewhilepos_dropzeros_sortd", "entry_point": "op_takewhilepos_dropzeros_sortd", "primitives": ["takewhilepos", "dropzeros", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the zeros, then sort descending.", "solution": "def op_takewhilepos_dropzeros_sortd(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_takewhilepos_dropzeros_sortd([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_takewhilepos_dropzeros_sortd([]) == []\nassert op_takewhilepos_dropzeros_sortd([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_dropzeros_sortd([5, 5, 5]) == [5, 5, 5]\nassert op_takewhilepos_dropzeros_sortd([3, 1, 2]) == [3, 2, 1]\nassert op_takewhilepos_dropzeros_sortd([10]) == [10]\nassert op_takewhilepos_dropzeros_sortd([2, 4, 6]) == [6, 4, 2]\nassert op_takewhilepos_dropzeros_sortd([-7, 12, -7]) == []"}
{"id": "op_add10_square_dropfirst", "entry_point": "op_add10_square_dropfirst", "primitives": ["add10", "square", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then drop the first element.", "solution": "def op_add10_square_dropfirst(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_add10_square_dropfirst([1, 2, 3, 4]) == [144, 169, 196]\nassert op_add10_square_dropfirst([]) == []\nassert op_add10_square_dropfirst([-2, -1, 0, 1, 2]) == [81, 100, 121, 144]\nassert op_add10_square_dropfirst([5, 5, 5]) == [225, 225]\nassert op_add10_square_dropfirst([3, 1, 2]) == [121, 144]\nassert op_add10_square_dropfirst([10]) == []\nassert op_add10_square_dropfirst([2, 4, 6]) == [196, 256]\nassert op_add10_square_dropfirst([-7, 12, -7]) == [484, 9]"}
{"id": "op_absval_takewhilepos_trimends", "entry_point": "op_absval_takewhilepos_trimends", "primitives": ["absval", "takewhilepos", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then take values while they are positive, then drop the first and last elements.", "solution": "def op_absval_takewhilepos_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_takewhilepos_trimends([1, 2, 3, 4]) == [2, 3]\nassert op_absval_takewhilepos_trimends([]) == []\nassert op_absval_takewhilepos_trimends([-2, -1, 0, 1, 2]) == []\nassert op_absval_takewhilepos_trimends([5, 5, 5]) == [5]\nassert op_absval_takewhilepos_trimends([3, 1, 2]) == [1]\nassert op_absval_takewhilepos_trimends([10]) == []\nassert op_absval_takewhilepos_trimends([2, 4, 6]) == [4]\nassert op_absval_takewhilepos_trimends([-7, 12, -7]) == [12]"}
{"id": "op_neg_add10_min", "entry_point": "op_neg_add10_min", "primitives": ["neg", "add10", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then add ten to each, then return the minimum (0 if empty).", "solution": "def op_neg_add10_min(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x + 10 for x in r]\n    return min(r) if r else 0", "tests": "assert op_neg_add10_min([1, 2, 3, 4]) == 0\nassert op_neg_add10_min([]) == 0\nassert op_neg_add10_min([-2, -1, 0, 1, 2]) == 8\nassert op_neg_add10_min([5, 5, 5]) == 0\nassert op_neg_add10_min([3, 1, 2]) == 0\nassert op_neg_add10_min([10]) == 0\nassert op_neg_add10_min([2, 4, 6]) == 0\nassert op_neg_add10_min([-7, 12, -7]) == 3"}
{"id": "op_add10_dropfirst_absval", "entry_point": "op_add10_dropfirst_absval", "primitives": ["add10", "dropfirst", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the first element, then take the absolute value of each.", "solution": "def op_add10_dropfirst_absval(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = r[1:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_add10_dropfirst_absval([1, 2, 3, 4]) == [12, 13, 14]\nassert op_add10_dropfirst_absval([]) == []\nassert op_add10_dropfirst_absval([-2, -1, 0, 1, 2]) == [9, 10, 11, 12]\nassert op_add10_dropfirst_absval([5, 5, 5]) == [15, 15]\nassert op_add10_dropfirst_absval([3, 1, 2]) == [11, 12]\nassert op_add10_dropfirst_absval([10]) == []\nassert op_add10_dropfirst_absval([2, 4, 6]) == [14, 16]\nassert op_add10_dropfirst_absval([-7, 12, -7]) == [22, 3]"}
{"id": "op_sortd_dropfirst_padto3", "entry_point": "op_sortd_dropfirst_padto3", "primitives": ["sortd", "dropfirst", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then pad with zeros to at least three elements.", "solution": "def op_sortd_dropfirst_padto3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_sortd_dropfirst_padto3([1, 2, 3, 4]) == [3, 2, 1]\nassert op_sortd_dropfirst_padto3([]) == [0, 0, 0]\nassert op_sortd_dropfirst_padto3([-2, -1, 0, 1, 2]) == [1, 0, -1, -2]\nassert op_sortd_dropfirst_padto3([5, 5, 5]) == [5, 5, 0]\nassert op_sortd_dropfirst_padto3([3, 1, 2]) == [2, 1, 0]\nassert op_sortd_dropfirst_padto3([10]) == [0, 0, 0]\nassert op_sortd_dropfirst_padto3([2, 4, 6]) == [4, 2, 0]\nassert op_sortd_dropfirst_padto3([-7, 12, -7]) == [-7, -7, 0]"}
{"id": "op_clamp10_padto3_prod", "entry_point": "op_clamp10_padto3_prod", "primitives": ["clamp10", "padto3", "prod"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then pad with zeros to at least three elements, then return their product.", "solution": "def op_clamp10_padto3_prod(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return __import__('math').prod(r)", "tests": "assert op_clamp10_padto3_prod([1, 2, 3, 4]) == 24\nassert op_clamp10_padto3_prod([]) == 0\nassert op_clamp10_padto3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_clamp10_padto3_prod([5, 5, 5]) == 125\nassert op_clamp10_padto3_prod([3, 1, 2]) == 6\nassert op_clamp10_padto3_prod([10]) == 0\nassert op_clamp10_padto3_prod([2, 4, 6]) == 48\nassert op_clamp10_padto3_prod([-7, 12, -7]) == 490"}
{"id": "op_sortd_takewhilepos_counteven", "entry_point": "op_sortd_takewhilepos_counteven", "primitives": ["sortd", "takewhilepos", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then return how many values are even.", "solution": "def op_sortd_takewhilepos_counteven(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_sortd_takewhilepos_counteven([1, 2, 3, 4]) == 2\nassert op_sortd_takewhilepos_counteven([]) == 0\nassert op_sortd_takewhilepos_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_sortd_takewhilepos_counteven([5, 5, 5]) == 0\nassert op_sortd_takewhilepos_counteven([3, 1, 2]) == 1\nassert op_sortd_takewhilepos_counteven([10]) == 1\nassert op_sortd_takewhilepos_counteven([2, 4, 6]) == 3\nassert op_sortd_takewhilepos_counteven([-7, 12, -7]) == 1"}
{"id": "op_add10_sortabs_oremptyzero", "entry_point": "op_add10_sortabs_oremptyzero", "primitives": ["add10", "sortabs", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then sort by absolute value, then if empty, use a single zero.", "solution": "def op_add10_sortabs_oremptyzero(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    return r", "tests": "assert op_add10_sortabs_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_add10_sortabs_oremptyzero([]) == [0]\nassert op_add10_sortabs_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 10, 11, 12]\nassert op_add10_sortabs_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_add10_sortabs_oremptyzero([3, 1, 2]) == [11, 12, 13]\nassert op_add10_sortabs_oremptyzero([10]) == [20]\nassert op_add10_sortabs_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_add10_sortabs_oremptyzero([-7, 12, -7]) == [3, 3, 22]"}
{"id": "op_pos_inc_neg", "entry_point": "op_pos_inc_neg", "primitives": ["pos", "inc", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then add one to each, then keep the negative numbers.", "solution": "def op_pos_inc_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x + 1 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_pos_inc_neg([1, 2, 3, 4]) == []\nassert op_pos_inc_neg([]) == []\nassert op_pos_inc_neg([-2, -1, 0, 1, 2]) == []\nassert op_pos_inc_neg([5, 5, 5]) == []\nassert op_pos_inc_neg([3, 1, 2]) == []\nassert op_pos_inc_neg([10]) == []\nassert op_pos_inc_neg([2, 4, 6]) == []\nassert op_pos_inc_neg([-7, 12, -7]) == []"}
{"id": "op_sortd_double_div3", "entry_point": "op_sortd_double_div3", "primitives": ["sortd", "double", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then double each, then keep multiples of three.", "solution": "def op_sortd_double_div3(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_sortd_double_div3([1, 2, 3, 4]) == [6]\nassert op_sortd_double_div3([]) == []\nassert op_sortd_double_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_sortd_double_div3([5, 5, 5]) == []\nassert op_sortd_double_div3([3, 1, 2]) == [6]\nassert op_sortd_double_div3([10]) == []\nassert op_sortd_double_div3([2, 4, 6]) == [12]\nassert op_sortd_double_div3([-7, 12, -7]) == [24]"}
{"id": "op_takewhilepos_absval_square", "entry_point": "op_takewhilepos_absval_square", "primitives": ["takewhilepos", "absval", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then take the absolute value of each, then square each.", "solution": "def op_takewhilepos_absval_square(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [abs(x) for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_takewhilepos_absval_square([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_takewhilepos_absval_square([]) == []\nassert op_takewhilepos_absval_square([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_absval_square([5, 5, 5]) == [25, 25, 25]\nassert op_takewhilepos_absval_square([3, 1, 2]) == [9, 1, 4]\nassert op_takewhilepos_absval_square([10]) == [100]\nassert op_takewhilepos_absval_square([2, 4, 6]) == [4, 16, 36]\nassert op_takewhilepos_absval_square([-7, 12, -7]) == []"}
{"id": "op_ages_beforezero_absval", "entry_point": "op_ages_beforezero_absval", "primitives": ["ages", "beforezero", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep everything before the first zero, then take the absolute value of each.", "solution": "def op_ages_beforezero_absval(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_ages_beforezero_absval([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36, 12]\nassert op_ages_beforezero_absval([]) == []\nassert op_ages_beforezero_absval([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65, 17]\nassert op_ages_beforezero_absval([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_gt5_trimends_div3", "entry_point": "op_gt5_trimends_div3", "primitives": ["gt5", "trimends", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop the first and last elements, then keep multiples of three.", "solution": "def op_gt5_trimends_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_gt5_trimends_div3([1, 2, 3, 4]) == []\nassert op_gt5_trimends_div3([]) == []\nassert op_gt5_trimends_div3([-2, -1, 0, 1, 2]) == []\nassert op_gt5_trimends_div3([5, 5, 5]) == []\nassert op_gt5_trimends_div3([3, 1, 2]) == []\nassert op_gt5_trimends_div3([10]) == []\nassert op_gt5_trimends_div3([2, 4, 6]) == []\nassert op_gt5_trimends_div3([-7, 12, -7]) == []"}
{"id": "op_uniq_absval_negate", "entry_point": "op_uniq_absval_negate", "primitives": ["uniq", "absval", "negate"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then negate each.", "solution": "def op_uniq_absval_negate(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_uniq_absval_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_uniq_absval_negate([]) == []\nassert op_uniq_absval_negate([-2, -1, 0, 1, 2]) == [-2, -1, 0, -1, -2]\nassert op_uniq_absval_negate([5, 5, 5]) == [-5]\nassert op_uniq_absval_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_uniq_absval_negate([10]) == [-10]\nassert op_uniq_absval_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_uniq_absval_negate([-7, 12, -7]) == [-7, -12]"}
{"id": "op_dropzeros_neg_issorted", "entry_point": "op_dropzeros_neg_issorted", "primitives": ["dropzeros", "neg", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep the negative numbers, then return whether the list is sorted ascending.", "solution": "def op_dropzeros_neg_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x for x in r if x < 0]\n    return r == sorted(r)", "tests": "assert op_dropzeros_neg_issorted([1, 2, 3, 4]) == True\nassert op_dropzeros_neg_issorted([]) == True\nassert op_dropzeros_neg_issorted([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_neg_issorted([5, 5, 5]) == True\nassert op_dropzeros_neg_issorted([3, 1, 2]) == True\nassert op_dropzeros_neg_issorted([10]) == True\nassert op_dropzeros_neg_issorted([2, 4, 6]) == True\nassert op_dropzeros_neg_issorted([-7, 12, -7]) == True"}
{"id": "op_dec_negate_max", "entry_point": "op_dec_negate_max", "primitives": ["dec", "negate", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then negate each, then return the maximum (0 if empty).", "solution": "def op_dec_negate_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [-x for x in r]\n    return max(r) if r else 0", "tests": "assert op_dec_negate_max([1, 2, 3, 4]) == 0\nassert op_dec_negate_max([]) == 0\nassert op_dec_negate_max([-2, -1, 0, 1, 2]) == 3\nassert op_dec_negate_max([5, 5, 5]) == -4\nassert op_dec_negate_max([3, 1, 2]) == 0\nassert op_dec_negate_max([10]) == -9\nassert op_dec_negate_max([2, 4, 6]) == -1\nassert op_dec_negate_max([-7, 12, -7]) == 8"}
{"id": "op_padto3_beforezero_odds", "entry_point": "op_padto3_beforezero_odds", "primitives": ["padto3", "beforezero", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep everything before the first zero, then keep the odd numbers.", "solution": "def op_padto3_beforezero_odds(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_padto3_beforezero_odds([1, 2, 3, 4]) == [1, 3]\nassert op_padto3_beforezero_odds([]) == []\nassert op_padto3_beforezero_odds([-2, -1, 0, 1, 2]) == [-1]\nassert op_padto3_beforezero_odds([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_beforezero_odds([3, 1, 2]) == [3, 1]\nassert op_padto3_beforezero_odds([10]) == []\nassert op_padto3_beforezero_odds([2, 4, 6]) == []\nassert op_padto3_beforezero_odds([-7, 12, -7]) == [-7, -7]"}
{"id": "op_div3_rev_haszero", "entry_point": "op_div3_rev_haszero", "primitives": ["div3", "rev", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then reverse the order, then return whether the list contains a zero.", "solution": "def op_div3_rev_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = list(reversed(r))\n    return 0 in r", "tests": "assert op_div3_rev_haszero([1, 2, 3, 4]) == False\nassert op_div3_rev_haszero([]) == False\nassert op_div3_rev_haszero([-2, -1, 0, 1, 2]) == True\nassert op_div3_rev_haszero([5, 5, 5]) == False\nassert op_div3_rev_haszero([3, 1, 2]) == False\nassert op_div3_rev_haszero([10]) == False\nassert op_div3_rev_haszero([2, 4, 6]) == False\nassert op_div3_rev_haszero([-7, 12, -7]) == False"}
{"id": "op_sortd_takewhilepos_neg", "entry_point": "op_sortd_takewhilepos_neg", "primitives": ["sortd", "takewhilepos", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then keep the negative numbers.", "solution": "def op_sortd_takewhilepos_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_takewhilepos_neg([1, 2, 3, 4]) == []\nassert op_sortd_takewhilepos_neg([]) == []\nassert op_sortd_takewhilepos_neg([-2, -1, 0, 1, 2]) == []\nassert op_sortd_takewhilepos_neg([5, 5, 5]) == []\nassert op_sortd_takewhilepos_neg([3, 1, 2]) == []\nassert op_sortd_takewhilepos_neg([10]) == []\nassert op_sortd_takewhilepos_neg([2, 4, 6]) == []\nassert op_sortd_takewhilepos_neg([-7, 12, -7]) == []"}
{"id": "op_dec_first3_padto3", "entry_point": "op_dec_first3_padto3", "primitives": ["dec", "first3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_dec_first3_padto3(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_dec_first3_padto3([1, 2, 3, 4]) == [0, 1, 2]\nassert op_dec_first3_padto3([]) == [0, 0, 0]\nassert op_dec_first3_padto3([-2, -1, 0, 1, 2]) == [-3, -2, -1]\nassert op_dec_first3_padto3([5, 5, 5]) == [4, 4, 4]\nassert op_dec_first3_padto3([3, 1, 2]) == [2, 0, 1]\nassert op_dec_first3_padto3([10]) == [9, 0, 0]\nassert op_dec_first3_padto3([2, 4, 6]) == [1, 3, 5]\nassert op_dec_first3_padto3([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_absval_sorta_counteven", "entry_point": "op_absval_sorta_counteven", "primitives": ["absval", "sorta", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then sort ascending, then return how many values are even.", "solution": "def op_absval_sorta_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = sorted(r)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_sorta_counteven([1, 2, 3, 4]) == 2\nassert op_absval_sorta_counteven([]) == 0\nassert op_absval_sorta_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_absval_sorta_counteven([5, 5, 5]) == 0\nassert op_absval_sorta_counteven([3, 1, 2]) == 1\nassert op_absval_sorta_counteven([10]) == 1\nassert op_absval_sorta_counteven([2, 4, 6]) == 3\nassert op_absval_sorta_counteven([-7, 12, -7]) == 1"}
{"id": "op_double_dropwhileneg_min", "entry_point": "op_double_dropwhileneg_min", "primitives": ["double", "dropwhileneg", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the leading negative values, then return the minimum (0 if empty).", "solution": "def op_double_dropwhileneg_min(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return min(r) if r else 0", "tests": "assert op_double_dropwhileneg_min([1, 2, 3, 4]) == 2\nassert op_double_dropwhileneg_min([]) == 0\nassert op_double_dropwhileneg_min([-2, -1, 0, 1, 2]) == 0\nassert op_double_dropwhileneg_min([5, 5, 5]) == 10\nassert op_double_dropwhileneg_min([3, 1, 2]) == 2\nassert op_double_dropwhileneg_min([10]) == 20\nassert op_double_dropwhileneg_min([2, 4, 6]) == 4\nassert op_double_dropwhileneg_min([-7, 12, -7]) == -14"}
{"id": "op_prefixup_upper_anyempty", "entry_point": "op_prefixup_upper_anyempty", "primitives": ["prefixup", "upper", "anyempty"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; prefix each with a hash, then uppercase each string, then return whether any string is empty.", "solution": "def op_prefixup_upper_anyempty(xs):\n    r = list(xs)\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    return any(s == '' for s in r)", "tests": "assert op_prefixup_upper_anyempty(['Hello', 'world']) == False\nassert op_prefixup_upper_anyempty([]) == False\nassert op_prefixup_upper_anyempty(['  a ', '', 'BC', 'bc']) == False\nassert op_prefixup_upper_anyempty(['one', 'one', 'Two']) == False\nassert op_prefixup_upper_anyempty(['x']) == False\nassert op_prefixup_upper_anyempty(['abc', 'de', '']) == False"}
{"id": "op_sortabs_evens_dropfirst", "entry_point": "op_sortabs_evens_dropfirst", "primitives": ["sortabs", "evens", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the even numbers, then drop the first element.", "solution": "def op_sortabs_evens_dropfirst(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x % 2 == 0]\n    r = r[1:]\n    return r", "tests": "assert op_sortabs_evens_dropfirst([1, 2, 3, 4]) == [4]\nassert op_sortabs_evens_dropfirst([]) == []\nassert op_sortabs_evens_dropfirst([-2, -1, 0, 1, 2]) == [-2, 2]\nassert op_sortabs_evens_dropfirst([5, 5, 5]) == []\nassert op_sortabs_evens_dropfirst([3, 1, 2]) == []\nassert op_sortabs_evens_dropfirst([10]) == []\nassert op_sortabs_evens_dropfirst([2, 4, 6]) == [4, 6]\nassert op_sortabs_evens_dropfirst([-7, 12, -7]) == []"}
{"id": "op_odds_padto3_counteven", "entry_point": "op_odds_padto3_counteven", "primitives": ["odds", "padto3", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then pad with zeros to at least three elements, then return how many values are even.", "solution": "def op_odds_padto3_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_odds_padto3_counteven([1, 2, 3, 4]) == 1\nassert op_odds_padto3_counteven([]) == 3\nassert op_odds_padto3_counteven([-2, -1, 0, 1, 2]) == 1\nassert op_odds_padto3_counteven([5, 5, 5]) == 0\nassert op_odds_padto3_counteven([3, 1, 2]) == 1\nassert op_odds_padto3_counteven([10]) == 3\nassert op_odds_padto3_counteven([2, 4, 6]) == 3\nassert op_odds_padto3_counteven([-7, 12, -7]) == 1"}
{"id": "op_ages_square_sortd", "entry_point": "op_ages_square_sortd", "primitives": ["ages", "square", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then sort descending.", "solution": "def op_ages_square_sortd(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_ages_square_sortd([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1296, 144]\nassert op_ages_square_sortd([]) == []\nassert op_ages_square_sortd([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [4225, 324, 289]\nassert op_ages_square_sortd([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_gt5_odds_neg", "entry_point": "op_gt5_odds_neg", "primitives": ["gt5", "odds", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep the odd numbers, then keep the negative numbers.", "solution": "def op_gt5_odds_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x for x in r if x % 2 != 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_gt5_odds_neg([1, 2, 3, 4]) == []\nassert op_gt5_odds_neg([]) == []\nassert op_gt5_odds_neg([-2, -1, 0, 1, 2]) == []\nassert op_gt5_odds_neg([5, 5, 5]) == []\nassert op_gt5_odds_neg([3, 1, 2]) == []\nassert op_gt5_odds_neg([10]) == []\nassert op_gt5_odds_neg([2, 4, 6]) == []\nassert op_gt5_odds_neg([-7, 12, -7]) == []"}
{"id": "op_odds_square_haszero", "entry_point": "op_odds_square_haszero", "primitives": ["odds", "square", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then square each, then return whether the list contains a zero.", "solution": "def op_odds_square_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x * x for x in r]\n    return 0 in r", "tests": "assert op_odds_square_haszero([1, 2, 3, 4]) == False\nassert op_odds_square_haszero([]) == False\nassert op_odds_square_haszero([-2, -1, 0, 1, 2]) == False\nassert op_odds_square_haszero([5, 5, 5]) == False\nassert op_odds_square_haszero([3, 1, 2]) == False\nassert op_odds_square_haszero([10]) == False\nassert op_odds_square_haszero([2, 4, 6]) == False\nassert op_odds_square_haszero([-7, 12, -7]) == False"}
{"id": "op_uniq_absval_gt5", "entry_point": "op_uniq_absval_gt5", "primitives": ["uniq", "absval", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then take the absolute value of each, then keep values greater than five.", "solution": "def op_uniq_absval_gt5(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_uniq_absval_gt5([1, 2, 3, 4]) == []\nassert op_uniq_absval_gt5([]) == []\nassert op_uniq_absval_gt5([-2, -1, 0, 1, 2]) == []\nassert op_uniq_absval_gt5([5, 5, 5]) == []\nassert op_uniq_absval_gt5([3, 1, 2]) == []\nassert op_uniq_absval_gt5([10]) == [10]\nassert op_uniq_absval_gt5([2, 4, 6]) == [6]\nassert op_uniq_absval_gt5([-7, 12, -7]) == [7, 12]"}
{"id": "op_add10_uniq_dec", "entry_point": "op_add10_uniq_dec", "primitives": ["add10", "uniq", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop duplicates keeping first occurrence, then subtract one from each.", "solution": "def op_add10_uniq_dec(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_add10_uniq_dec([1, 2, 3, 4]) == [10, 11, 12, 13]\nassert op_add10_uniq_dec([]) == []\nassert op_add10_uniq_dec([-2, -1, 0, 1, 2]) == [7, 8, 9, 10, 11]\nassert op_add10_uniq_dec([5, 5, 5]) == [14]\nassert op_add10_uniq_dec([3, 1, 2]) == [12, 10, 11]\nassert op_add10_uniq_dec([10]) == [19]\nassert op_add10_uniq_dec([2, 4, 6]) == [11, 13, 15]\nassert op_add10_uniq_dec([-7, 12, -7]) == [2, 21]"}
{"id": "op_oremptyzero_square_neg", "entry_point": "op_oremptyzero_square_neg", "primitives": ["oremptyzero", "square", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then keep the negative numbers.", "solution": "def op_oremptyzero_square_neg(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_oremptyzero_square_neg([1, 2, 3, 4]) == []\nassert op_oremptyzero_square_neg([]) == []\nassert op_oremptyzero_square_neg([-2, -1, 0, 1, 2]) == []\nassert op_oremptyzero_square_neg([5, 5, 5]) == []\nassert op_oremptyzero_square_neg([3, 1, 2]) == []\nassert op_oremptyzero_square_neg([10]) == []\nassert op_oremptyzero_square_neg([2, 4, 6]) == []\nassert op_oremptyzero_square_neg([-7, 12, -7]) == []"}
{"id": "op_trimends_rev_add10", "entry_point": "op_trimends_rev_add10", "primitives": ["trimends", "rev", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then reverse the order, then add ten to each.", "solution": "def op_trimends_rev_add10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(reversed(r))\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_trimends_rev_add10([1, 2, 3, 4]) == [13, 12]\nassert op_trimends_rev_add10([]) == []\nassert op_trimends_rev_add10([-2, -1, 0, 1, 2]) == [11, 10, 9]\nassert op_trimends_rev_add10([5, 5, 5]) == [15]\nassert op_trimends_rev_add10([3, 1, 2]) == [11]\nassert op_trimends_rev_add10([10]) == []\nassert op_trimends_rev_add10([2, 4, 6]) == [14]\nassert op_trimends_rev_add10([-7, 12, -7]) == [22]"}
{"id": "op_padto3_pos_gt5", "entry_point": "op_padto3_pos_gt5", "primitives": ["padto3", "pos", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then keep the positive numbers, then keep values greater than five.", "solution": "def op_padto3_pos_gt5(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_padto3_pos_gt5([1, 2, 3, 4]) == []\nassert op_padto3_pos_gt5([]) == []\nassert op_padto3_pos_gt5([-2, -1, 0, 1, 2]) == []\nassert op_padto3_pos_gt5([5, 5, 5]) == []\nassert op_padto3_pos_gt5([3, 1, 2]) == []\nassert op_padto3_pos_gt5([10]) == [10]\nassert op_padto3_pos_gt5([2, 4, 6]) == [6]\nassert op_padto3_pos_gt5([-7, 12, -7]) == [12]"}
{"id": "op_trimends_uniq_square", "entry_point": "op_trimends_uniq_square", "primitives": ["trimends", "uniq", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then square each.", "solution": "def op_trimends_uniq_square(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = [x * x for x in r]\n    return r", "tests": "assert op_trimends_uniq_square([1, 2, 3, 4]) == [4, 9]\nassert op_trimends_uniq_square([]) == []\nassert op_trimends_uniq_square([-2, -1, 0, 1, 2]) == [1, 0, 1]\nassert op_trimends_uniq_square([5, 5, 5]) == [25]\nassert op_trimends_uniq_square([3, 1, 2]) == [1]\nassert op_trimends_uniq_square([10]) == []\nassert op_trimends_uniq_square([2, 4, 6]) == [16]\nassert op_trimends_uniq_square([-7, 12, -7]) == [144]"}
{"id": "op_absval_gt5_trimends", "entry_point": "op_absval_gt5_trimends", "primitives": ["absval", "gt5", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep values greater than five, then drop the first and last elements.", "solution": "def op_absval_gt5_trimends(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 5]\n    r = r[1:-1]\n    return r", "tests": "assert op_absval_gt5_trimends([1, 2, 3, 4]) == []\nassert op_absval_gt5_trimends([]) == []\nassert op_absval_gt5_trimends([-2, -1, 0, 1, 2]) == []\nassert op_absval_gt5_trimends([5, 5, 5]) == []\nassert op_absval_gt5_trimends([3, 1, 2]) == []\nassert op_absval_gt5_trimends([10]) == []\nassert op_absval_gt5_trimends([2, 4, 6]) == []\nassert op_absval_gt5_trimends([-7, 12, -7]) == [12]"}
{"id": "op_sortabs_takewhilepos_max", "entry_point": "op_sortabs_takewhilepos_max", "primitives": ["sortabs", "takewhilepos", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take values while they are positive, then return the maximum (0 if empty).", "solution": "def op_sortabs_takewhilepos_max(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return max(r) if r else 0", "tests": "assert op_sortabs_takewhilepos_max([1, 2, 3, 4]) == 4\nassert op_sortabs_takewhilepos_max([]) == 0\nassert op_sortabs_takewhilepos_max([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_takewhilepos_max([5, 5, 5]) == 5\nassert op_sortabs_takewhilepos_max([3, 1, 2]) == 3\nassert op_sortabs_takewhilepos_max([10]) == 10\nassert op_sortabs_takewhilepos_max([2, 4, 6]) == 6\nassert op_sortabs_takewhilepos_max([-7, 12, -7]) == 0"}
{"id": "op_sortd_add10_double", "entry_point": "op_sortd_add10_double", "primitives": ["sortd", "add10", "double"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then add ten to each, then double each.", "solution": "def op_sortd_add10_double(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x + 10 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_sortd_add10_double([1, 2, 3, 4]) == [28, 26, 24, 22]\nassert op_sortd_add10_double([]) == []\nassert op_sortd_add10_double([-2, -1, 0, 1, 2]) == [24, 22, 20, 18, 16]\nassert op_sortd_add10_double([5, 5, 5]) == [30, 30, 30]\nassert op_sortd_add10_double([3, 1, 2]) == [26, 24, 22]\nassert op_sortd_add10_double([10]) == [40]\nassert op_sortd_add10_double([2, 4, 6]) == [32, 28, 24]\nassert op_sortd_add10_double([-7, 12, -7]) == [44, 6, 6]"}
{"id": "op_square_uniq_dropwhileneg", "entry_point": "op_square_uniq_dropwhileneg", "primitives": ["square", "uniq", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop duplicates keeping first occurrence, then drop the leading negative values.", "solution": "def op_square_uniq_dropwhileneg(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_square_uniq_dropwhileneg([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_uniq_dropwhileneg([]) == []\nassert op_square_uniq_dropwhileneg([-2, -1, 0, 1, 2]) == [4, 1, 0]\nassert op_square_uniq_dropwhileneg([5, 5, 5]) == [25]\nassert op_square_uniq_dropwhileneg([3, 1, 2]) == [9, 1, 4]\nassert op_square_uniq_dropwhileneg([10]) == [100]\nassert op_square_uniq_dropwhileneg([2, 4, 6]) == [4, 16, 36]\nassert op_square_uniq_dropwhileneg([-7, 12, -7]) == [49, 144]"}
{"id": "op_clamp10_negate_odds", "entry_point": "op_clamp10_negate_odds", "primitives": ["clamp10", "negate", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then keep the odd numbers.", "solution": "def op_clamp10_negate_odds(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_clamp10_negate_odds([1, 2, 3, 4]) == [-1, -3]\nassert op_clamp10_negate_odds([]) == []\nassert op_clamp10_negate_odds([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_clamp10_negate_odds([5, 5, 5]) == [-5, -5, -5]\nassert op_clamp10_negate_odds([3, 1, 2]) == [-3, -1]\nassert op_clamp10_negate_odds([10]) == []\nassert op_clamp10_negate_odds([2, 4, 6]) == []\nassert op_clamp10_negate_odds([-7, 12, -7]) == [7, 7]"}
{"id": "op_beforezero_dec_dropzeros", "entry_point": "op_beforezero_dec_dropzeros", "primitives": ["beforezero", "dec", "dropzeros"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then subtract one from each, then drop the zeros.", "solution": "def op_beforezero_dec_dropzeros(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x - 1 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_beforezero_dec_dropzeros([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_dec_dropzeros([]) == []\nassert op_beforezero_dec_dropzeros([-2, -1, 0, 1, 2]) == [-3, -2]\nassert op_beforezero_dec_dropzeros([5, 5, 5]) == [4, 4, 4]\nassert op_beforezero_dec_dropzeros([3, 1, 2]) == [2, 1]\nassert op_beforezero_dec_dropzeros([10]) == [9]\nassert op_beforezero_dec_dropzeros([2, 4, 6]) == [1, 3, 5]\nassert op_beforezero_dec_dropzeros([-7, 12, -7]) == [-8, 11, -8]"}
{"id": "op_inc_oremptyzero_pos", "entry_point": "op_inc_oremptyzero_pos", "primitives": ["inc", "oremptyzero", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then keep the positive numbers.", "solution": "def op_inc_oremptyzero_pos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_inc_oremptyzero_pos([1, 2, 3, 4]) == [2, 3, 4, 5]\nassert op_inc_oremptyzero_pos([]) == []\nassert op_inc_oremptyzero_pos([-2, -1, 0, 1, 2]) == [1, 2, 3]\nassert op_inc_oremptyzero_pos([5, 5, 5]) == [6, 6, 6]\nassert op_inc_oremptyzero_pos([3, 1, 2]) == [4, 2, 3]\nassert op_inc_oremptyzero_pos([10]) == [11]\nassert op_inc_oremptyzero_pos([2, 4, 6]) == [3, 5, 7]\nassert op_inc_oremptyzero_pos([-7, 12, -7]) == [13]"}
{"id": "op_uniq_clamp10_counteven", "entry_point": "op_uniq_clamp10_counteven", "primitives": ["uniq", "clamp10", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cap each value at 10, then return how many values are even.", "solution": "def op_uniq_clamp10_counteven(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [min(x, 10) for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_uniq_clamp10_counteven([1, 2, 3, 4]) == 2\nassert op_uniq_clamp10_counteven([]) == 0\nassert op_uniq_clamp10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_uniq_clamp10_counteven([5, 5, 5]) == 0\nassert op_uniq_clamp10_counteven([3, 1, 2]) == 1\nassert op_uniq_clamp10_counteven([10]) == 1\nassert op_uniq_clamp10_counteven([2, 4, 6]) == 3\nassert op_uniq_clamp10_counteven([-7, 12, -7]) == 1"}
{"id": "op_trimends_beforezero_clamp10", "entry_point": "op_trimends_beforezero_clamp10", "primitives": ["trimends", "beforezero", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_trimends_beforezero_clamp10(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_trimends_beforezero_clamp10([1, 2, 3, 4]) == [2, 3]\nassert op_trimends_beforezero_clamp10([]) == []\nassert op_trimends_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_beforezero_clamp10([5, 5, 5]) == [5]\nassert op_trimends_beforezero_clamp10([3, 1, 2]) == [1]\nassert op_trimends_beforezero_clamp10([10]) == []\nassert op_trimends_beforezero_clamp10([2, 4, 6]) == [4]\nassert op_trimends_beforezero_clamp10([-7, 12, -7]) == [10]"}
{"id": "op_absval_dropwhileneg_counteven", "entry_point": "op_absval_dropwhileneg_counteven", "primitives": ["absval", "dropwhileneg", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then drop the leading negative values, then return how many values are even.", "solution": "def op_absval_dropwhileneg_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_dropwhileneg_counteven([1, 2, 3, 4]) == 2\nassert op_absval_dropwhileneg_counteven([]) == 0\nassert op_absval_dropwhileneg_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_absval_dropwhileneg_counteven([5, 5, 5]) == 0\nassert op_absval_dropwhileneg_counteven([3, 1, 2]) == 1\nassert op_absval_dropwhileneg_counteven([10]) == 1\nassert op_absval_dropwhileneg_counteven([2, 4, 6]) == 3\nassert op_absval_dropwhileneg_counteven([-7, 12, -7]) == 1"}
{"id": "op_gt5_padto3_oremptyzero", "entry_point": "op_gt5_padto3_oremptyzero", "primitives": ["gt5", "padto3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then pad with zeros to at least three elements, then if empty, use a single zero.", "solution": "def op_gt5_padto3_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    return r", "tests": "assert op_gt5_padto3_oremptyzero([1, 2, 3, 4]) == [0, 0, 0]\nassert op_gt5_padto3_oremptyzero([]) == [0, 0, 0]\nassert op_gt5_padto3_oremptyzero([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_oremptyzero([5, 5, 5]) == [0, 0, 0]\nassert op_gt5_padto3_oremptyzero([3, 1, 2]) == [0, 0, 0]\nassert op_gt5_padto3_oremptyzero([10]) == [10, 0, 0]\nassert op_gt5_padto3_oremptyzero([2, 4, 6]) == [6, 0, 0]\nassert op_gt5_padto3_oremptyzero([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_div3_sortabs_alldistinct", "entry_point": "op_div3_sortabs_alldistinct", "primitives": ["div3", "sortabs", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value, then return whether all values are distinct.", "solution": "def op_div3_sortabs_alldistinct(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return len(r) == len(set(r))", "tests": "assert op_div3_sortabs_alldistinct([1, 2, 3, 4]) == True\nassert op_div3_sortabs_alldistinct([]) == True\nassert op_div3_sortabs_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_div3_sortabs_alldistinct([5, 5, 5]) == True\nassert op_div3_sortabs_alldistinct([3, 1, 2]) == True\nassert op_div3_sortabs_alldistinct([10]) == True\nassert op_div3_sortabs_alldistinct([2, 4, 6]) == True\nassert op_div3_sortabs_alldistinct([-7, 12, -7]) == True"}
{"id": "op_pos_beforezero_rev", "entry_point": "op_pos_beforezero_rev", "primitives": ["pos", "beforezero", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then keep everything before the first zero, then reverse the order.", "solution": "def op_pos_beforezero_rev(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = list(reversed(r))\n    return r", "tests": "assert op_pos_beforezero_rev([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_pos_beforezero_rev([]) == []\nassert op_pos_beforezero_rev([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_pos_beforezero_rev([5, 5, 5]) == [5, 5, 5]\nassert op_pos_beforezero_rev([3, 1, 2]) == [2, 1, 3]\nassert op_pos_beforezero_rev([10]) == [10]\nassert op_pos_beforezero_rev([2, 4, 6]) == [6, 4, 2]\nassert op_pos_beforezero_rev([-7, 12, -7]) == [12]"}
{"id": "op_sortd_pos_uniq", "entry_point": "op_sortd_pos_uniq", "primitives": ["sortd", "pos", "uniq"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep the positive numbers, then drop duplicates keeping first occurrence.", "solution": "def op_sortd_pos_uniq(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x for x in r if x > 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_sortd_pos_uniq([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_sortd_pos_uniq([]) == []\nassert op_sortd_pos_uniq([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_sortd_pos_uniq([5, 5, 5]) == [5]\nassert op_sortd_pos_uniq([3, 1, 2]) == [3, 2, 1]\nassert op_sortd_pos_uniq([10]) == [10]\nassert op_sortd_pos_uniq([2, 4, 6]) == [6, 4, 2]\nassert op_sortd_pos_uniq([-7, 12, -7]) == [12]"}
{"id": "op_negate_pos_oremptyzero", "entry_point": "op_negate_pos_oremptyzero", "primitives": ["negate", "pos", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then keep the positive numbers, then if empty, use a single zero.", "solution": "def op_negate_pos_oremptyzero(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x > 0]\n    r = r if r else [0]\n    return r", "tests": "assert op_negate_pos_oremptyzero([1, 2, 3, 4]) == [0]\nassert op_negate_pos_oremptyzero([]) == [0]\nassert op_negate_pos_oremptyzero([-2, -1, 0, 1, 2]) == [2, 1]\nassert op_negate_pos_oremptyzero([5, 5, 5]) == [0]\nassert op_negate_pos_oremptyzero([3, 1, 2]) == [0]\nassert op_negate_pos_oremptyzero([10]) == [0]\nassert op_negate_pos_oremptyzero([2, 4, 6]) == [0]\nassert op_negate_pos_oremptyzero([-7, 12, -7]) == [7, 7]"}
{"id": "op_last3_sortd_haszero", "entry_point": "op_last3_sortd_haszero", "primitives": ["last3", "sortd", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then sort descending, then return whether the list contains a zero.", "solution": "def op_last3_sortd_haszero(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = sorted(r, reverse=True)\n    return 0 in r", "tests": "assert op_last3_sortd_haszero([1, 2, 3, 4]) == False\nassert op_last3_sortd_haszero([]) == False\nassert op_last3_sortd_haszero([-2, -1, 0, 1, 2]) == True\nassert op_last3_sortd_haszero([5, 5, 5]) == False\nassert op_last3_sortd_haszero([3, 1, 2]) == False\nassert op_last3_sortd_haszero([10]) == False\nassert op_last3_sortd_haszero([2, 4, 6]) == False\nassert op_last3_sortd_haszero([-7, 12, -7]) == False"}
{"id": "op_first3_sortd_counteven", "entry_point": "op_first3_sortd_counteven", "primitives": ["first3", "sortd", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then sort descending, then return how many values are even.", "solution": "def op_first3_sortd_counteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = sorted(r, reverse=True)\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_first3_sortd_counteven([1, 2, 3, 4]) == 1\nassert op_first3_sortd_counteven([]) == 0\nassert op_first3_sortd_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_first3_sortd_counteven([5, 5, 5]) == 0\nassert op_first3_sortd_counteven([3, 1, 2]) == 1\nassert op_first3_sortd_counteven([10]) == 1\nassert op_first3_sortd_counteven([2, 4, 6]) == 3\nassert op_first3_sortd_counteven([-7, 12, -7]) == 1"}
{"id": "op_ages_square_odds", "entry_point": "op_ages_square_odds", "primitives": ["ages", "square", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then square each, then keep the odd numbers.", "solution": "def op_ages_square_odds(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x * x for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_ages_square_odds([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_square_odds([]) == []\nassert op_ages_square_odds([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [4225, 289]\nassert op_ages_square_odds([{'name': 'Fi', 'age': 41}]) == [1681]"}
{"id": "op_uniqs_prefixup_joinc", "entry_point": "op_uniqs_prefixup_joinc", "primitives": ["uniqs", "prefixup", "joinc"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then prefix each with a hash, then join them with commas.", "solution": "def op_uniqs_prefixup_joinc(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = ['#' + s for s in r]\n    return ','.join(r)", "tests": "assert op_uniqs_prefixup_joinc(['Hello', 'world']) == '#Hello,#world'\nassert op_uniqs_prefixup_joinc([]) == ''\nassert op_uniqs_prefixup_joinc(['  a ', '', 'BC', 'bc']) == '#  a ,#,#BC,#bc'\nassert op_uniqs_prefixup_joinc(['one', 'one', 'Two']) == '#one,#Two'\nassert op_uniqs_prefixup_joinc(['x']) == '#x'\nassert op_uniqs_prefixup_joinc(['abc', 'de', '']) == '#abc,#de,#'"}
{"id": "op_oremptyzero_uniq_dropfirst", "entry_point": "op_oremptyzero_uniq_dropfirst", "primitives": ["oremptyzero", "uniq", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop duplicates keeping first occurrence, then drop the first element.", "solution": "def op_oremptyzero_uniq_dropfirst(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return r", "tests": "assert op_oremptyzero_uniq_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_oremptyzero_uniq_dropfirst([]) == []\nassert op_oremptyzero_uniq_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 2]\nassert op_oremptyzero_uniq_dropfirst([5, 5, 5]) == []\nassert op_oremptyzero_uniq_dropfirst([3, 1, 2]) == [1, 2]\nassert op_oremptyzero_uniq_dropfirst([10]) == []\nassert op_oremptyzero_uniq_dropfirst([2, 4, 6]) == [4, 6]\nassert op_oremptyzero_uniq_dropfirst([-7, 12, -7]) == [12]"}
{"id": "op_oremptyzero_dropzeros_sum", "entry_point": "op_oremptyzero_dropzeros_sum", "primitives": ["oremptyzero", "dropzeros", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the zeros, then return their sum.", "solution": "def op_oremptyzero_dropzeros_sum(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x != 0]\n    return sum(r)", "tests": "assert op_oremptyzero_dropzeros_sum([1, 2, 3, 4]) == 10\nassert op_oremptyzero_dropzeros_sum([]) == 0\nassert op_oremptyzero_dropzeros_sum([-2, -1, 0, 1, 2]) == 0\nassert op_oremptyzero_dropzeros_sum([5, 5, 5]) == 15\nassert op_oremptyzero_dropzeros_sum([3, 1, 2]) == 6\nassert op_oremptyzero_dropzeros_sum([10]) == 10\nassert op_oremptyzero_dropzeros_sum([2, 4, 6]) == 12\nassert op_oremptyzero_dropzeros_sum([-7, 12, -7]) == -2"}
{"id": "op_dropfirst_oremptyzero_odds", "entry_point": "op_dropfirst_oremptyzero_odds", "primitives": ["dropfirst", "oremptyzero", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then if empty, use a single zero, then keep the odd numbers.", "solution": "def op_dropfirst_oremptyzero_odds(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r if r else [0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_dropfirst_oremptyzero_odds([1, 2, 3, 4]) == [3]\nassert op_dropfirst_oremptyzero_odds([]) == []\nassert op_dropfirst_oremptyzero_odds([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_dropfirst_oremptyzero_odds([5, 5, 5]) == [5, 5]\nassert op_dropfirst_oremptyzero_odds([3, 1, 2]) == [1]\nassert op_dropfirst_oremptyzero_odds([10]) == []\nassert op_dropfirst_oremptyzero_odds([2, 4, 6]) == []\nassert op_dropfirst_oremptyzero_odds([-7, 12, -7]) == [-7]"}
{"id": "op_takewhilepos_trimends_padto3", "entry_point": "op_takewhilepos_trimends_padto3", "primitives": ["takewhilepos", "trimends", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then drop the first and last elements, then pad with zeros to at least three elements.", "solution": "def op_takewhilepos_trimends_padto3(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:-1]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_takewhilepos_trimends_padto3([1, 2, 3, 4]) == [2, 3, 0]\nassert op_takewhilepos_trimends_padto3([]) == [0, 0, 0]\nassert op_takewhilepos_trimends_padto3([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_trimends_padto3([5, 5, 5]) == [5, 0, 0]\nassert op_takewhilepos_trimends_padto3([3, 1, 2]) == [1, 0, 0]\nassert op_takewhilepos_trimends_padto3([10]) == [0, 0, 0]\nassert op_takewhilepos_trimends_padto3([2, 4, 6]) == [4, 0, 0]\nassert op_takewhilepos_trimends_padto3([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_add10_inc_counteven", "entry_point": "op_add10_inc_counteven", "primitives": ["add10", "inc", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then add one to each, then return how many values are even.", "solution": "def op_add10_inc_counteven(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x + 1 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_add10_inc_counteven([1, 2, 3, 4]) == 2\nassert op_add10_inc_counteven([]) == 0\nassert op_add10_inc_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_add10_inc_counteven([5, 5, 5]) == 3\nassert op_add10_inc_counteven([3, 1, 2]) == 2\nassert op_add10_inc_counteven([10]) == 0\nassert op_add10_inc_counteven([2, 4, 6]) == 0\nassert op_add10_inc_counteven([-7, 12, -7]) == 2"}
{"id": "op_div3_clamp10_dec", "entry_point": "op_div3_clamp10_dec", "primitives": ["div3", "clamp10", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cap each value at 10, then subtract one from each.", "solution": "def op_div3_clamp10_dec(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_div3_clamp10_dec([1, 2, 3, 4]) == [2]\nassert op_div3_clamp10_dec([]) == []\nassert op_div3_clamp10_dec([-2, -1, 0, 1, 2]) == [-1]\nassert op_div3_clamp10_dec([5, 5, 5]) == []\nassert op_div3_clamp10_dec([3, 1, 2]) == [2]\nassert op_div3_clamp10_dec([10]) == []\nassert op_div3_clamp10_dec([2, 4, 6]) == [5]\nassert op_div3_clamp10_dec([-7, 12, -7]) == [9]"}
{"id": "op_add10_square_padto3", "entry_point": "op_add10_square_padto3", "primitives": ["add10", "square", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; add ten to each, then square each, then pad with zeros to at least three elements.", "solution": "def op_add10_square_padto3(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x * x for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_add10_square_padto3([1, 2, 3, 4]) == [121, 144, 169, 196]\nassert op_add10_square_padto3([]) == [0, 0, 0]\nassert op_add10_square_padto3([-2, -1, 0, 1, 2]) == [64, 81, 100, 121, 144]\nassert op_add10_square_padto3([5, 5, 5]) == [225, 225, 225]\nassert op_add10_square_padto3([3, 1, 2]) == [169, 121, 144]\nassert op_add10_square_padto3([10]) == [400, 0, 0]\nassert op_add10_square_padto3([2, 4, 6]) == [144, 196, 256]\nassert op_add10_square_padto3([-7, 12, -7]) == [9, 484, 9]"}
{"id": "op_uniq_trimends_alldistinct", "entry_point": "op_uniq_trimends_alldistinct", "primitives": ["uniq", "trimends", "alldistinct"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first and last elements, then return whether all values are distinct.", "solution": "def op_uniq_trimends_alldistinct(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:-1]\n    return len(r) == len(set(r))", "tests": "assert op_uniq_trimends_alldistinct([1, 2, 3, 4]) == True\nassert op_uniq_trimends_alldistinct([]) == True\nassert op_uniq_trimends_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_uniq_trimends_alldistinct([5, 5, 5]) == True\nassert op_uniq_trimends_alldistinct([3, 1, 2]) == True\nassert op_uniq_trimends_alldistinct([10]) == True\nassert op_uniq_trimends_alldistinct([2, 4, 6]) == True\nassert op_uniq_trimends_alldistinct([-7, 12, -7]) == True"}
{"id": "op_nonempty_lower_firstchar", "entry_point": "op_nonempty_lower_firstchar", "primitives": ["nonempty", "lower", "firstchar"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then lowercase each string, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_lower_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.lower() for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_lower_firstchar(['Hello', 'world']) == ['h', 'w']\nassert op_nonempty_lower_firstchar([]) == []\nassert op_nonempty_lower_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'b', 'b']\nassert op_nonempty_lower_firstchar(['one', 'one', 'Two']) == ['o', 'o', 't']\nassert op_nonempty_lower_firstchar(['x']) == ['x']\nassert op_nonempty_lower_firstchar(['abc', 'de', '']) == ['a', 'd']"}
{"id": "op_div3_oremptyzero_sortd", "entry_point": "op_div3_oremptyzero_sortd", "primitives": ["div3", "oremptyzero", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then if empty, use a single zero, then sort descending.", "solution": "def op_div3_oremptyzero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_div3_oremptyzero_sortd([1, 2, 3, 4]) == [3]\nassert op_div3_oremptyzero_sortd([]) == [0]\nassert op_div3_oremptyzero_sortd([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_oremptyzero_sortd([5, 5, 5]) == [0]\nassert op_div3_oremptyzero_sortd([3, 1, 2]) == [3]\nassert op_div3_oremptyzero_sortd([10]) == [0]\nassert op_div3_oremptyzero_sortd([2, 4, 6]) == [6]\nassert op_div3_oremptyzero_sortd([-7, 12, -7]) == [12]"}
{"id": "op_sortd_last3_sum", "entry_point": "op_sortd_last3_sum", "primitives": ["sortd", "last3", "sum"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then keep only the last three, then return their sum.", "solution": "def op_sortd_last3_sum(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[-3:]\n    return sum(r)", "tests": "assert op_sortd_last3_sum([1, 2, 3, 4]) == 6\nassert op_sortd_last3_sum([]) == 0\nassert op_sortd_last3_sum([-2, -1, 0, 1, 2]) == -3\nassert op_sortd_last3_sum([5, 5, 5]) == 15\nassert op_sortd_last3_sum([3, 1, 2]) == 6\nassert op_sortd_last3_sum([10]) == 10\nassert op_sortd_last3_sum([2, 4, 6]) == 12\nassert op_sortd_last3_sum([-7, 12, -7]) == -2"}
{"id": "op_dec_oremptyzero_max", "entry_point": "op_dec_oremptyzero_max", "primitives": ["dec", "oremptyzero", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then return the maximum (0 if empty).", "solution": "def op_dec_oremptyzero_max(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return max(r) if r else 0", "tests": "assert op_dec_oremptyzero_max([1, 2, 3, 4]) == 3\nassert op_dec_oremptyzero_max([]) == 0\nassert op_dec_oremptyzero_max([-2, -1, 0, 1, 2]) == 1\nassert op_dec_oremptyzero_max([5, 5, 5]) == 4\nassert op_dec_oremptyzero_max([3, 1, 2]) == 2\nassert op_dec_oremptyzero_max([10]) == 9\nassert op_dec_oremptyzero_max([2, 4, 6]) == 5\nassert op_dec_oremptyzero_max([-7, 12, -7]) == 11"}
{"id": "op_absval_rev_dec", "entry_point": "op_absval_rev_dec", "primitives": ["absval", "rev", "dec"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then reverse the order, then subtract one from each.", "solution": "def op_absval_rev_dec(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_absval_rev_dec([1, 2, 3, 4]) == [3, 2, 1, 0]\nassert op_absval_rev_dec([]) == []\nassert op_absval_rev_dec([-2, -1, 0, 1, 2]) == [1, 0, -1, 0, 1]\nassert op_absval_rev_dec([5, 5, 5]) == [4, 4, 4]\nassert op_absval_rev_dec([3, 1, 2]) == [1, 0, 2]\nassert op_absval_rev_dec([10]) == [9]\nassert op_absval_rev_dec([2, 4, 6]) == [5, 3, 1]\nassert op_absval_rev_dec([-7, 12, -7]) == [6, 11, 6]"}
{"id": "op_negate_dropzeros_trimends", "entry_point": "op_negate_dropzeros_trimends", "primitives": ["negate", "dropzeros", "trimends"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then drop the zeros, then drop the first and last elements.", "solution": "def op_negate_dropzeros_trimends(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    r = r[1:-1]\n    return r", "tests": "assert op_negate_dropzeros_trimends([1, 2, 3, 4]) == [-2, -3]\nassert op_negate_dropzeros_trimends([]) == []\nassert op_negate_dropzeros_trimends([-2, -1, 0, 1, 2]) == [1, -1]\nassert op_negate_dropzeros_trimends([5, 5, 5]) == [-5]\nassert op_negate_dropzeros_trimends([3, 1, 2]) == [-1]\nassert op_negate_dropzeros_trimends([10]) == []\nassert op_negate_dropzeros_trimends([2, 4, 6]) == [-4]\nassert op_negate_dropzeros_trimends([-7, 12, -7]) == [-12]"}
{"id": "op_evens_sorta_div3", "entry_point": "op_evens_sorta_div3", "primitives": ["evens", "sorta", "div3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then sort ascending, then keep multiples of three.", "solution": "def op_evens_sorta_div3(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r)\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_evens_sorta_div3([1, 2, 3, 4]) == []\nassert op_evens_sorta_div3([]) == []\nassert op_evens_sorta_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_sorta_div3([5, 5, 5]) == []\nassert op_evens_sorta_div3([3, 1, 2]) == []\nassert op_evens_sorta_div3([10]) == []\nassert op_evens_sorta_div3([2, 4, 6]) == [6]\nassert op_evens_sorta_div3([-7, 12, -7]) == [12]"}
{"id": "op_neg_dropwhileneg_odds", "entry_point": "op_neg_dropwhileneg_odds", "primitives": ["neg", "dropwhileneg", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop the leading negative values, then keep the odd numbers.", "solution": "def op_neg_dropwhileneg_odds(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_neg_dropwhileneg_odds([1, 2, 3, 4]) == []\nassert op_neg_dropwhileneg_odds([]) == []\nassert op_neg_dropwhileneg_odds([-2, -1, 0, 1, 2]) == []\nassert op_neg_dropwhileneg_odds([5, 5, 5]) == []\nassert op_neg_dropwhileneg_odds([3, 1, 2]) == []\nassert op_neg_dropwhileneg_odds([10]) == []\nassert op_neg_dropwhileneg_odds([2, 4, 6]) == []\nassert op_neg_dropwhileneg_odds([-7, 12, -7]) == []"}
{"id": "op_uniqs_prefixup_counts", "entry_point": "op_uniqs_prefixup_counts", "primitives": ["uniqs", "prefixup", "counts"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then prefix each with a hash, then return how many strings remain.", "solution": "def op_uniqs_prefixup_counts(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = ['#' + s for s in r]\n    return len(r)", "tests": "assert op_uniqs_prefixup_counts(['Hello', 'world']) == 2\nassert op_uniqs_prefixup_counts([]) == 0\nassert op_uniqs_prefixup_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_uniqs_prefixup_counts(['one', 'one', 'Two']) == 2\nassert op_uniqs_prefixup_counts(['x']) == 1\nassert op_uniqs_prefixup_counts(['abc', 'de', '']) == 3"}
{"id": "op_beforezero_takewhilepos_dropfirst", "entry_point": "op_beforezero_takewhilepos_dropfirst", "primitives": ["beforezero", "takewhilepos", "dropfirst"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then drop the first element.", "solution": "def op_beforezero_takewhilepos_dropfirst(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[1:]\n    return r", "tests": "assert op_beforezero_takewhilepos_dropfirst([1, 2, 3, 4]) == [2, 3, 4]\nassert op_beforezero_takewhilepos_dropfirst([]) == []\nassert op_beforezero_takewhilepos_dropfirst([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_dropfirst([5, 5, 5]) == [5, 5]\nassert op_beforezero_takewhilepos_dropfirst([3, 1, 2]) == [1, 2]\nassert op_beforezero_takewhilepos_dropfirst([10]) == []\nassert op_beforezero_takewhilepos_dropfirst([2, 4, 6]) == [4, 6]\nassert op_beforezero_takewhilepos_dropfirst([-7, 12, -7]) == []"}
{"id": "op_odds_beforezero_haszero", "entry_point": "op_odds_beforezero_haszero", "primitives": ["odds", "beforezero", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then keep everything before the first zero, then return whether the list contains a zero.", "solution": "def op_odds_beforezero_haszero(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return 0 in r", "tests": "assert op_odds_beforezero_haszero([1, 2, 3, 4]) == False\nassert op_odds_beforezero_haszero([]) == False\nassert op_odds_beforezero_haszero([-2, -1, 0, 1, 2]) == False\nassert op_odds_beforezero_haszero([5, 5, 5]) == False\nassert op_odds_beforezero_haszero([3, 1, 2]) == False\nassert op_odds_beforezero_haszero([10]) == False\nassert op_odds_beforezero_haszero([2, 4, 6]) == False\nassert op_odds_beforezero_haszero([-7, 12, -7]) == False"}
{"id": "op_double_uniq_rev", "entry_point": "op_double_uniq_rev", "primitives": ["double", "uniq", "rev"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then reverse the order.", "solution": "def op_double_uniq_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_uniq_rev([1, 2, 3, 4]) == [8, 6, 4, 2]\nassert op_double_uniq_rev([]) == []\nassert op_double_uniq_rev([-2, -1, 0, 1, 2]) == [4, 2, 0, -2, -4]\nassert op_double_uniq_rev([5, 5, 5]) == [10]\nassert op_double_uniq_rev([3, 1, 2]) == [4, 2, 6]\nassert op_double_uniq_rev([10]) == [20]\nassert op_double_uniq_rev([2, 4, 6]) == [12, 8, 4]\nassert op_double_uniq_rev([-7, 12, -7]) == [24, -14]"}
{"id": "op_double_dropfirst_takewhilepos", "entry_point": "op_double_dropfirst_takewhilepos", "primitives": ["double", "dropfirst", "takewhilepos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then drop the first element, then take values while they are positive.", "solution": "def op_double_dropfirst_takewhilepos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[1:]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_double_dropfirst_takewhilepos([1, 2, 3, 4]) == [4, 6, 8]\nassert op_double_dropfirst_takewhilepos([]) == []\nassert op_double_dropfirst_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_double_dropfirst_takewhilepos([5, 5, 5]) == [10, 10]\nassert op_double_dropfirst_takewhilepos([3, 1, 2]) == [2, 4]\nassert op_double_dropfirst_takewhilepos([10]) == []\nassert op_double_dropfirst_takewhilepos([2, 4, 6]) == [8, 12]\nassert op_double_dropfirst_takewhilepos([-7, 12, -7]) == [24]"}
{"id": "op_sortabs_pos_odds", "entry_point": "op_sortabs_pos_odds", "primitives": ["sortabs", "pos", "odds"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep the positive numbers, then keep the odd numbers.", "solution": "def op_sortabs_pos_odds(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortabs_pos_odds([1, 2, 3, 4]) == [1, 3]\nassert op_sortabs_pos_odds([]) == []\nassert op_sortabs_pos_odds([-2, -1, 0, 1, 2]) == [1]\nassert op_sortabs_pos_odds([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_pos_odds([3, 1, 2]) == [1, 3]\nassert op_sortabs_pos_odds([10]) == []\nassert op_sortabs_pos_odds([2, 4, 6]) == []\nassert op_sortabs_pos_odds([-7, 12, -7]) == []"}
{"id": "op_evens_gt5_issorted", "entry_point": "op_evens_gt5_issorted", "primitives": ["evens", "gt5", "issorted"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep values greater than five, then return whether the list is sorted ascending.", "solution": "def op_evens_gt5_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x > 5]\n    return r == sorted(r)", "tests": "assert op_evens_gt5_issorted([1, 2, 3, 4]) == True\nassert op_evens_gt5_issorted([]) == True\nassert op_evens_gt5_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_gt5_issorted([5, 5, 5]) == True\nassert op_evens_gt5_issorted([3, 1, 2]) == True\nassert op_evens_gt5_issorted([10]) == True\nassert op_evens_gt5_issorted([2, 4, 6]) == True\nassert op_evens_gt5_issorted([-7, 12, -7]) == True"}
{"id": "op_double_square_clamp10", "entry_point": "op_double_square_clamp10", "primitives": ["double", "square", "clamp10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then square each, then cap each value at 10.", "solution": "def op_double_square_clamp10(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x * x for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_double_square_clamp10([1, 2, 3, 4]) == [4, 10, 10, 10]\nassert op_double_square_clamp10([]) == []\nassert op_double_square_clamp10([-2, -1, 0, 1, 2]) == [10, 4, 0, 4, 10]\nassert op_double_square_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_double_square_clamp10([3, 1, 2]) == [10, 4, 10]\nassert op_double_square_clamp10([10]) == [10]\nassert op_double_square_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_double_square_clamp10([-7, 12, -7]) == [10, 10, 10]"}
{"id": "op_div3_odds_allpos", "entry_point": "op_div3_odds_allpos", "primitives": ["div3", "odds", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then return whether all values are positive.", "solution": "def op_div3_odds_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return all(x > 0 for x in r)", "tests": "assert op_div3_odds_allpos([1, 2, 3, 4]) == True\nassert op_div3_odds_allpos([]) == True\nassert op_div3_odds_allpos([-2, -1, 0, 1, 2]) == True\nassert op_div3_odds_allpos([5, 5, 5]) == True\nassert op_div3_odds_allpos([3, 1, 2]) == True\nassert op_div3_odds_allpos([10]) == True\nassert op_div3_odds_allpos([2, 4, 6]) == True\nassert op_div3_odds_allpos([-7, 12, -7]) == True"}
{"id": "op_rev_dec_haszero", "entry_point": "op_rev_dec_haszero", "primitives": ["rev", "dec", "haszero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then subtract one from each, then return whether the list contains a zero.", "solution": "def op_rev_dec_haszero(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x - 1 for x in r]\n    return 0 in r", "tests": "assert op_rev_dec_haszero([1, 2, 3, 4]) == True\nassert op_rev_dec_haszero([]) == False\nassert op_rev_dec_haszero([-2, -1, 0, 1, 2]) == True\nassert op_rev_dec_haszero([5, 5, 5]) == False\nassert op_rev_dec_haszero([3, 1, 2]) == True\nassert op_rev_dec_haszero([10]) == False\nassert op_rev_dec_haszero([2, 4, 6]) == False\nassert op_rev_dec_haszero([-7, 12, -7]) == False"}
{"id": "op_double_last3_square", "entry_point": "op_double_last3_square", "primitives": ["double", "last3", "square"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; double each, then keep only the last three, then square each.", "solution": "def op_double_last3_square(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = r[-3:]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_double_last3_square([1, 2, 3, 4]) == [16, 36, 64]\nassert op_double_last3_square([]) == []\nassert op_double_last3_square([-2, -1, 0, 1, 2]) == [0, 4, 16]\nassert op_double_last3_square([5, 5, 5]) == [100, 100, 100]\nassert op_double_last3_square([3, 1, 2]) == [36, 4, 16]\nassert op_double_last3_square([10]) == [400]\nassert op_double_last3_square([2, 4, 6]) == [16, 64, 144]\nassert op_double_last3_square([-7, 12, -7]) == [196, 576, 196]"}
{"id": "op_div3_takewhilepos_len", "entry_point": "op_div3_takewhilepos_len", "primitives": ["div3", "takewhilepos", "len"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then take values while they are positive, then return how many remain.", "solution": "def op_div3_takewhilepos_len(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return len(r)", "tests": "assert op_div3_takewhilepos_len([1, 2, 3, 4]) == 1\nassert op_div3_takewhilepos_len([]) == 0\nassert op_div3_takewhilepos_len([-2, -1, 0, 1, 2]) == 0\nassert op_div3_takewhilepos_len([5, 5, 5]) == 0\nassert op_div3_takewhilepos_len([3, 1, 2]) == 1\nassert op_div3_takewhilepos_len([10]) == 0\nassert op_div3_takewhilepos_len([2, 4, 6]) == 1\nassert op_div3_takewhilepos_len([-7, 12, -7]) == 1"}
{"id": "op_absval_evens_padto3", "entry_point": "op_absval_evens_padto3", "primitives": ["absval", "evens", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the even numbers, then pad with zeros to at least three elements.", "solution": "def op_absval_evens_padto3(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_absval_evens_padto3([1, 2, 3, 4]) == [2, 4, 0]\nassert op_absval_evens_padto3([]) == [0, 0, 0]\nassert op_absval_evens_padto3([-2, -1, 0, 1, 2]) == [2, 0, 2]\nassert op_absval_evens_padto3([5, 5, 5]) == [0, 0, 0]\nassert op_absval_evens_padto3([3, 1, 2]) == [2, 0, 0]\nassert op_absval_evens_padto3([10]) == [10, 0, 0]\nassert op_absval_evens_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_absval_evens_padto3([-7, 12, -7]) == [12, 0, 0]"}
{"id": "op_ages_first3_max", "entry_point": "op_ages_first3_max", "primitives": ["ages", "first3", "max"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then return the maximum (0 if empty).", "solution": "def op_ages_first3_max(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    return max(r) if r else 0", "tests": "assert op_ages_first3_max([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 36\nassert op_ages_first3_max([]) == 0\nassert op_ages_first3_max([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 65\nassert op_ages_first3_max([{'name': 'Fi', 'age': 41}]) == 41"}
{"id": "op_dropfirst_square_pos", "entry_point": "op_dropfirst_square_pos", "primitives": ["dropfirst", "square", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then square each, then keep the positive numbers.", "solution": "def op_dropfirst_square_pos(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * x for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_dropfirst_square_pos([1, 2, 3, 4]) == [4, 9, 16]\nassert op_dropfirst_square_pos([]) == []\nassert op_dropfirst_square_pos([-2, -1, 0, 1, 2]) == [1, 1, 4]\nassert op_dropfirst_square_pos([5, 5, 5]) == [25, 25]\nassert op_dropfirst_square_pos([3, 1, 2]) == [1, 4]\nassert op_dropfirst_square_pos([10]) == []\nassert op_dropfirst_square_pos([2, 4, 6]) == [16, 36]\nassert op_dropfirst_square_pos([-7, 12, -7]) == [144, 49]"}
{"id": "op_dropwhileneg_double_beforezero", "entry_point": "op_dropwhileneg_double_beforezero", "primitives": ["dropwhileneg", "double", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then double each, then keep everything before the first zero.", "solution": "def op_dropwhileneg_double_beforezero(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x * 2 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_dropwhileneg_double_beforezero([1, 2, 3, 4]) == [2, 4, 6, 8]\nassert op_dropwhileneg_double_beforezero([]) == []\nassert op_dropwhileneg_double_beforezero([-2, -1, 0, 1, 2]) == []\nassert op_dropwhileneg_double_beforezero([5, 5, 5]) == [10, 10, 10]\nassert op_dropwhileneg_double_beforezero([3, 1, 2]) == [6, 2, 4]\nassert op_dropwhileneg_double_beforezero([10]) == [20]\nassert op_dropwhileneg_double_beforezero([2, 4, 6]) == [4, 8, 12]\nassert op_dropwhileneg_double_beforezero([-7, 12, -7]) == [24, -14]"}
{"id": "op_dropzeros_add10_oremptyzero", "entry_point": "op_dropzeros_add10_oremptyzero", "primitives": ["dropzeros", "add10", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then if empty, use a single zero.", "solution": "def op_dropzeros_add10_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_add10_oremptyzero([1, 2, 3, 4]) == [11, 12, 13, 14]\nassert op_dropzeros_add10_oremptyzero([]) == [0]\nassert op_dropzeros_add10_oremptyzero([-2, -1, 0, 1, 2]) == [8, 9, 11, 12]\nassert op_dropzeros_add10_oremptyzero([5, 5, 5]) == [15, 15, 15]\nassert op_dropzeros_add10_oremptyzero([3, 1, 2]) == [13, 11, 12]\nassert op_dropzeros_add10_oremptyzero([10]) == [20]\nassert op_dropzeros_add10_oremptyzero([2, 4, 6]) == [12, 14, 16]\nassert op_dropzeros_add10_oremptyzero([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_dropfirst_double_gt5", "entry_point": "op_dropfirst_double_gt5", "primitives": ["dropfirst", "double", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then double each, then keep values greater than five.", "solution": "def op_dropfirst_double_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_double_gt5([1, 2, 3, 4]) == [6, 8]\nassert op_dropfirst_double_gt5([]) == []\nassert op_dropfirst_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_dropfirst_double_gt5([5, 5, 5]) == [10, 10]\nassert op_dropfirst_double_gt5([3, 1, 2]) == []\nassert op_dropfirst_double_gt5([10]) == []\nassert op_dropfirst_double_gt5([2, 4, 6]) == [8, 12]\nassert op_dropfirst_double_gt5([-7, 12, -7]) == [24]"}
{"id": "op_rev_last3_absval", "entry_point": "op_rev_last3_absval", "primitives": ["rev", "last3", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep only the last three, then take the absolute value of each.", "solution": "def op_rev_last3_absval(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_rev_last3_absval([1, 2, 3, 4]) == [3, 2, 1]\nassert op_rev_last3_absval([]) == []\nassert op_rev_last3_absval([-2, -1, 0, 1, 2]) == [0, 1, 2]\nassert op_rev_last3_absval([5, 5, 5]) == [5, 5, 5]\nassert op_rev_last3_absval([3, 1, 2]) == [2, 1, 3]\nassert op_rev_last3_absval([10]) == [10]\nassert op_rev_last3_absval([2, 4, 6]) == [6, 4, 2]\nassert op_rev_last3_absval([-7, 12, -7]) == [7, 12, 7]"}
{"id": "op_div3_beforezero_sortd", "entry_point": "op_div3_beforezero_sortd", "primitives": ["div3", "beforezero", "sortd"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep everything before the first zero, then sort descending.", "solution": "def op_div3_beforezero_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_div3_beforezero_sortd([1, 2, 3, 4]) == [3]\nassert op_div3_beforezero_sortd([]) == []\nassert op_div3_beforezero_sortd([-2, -1, 0, 1, 2]) == []\nassert op_div3_beforezero_sortd([5, 5, 5]) == []\nassert op_div3_beforezero_sortd([3, 1, 2]) == [3]\nassert op_div3_beforezero_sortd([10]) == []\nassert op_div3_beforezero_sortd([2, 4, 6]) == [6]\nassert op_div3_beforezero_sortd([-7, 12, -7]) == [12]"}
{"id": "op_div3_sortabs_firsteven", "entry_point": "op_div3_sortabs_firsteven", "primitives": ["div3", "sortabs", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_div3_sortabs_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_div3_sortabs_firsteven([1, 2, 3, 4]) == 0\nassert op_div3_sortabs_firsteven([]) == 0\nassert op_div3_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_div3_sortabs_firsteven([5, 5, 5]) == 0\nassert op_div3_sortabs_firsteven([3, 1, 2]) == 0\nassert op_div3_sortabs_firsteven([10]) == 0\nassert op_div3_sortabs_firsteven([2, 4, 6]) == 6\nassert op_div3_sortabs_firsteven([-7, 12, -7]) == 12"}
{"id": "op_sortabs_gt5_dropwhileneg", "entry_point": "op_sortabs_gt5_dropwhileneg", "primitives": ["sortabs", "gt5", "dropwhileneg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then keep values greater than five, then drop the leading negative values.", "solution": "def op_sortabs_gt5_dropwhileneg(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x for x in r if x > 5]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_sortabs_gt5_dropwhileneg([1, 2, 3, 4]) == []\nassert op_sortabs_gt5_dropwhileneg([]) == []\nassert op_sortabs_gt5_dropwhileneg([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_gt5_dropwhileneg([5, 5, 5]) == []\nassert op_sortabs_gt5_dropwhileneg([3, 1, 2]) == []\nassert op_sortabs_gt5_dropwhileneg([10]) == [10]\nassert op_sortabs_gt5_dropwhileneg([2, 4, 6]) == [6]\nassert op_sortabs_gt5_dropwhileneg([-7, 12, -7]) == [12]"}
{"id": "op_square_trimends_beforezero", "entry_point": "op_square_trimends_beforezero", "primitives": ["square", "trimends", "beforezero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then drop the first and last elements, then keep everything before the first zero.", "solution": "def op_square_trimends_beforezero(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[1:-1]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_square_trimends_beforezero([1, 2, 3, 4]) == [4, 9]\nassert op_square_trimends_beforezero([]) == []\nassert op_square_trimends_beforezero([-2, -1, 0, 1, 2]) == [1]\nassert op_square_trimends_beforezero([5, 5, 5]) == [25]\nassert op_square_trimends_beforezero([3, 1, 2]) == [1]\nassert op_square_trimends_beforezero([10]) == []\nassert op_square_trimends_beforezero([2, 4, 6]) == [16]\nassert op_square_trimends_beforezero([-7, 12, -7]) == [144]"}
{"id": "op_sortd_trimends_neg", "entry_point": "op_sortd_trimends_neg", "primitives": ["sortd", "trimends", "neg"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first and last elements, then keep the negative numbers.", "solution": "def op_sortd_trimends_neg(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:-1]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_sortd_trimends_neg([1, 2, 3, 4]) == []\nassert op_sortd_trimends_neg([]) == []\nassert op_sortd_trimends_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_sortd_trimends_neg([5, 5, 5]) == []\nassert op_sortd_trimends_neg([3, 1, 2]) == []\nassert op_sortd_trimends_neg([10]) == []\nassert op_sortd_trimends_neg([2, 4, 6]) == []\nassert op_sortd_trimends_neg([-7, 12, -7]) == [-7]"}
{"id": "op_last3_beforezero_add10", "entry_point": "op_last3_beforezero_add10", "primitives": ["last3", "beforezero", "add10"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep everything before the first zero, then add ten to each.", "solution": "def op_last3_beforezero_add10(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_last3_beforezero_add10([1, 2, 3, 4]) == [12, 13, 14]\nassert op_last3_beforezero_add10([]) == []\nassert op_last3_beforezero_add10([-2, -1, 0, 1, 2]) == []\nassert op_last3_beforezero_add10([5, 5, 5]) == [15, 15, 15]\nassert op_last3_beforezero_add10([3, 1, 2]) == [13, 11, 12]\nassert op_last3_beforezero_add10([10]) == [20]\nassert op_last3_beforezero_add10([2, 4, 6]) == [12, 14, 16]\nassert op_last3_beforezero_add10([-7, 12, -7]) == [3, 22, 3]"}
{"id": "op_takewhilepos_negate_gt5", "entry_point": "op_takewhilepos_negate_gt5", "primitives": ["takewhilepos", "negate", "gt5"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then negate each, then keep values greater than five.", "solution": "def op_takewhilepos_negate_gt5(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [-x for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_takewhilepos_negate_gt5([1, 2, 3, 4]) == []\nassert op_takewhilepos_negate_gt5([]) == []\nassert op_takewhilepos_negate_gt5([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_negate_gt5([5, 5, 5]) == []\nassert op_takewhilepos_negate_gt5([3, 1, 2]) == []\nassert op_takewhilepos_negate_gt5([10]) == []\nassert op_takewhilepos_negate_gt5([2, 4, 6]) == []\nassert op_takewhilepos_negate_gt5([-7, 12, -7]) == []"}
{"id": "op_last3_oremptyzero_counteven", "entry_point": "op_last3_oremptyzero_counteven", "primitives": ["last3", "oremptyzero", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then if empty, use a single zero, then return how many values are even.", "solution": "def op_last3_oremptyzero_counteven(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r if r else [0]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_last3_oremptyzero_counteven([1, 2, 3, 4]) == 2\nassert op_last3_oremptyzero_counteven([]) == 1\nassert op_last3_oremptyzero_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_last3_oremptyzero_counteven([5, 5, 5]) == 0\nassert op_last3_oremptyzero_counteven([3, 1, 2]) == 1\nassert op_last3_oremptyzero_counteven([10]) == 1\nassert op_last3_oremptyzero_counteven([2, 4, 6]) == 3\nassert op_last3_oremptyzero_counteven([-7, 12, -7]) == 1"}
{"id": "op_gt5_uniq_counteven", "entry_point": "op_gt5_uniq_counteven", "primitives": ["gt5", "uniq", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then drop duplicates keeping first occurrence, then return how many values are even.", "solution": "def op_gt5_uniq_counteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = list(dict.fromkeys(r))\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_gt5_uniq_counteven([1, 2, 3, 4]) == 0\nassert op_gt5_uniq_counteven([]) == 0\nassert op_gt5_uniq_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_uniq_counteven([5, 5, 5]) == 0\nassert op_gt5_uniq_counteven([3, 1, 2]) == 0\nassert op_gt5_uniq_counteven([10]) == 1\nassert op_gt5_uniq_counteven([2, 4, 6]) == 1\nassert op_gt5_uniq_counteven([-7, 12, -7]) == 1"}
{"id": "op_absval_add10_counteven", "entry_point": "op_absval_add10_counteven", "primitives": ["absval", "add10", "counteven"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then add ten to each, then return how many values are even.", "solution": "def op_absval_add10_counteven(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x + 10 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_absval_add10_counteven([1, 2, 3, 4]) == 2\nassert op_absval_add10_counteven([]) == 0\nassert op_absval_add10_counteven([-2, -1, 0, 1, 2]) == 3\nassert op_absval_add10_counteven([5, 5, 5]) == 0\nassert op_absval_add10_counteven([3, 1, 2]) == 1\nassert op_absval_add10_counteven([10]) == 1\nassert op_absval_add10_counteven([2, 4, 6]) == 3\nassert op_absval_add10_counteven([-7, 12, -7]) == 1"}
{"id": "op_dropfirst_first3_min", "entry_point": "op_dropfirst_first3_min", "primitives": ["dropfirst", "first3", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the first element, then keep only the first three, then return the minimum (0 if empty).", "solution": "def op_dropfirst_first3_min(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[:3]\n    return min(r) if r else 0", "tests": "assert op_dropfirst_first3_min([1, 2, 3, 4]) == 2\nassert op_dropfirst_first3_min([]) == 0\nassert op_dropfirst_first3_min([-2, -1, 0, 1, 2]) == -1\nassert op_dropfirst_first3_min([5, 5, 5]) == 5\nassert op_dropfirst_first3_min([3, 1, 2]) == 1\nassert op_dropfirst_first3_min([10]) == 0\nassert op_dropfirst_first3_min([2, 4, 6]) == 4\nassert op_dropfirst_first3_min([-7, 12, -7]) == -7"}
{"id": "op_square_sorta_pos", "entry_point": "op_square_sorta_pos", "primitives": ["square", "sorta", "pos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then keep the positive numbers.", "solution": "def op_square_sorta_pos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_square_sorta_pos([1, 2, 3, 4]) == [1, 4, 9, 16]\nassert op_square_sorta_pos([]) == []\nassert op_square_sorta_pos([-2, -1, 0, 1, 2]) == [1, 1, 4, 4]\nassert op_square_sorta_pos([5, 5, 5]) == [25, 25, 25]\nassert op_square_sorta_pos([3, 1, 2]) == [1, 4, 9]\nassert op_square_sorta_pos([10]) == [100]\nassert op_square_sorta_pos([2, 4, 6]) == [4, 16, 36]\nassert op_square_sorta_pos([-7, 12, -7]) == [49, 49, 144]"}
{"id": "op_first3_inc_oremptyzero", "entry_point": "op_first3_inc_oremptyzero", "primitives": ["first3", "inc", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then add one to each, then if empty, use a single zero.", "solution": "def op_first3_inc_oremptyzero(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_first3_inc_oremptyzero([1, 2, 3, 4]) == [2, 3, 4]\nassert op_first3_inc_oremptyzero([]) == [0]\nassert op_first3_inc_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_first3_inc_oremptyzero([5, 5, 5]) == [6, 6, 6]\nassert op_first3_inc_oremptyzero([3, 1, 2]) == [4, 2, 3]\nassert op_first3_inc_oremptyzero([10]) == [11]\nassert op_first3_inc_oremptyzero([2, 4, 6]) == [3, 5, 7]\nassert op_first3_inc_oremptyzero([-7, 12, -7]) == [-6, 13, -6]"}
{"id": "op_negate_oremptyzero_min", "entry_point": "op_negate_oremptyzero_min", "primitives": ["negate", "oremptyzero", "min"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; negate each, then if empty, use a single zero, then return the minimum (0 if empty).", "solution": "def op_negate_oremptyzero_min(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r if r else [0]\n    return min(r) if r else 0", "tests": "assert op_negate_oremptyzero_min([1, 2, 3, 4]) == -4\nassert op_negate_oremptyzero_min([]) == 0\nassert op_negate_oremptyzero_min([-2, -1, 0, 1, 2]) == -2\nassert op_negate_oremptyzero_min([5, 5, 5]) == -5\nassert op_negate_oremptyzero_min([3, 1, 2]) == -3\nassert op_negate_oremptyzero_min([10]) == -10\nassert op_negate_oremptyzero_min([2, 4, 6]) == -6\nassert op_negate_oremptyzero_min([-7, 12, -7]) == -12"}
{"id": "op_padto3_oremptyzero_sorta", "entry_point": "op_padto3_oremptyzero_sorta", "primitives": ["padto3", "oremptyzero", "sorta"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then if empty, use a single zero, then sort ascending.", "solution": "def op_padto3_oremptyzero_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = r if r else [0]\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_oremptyzero_sorta([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_padto3_oremptyzero_sorta([]) == [0, 0, 0]\nassert op_padto3_oremptyzero_sorta([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_padto3_oremptyzero_sorta([5, 5, 5]) == [5, 5, 5]\nassert op_padto3_oremptyzero_sorta([3, 1, 2]) == [1, 2, 3]\nassert op_padto3_oremptyzero_sorta([10]) == [0, 0, 10]\nassert op_padto3_oremptyzero_sorta([2, 4, 6]) == [2, 4, 6]\nassert op_padto3_oremptyzero_sorta([-7, 12, -7]) == [-7, -7, 12]"}
{"id": "op_rev_beforezero_max", "entry_point": "op_rev_beforezero_max", "primitives": ["rev", "beforezero", "max"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep everything before the first zero, then return the maximum (0 if empty).", "solution": "def op_rev_beforezero_max(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = r[:r.index(0)] if 0 in r else r\n    return max(r) if r else 0", "tests": "assert op_rev_beforezero_max([1, 2, 3, 4]) == 4\nassert op_rev_beforezero_max([]) == 0\nassert op_rev_beforezero_max([-2, -1, 0, 1, 2]) == 2\nassert op_rev_beforezero_max([5, 5, 5]) == 5\nassert op_rev_beforezero_max([3, 1, 2]) == 3\nassert op_rev_beforezero_max([10]) == 10\nassert op_rev_beforezero_max([2, 4, 6]) == 6\nassert op_rev_beforezero_max([-7, 12, -7]) == 12"}
{"id": "op_ages_sorta_firsteven", "entry_point": "op_ages_sorta_firsteven", "primitives": ["ages", "sorta", "firsteven"], "difficulty": 2, "split": "heldout_comp", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort ascending, then return the first even value (0 if none).", "solution": "def op_ages_sorta_firsteven(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_ages_sorta_firsteven([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 12\nassert op_ages_sorta_firsteven([]) == 0\nassert op_ages_sorta_firsteven([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 18\nassert op_ages_sorta_firsteven([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_dropzeros_first3_oremptyzero", "entry_point": "op_dropzeros_first3_oremptyzero", "primitives": ["dropzeros", "first3", "oremptyzero"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then if empty, use a single zero.", "solution": "def op_dropzeros_first3_oremptyzero(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropzeros_first3_oremptyzero([1, 2, 3, 4]) == [1, 2, 3]\nassert op_dropzeros_first3_oremptyzero([]) == [0]\nassert op_dropzeros_first3_oremptyzero([-2, -1, 0, 1, 2]) == [-2, -1, 1]\nassert op_dropzeros_first3_oremptyzero([5, 5, 5]) == [5, 5, 5]\nassert op_dropzeros_first3_oremptyzero([3, 1, 2]) == [3, 1, 2]\nassert op_dropzeros_first3_oremptyzero([10]) == [10]\nassert op_dropzeros_first3_oremptyzero([2, 4, 6]) == [2, 4, 6]\nassert op_dropzeros_first3_oremptyzero([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_beforezero_first3_padto3", "entry_point": "op_beforezero_first3_padto3", "primitives": ["beforezero", "first3", "padto3"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then keep only the first three, then pad with zeros to at least three elements.", "solution": "def op_beforezero_first3_padto3(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_beforezero_first3_padto3([1, 2, 3, 4]) == [1, 2, 3]\nassert op_beforezero_first3_padto3([]) == [0, 0, 0]\nassert op_beforezero_first3_padto3([-2, -1, 0, 1, 2]) == [-2, -1, 0]\nassert op_beforezero_first3_padto3([5, 5, 5]) == [5, 5, 5]\nassert op_beforezero_first3_padto3([3, 1, 2]) == [3, 1, 2]\nassert op_beforezero_first3_padto3([10]) == [10, 0, 0]\nassert op_beforezero_first3_padto3([2, 4, 6]) == [2, 4, 6]\nassert op_beforezero_first3_padto3([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_sortabs_oremptyzero_absval", "entry_point": "op_sortabs_oremptyzero_absval", "primitives": ["sortabs", "oremptyzero", "absval"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then if empty, use a single zero, then take the absolute value of each.", "solution": "def op_sortabs_oremptyzero_absval(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = r if r else [0]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_sortabs_oremptyzero_absval([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_sortabs_oremptyzero_absval([]) == [0]\nassert op_sortabs_oremptyzero_absval([-2, -1, 0, 1, 2]) == [0, 1, 1, 2, 2]\nassert op_sortabs_oremptyzero_absval([5, 5, 5]) == [5, 5, 5]\nassert op_sortabs_oremptyzero_absval([3, 1, 2]) == [1, 2, 3]\nassert op_sortabs_oremptyzero_absval([10]) == [10]\nassert op_sortabs_oremptyzero_absval([2, 4, 6]) == [2, 4, 6]\nassert op_sortabs_oremptyzero_absval([-7, 12, -7]) == [7, 7, 12]"}
{"id": "op_lower_firstchar_longest", "entry_point": "op_lower_firstchar_longest", "primitives": ["lower", "firstchar", "longest"], "difficulty": 2, "split": "heldout_comp", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then keep the first character of each (dropping empties), then return the longest string (empty if none).", "solution": "def op_lower_firstchar_longest(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[0] for s in r if s]\n    return max(r, key=len) if r else ''", "tests": "assert op_lower_firstchar_longest(['Hello', 'world']) == 'h'\nassert op_lower_firstchar_longest([]) == ''\nassert op_lower_firstchar_longest(['  a ', '', 'BC', 'bc']) == ' '\nassert op_lower_firstchar_longest(['one', 'one', 'Two']) == 'o'\nassert op_lower_firstchar_longest(['x']) == 'x'\nassert op_lower_firstchar_longest(['abc', 'de', '']) == 'a'"}
{"id": "op_square_beforezero_allpos", "entry_point": "op_square_beforezero_allpos", "primitives": ["square", "beforezero", "allpos"], "difficulty": 2, "split": "heldout_comp", "type": "IL", "prompt": "Take a list of integers; square each, then keep everything before the first zero, then return whether all values are positive.", "solution": "def op_square_beforezero_allpos(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return all(x > 0 for x in r)", "tests": "assert op_square_beforezero_allpos([1, 2, 3, 4]) == True\nassert op_square_beforezero_allpos([]) == True\nassert op_square_beforezero_allpos([-2, -1, 0, 1, 2]) == True\nassert op_square_beforezero_allpos([5, 5, 5]) == True\nassert op_square_beforezero_allpos([3, 1, 2]) == True\nassert op_square_beforezero_allpos([10]) == True\nassert op_square_beforezero_allpos([2, 4, 6]) == True\nassert op_square_beforezero_allpos([-7, 12, -7]) == True"}
{"id": "op_square_takewhilepos_halve", "entry_point": "op_square_takewhilepos_halve", "primitives": ["square", "takewhilepos", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; square each, then take values while they are positive, then halve each (integer division).", "solution": "def op_square_takewhilepos_halve(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_square_takewhilepos_halve([1, 2, 3, 4]) == [0, 2, 4, 8]\nassert op_square_takewhilepos_halve([]) == []\nassert op_square_takewhilepos_halve([-2, -1, 0, 1, 2]) == [2, 0]\nassert op_square_takewhilepos_halve([5, 5, 5]) == [12, 12, 12]\nassert op_square_takewhilepos_halve([3, 1, 2]) == [4, 0, 2]\nassert op_square_takewhilepos_halve([10]) == [50]\nassert op_square_takewhilepos_halve([2, 4, 6]) == [2, 8, 18]\nassert op_square_takewhilepos_halve([-7, 12, -7]) == [24, 72, 24]"}
{"id": "op_sortd_absval_cube", "entry_point": "op_sortd_absval_cube", "primitives": ["sortd", "absval", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort descending, then take the absolute value of each, then cube each.", "solution": "def op_sortd_absval_cube(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [abs(x) for x in r]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_sortd_absval_cube([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_sortd_absval_cube([]) == []\nassert op_sortd_absval_cube([-2, -1, 0, 1, 2]) == [8, 1, 0, 1, 8]\nassert op_sortd_absval_cube([5, 5, 5]) == [125, 125, 125]\nassert op_sortd_absval_cube([3, 1, 2]) == [27, 8, 1]\nassert op_sortd_absval_cube([10]) == [1000]\nassert op_sortd_absval_cube([2, 4, 6]) == [216, 64, 8]\nassert op_sortd_absval_cube([-7, 12, -7]) == [1728, 343, 343]"}
{"id": "op_inc_halve_cube", "entry_point": "op_inc_halve_cube", "primitives": ["inc", "halve", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then halve each (integer division), then cube each.", "solution": "def op_inc_halve_cube(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x // 2 for x in r]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_inc_halve_cube([1, 2, 3, 4]) == [1, 1, 8, 8]\nassert op_inc_halve_cube([]) == []\nassert op_inc_halve_cube([-2, -1, 0, 1, 2]) == [-1, 0, 0, 1, 1]\nassert op_inc_halve_cube([5, 5, 5]) == [27, 27, 27]\nassert op_inc_halve_cube([3, 1, 2]) == [8, 1, 1]\nassert op_inc_halve_cube([10]) == [125]\nassert op_inc_halve_cube([2, 4, 6]) == [1, 8, 27]\nassert op_inc_halve_cube([-7, 12, -7]) == [-27, 216, -27]"}
{"id": "op_uniq_cube_dropfirst", "entry_point": "op_uniq_cube_dropfirst", "primitives": ["uniq", "cube", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then cube each, then drop the first element.", "solution": "def op_uniq_cube_dropfirst(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [x ** 3 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_uniq_cube_dropfirst([1, 2, 3, 4]) == [8, 27, 64]\nassert op_uniq_cube_dropfirst([]) == []\nassert op_uniq_cube_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 8]\nassert op_uniq_cube_dropfirst([5, 5, 5]) == []\nassert op_uniq_cube_dropfirst([3, 1, 2]) == [1, 8]\nassert op_uniq_cube_dropfirst([10]) == []\nassert op_uniq_cube_dropfirst([2, 4, 6]) == [64, 216]\nassert op_uniq_cube_dropfirst([-7, 12, -7]) == [1728]"}
{"id": "op_negate_cube_firsteven", "entry_point": "op_negate_cube_firsteven", "primitives": ["negate", "cube", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then cube each, then return the first even value (0 if none).", "solution": "def op_negate_cube_firsteven(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x ** 3 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_negate_cube_firsteven([1, 2, 3, 4]) == -8\nassert op_negate_cube_firsteven([]) == 0\nassert op_negate_cube_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_negate_cube_firsteven([5, 5, 5]) == 0\nassert op_negate_cube_firsteven([3, 1, 2]) == -8\nassert op_negate_cube_firsteven([10]) == -1000\nassert op_negate_cube_firsteven([2, 4, 6]) == -8\nassert op_negate_cube_firsteven([-7, 12, -7]) == -1728"}
{"id": "op_takewhilepos_cube_trimends", "entry_point": "op_takewhilepos_cube_trimends", "primitives": ["takewhilepos", "cube", "trimends"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then cube each, then drop the first and last elements.", "solution": "def op_takewhilepos_cube_trimends(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_takewhilepos_cube_trimends([1, 2, 3, 4]) == [8, 27]\nassert op_takewhilepos_cube_trimends([]) == []\nassert op_takewhilepos_cube_trimends([-2, -1, 0, 1, 2]) == []\nassert op_takewhilepos_cube_trimends([5, 5, 5]) == [125]\nassert op_takewhilepos_cube_trimends([3, 1, 2]) == [1]\nassert op_takewhilepos_cube_trimends([10]) == []\nassert op_takewhilepos_cube_trimends([2, 4, 6]) == [64]\nassert op_takewhilepos_cube_trimends([-7, 12, -7]) == []"}
{"id": "op_rev_pos_halve", "entry_point": "op_rev_pos_halve", "primitives": ["rev", "pos", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; reverse the order, then keep the positive numbers, then halve each (integer division).", "solution": "def op_rev_pos_halve(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x for x in r if x > 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_rev_pos_halve([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_rev_pos_halve([]) == []\nassert op_rev_pos_halve([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_rev_pos_halve([5, 5, 5]) == [2, 2, 2]\nassert op_rev_pos_halve([3, 1, 2]) == [1, 0, 1]\nassert op_rev_pos_halve([10]) == [5]\nassert op_rev_pos_halve([2, 4, 6]) == [3, 2, 1]\nassert op_rev_pos_halve([-7, 12, -7]) == [6]"}
{"id": "op_halve_odds_sum", "entry_point": "op_halve_odds_sum", "primitives": ["halve", "odds", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the odd numbers, then return their sum.", "solution": "def op_halve_odds_sum(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return sum(r)", "tests": "assert op_halve_odds_sum([1, 2, 3, 4]) == 2\nassert op_halve_odds_sum([]) == 0\nassert op_halve_odds_sum([-2, -1, 0, 1, 2]) == -1\nassert op_halve_odds_sum([5, 5, 5]) == 0\nassert op_halve_odds_sum([3, 1, 2]) == 2\nassert op_halve_odds_sum([10]) == 5\nassert op_halve_odds_sum([2, 4, 6]) == 4\nassert op_halve_odds_sum([-7, 12, -7]) == 0"}
{"id": "op_names_title_strip", "entry_point": "op_names_title_strip", "primitives": ["names", "title", "strip"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then title-case each string, then trim whitespace from each.", "solution": "def op_names_title_strip(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.title() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_names_title_strip([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_title_strip([]) == []\nassert op_names_title_strip([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_title_strip([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_add10_halve_sum", "entry_point": "op_add10_halve_sum", "primitives": ["add10", "halve", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add ten to each, then halve each (integer division), then return their sum.", "solution": "def op_add10_halve_sum(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x // 2 for x in r]\n    return sum(r)", "tests": "assert op_add10_halve_sum([1, 2, 3, 4]) == 24\nassert op_add10_halve_sum([]) == 0\nassert op_add10_halve_sum([-2, -1, 0, 1, 2]) == 24\nassert op_add10_halve_sum([5, 5, 5]) == 21\nassert op_add10_halve_sum([3, 1, 2]) == 17\nassert op_add10_halve_sum([10]) == 10\nassert op_add10_halve_sum([2, 4, 6]) == 21\nassert op_add10_halve_sum([-7, 12, -7]) == 13"}
{"id": "op_revstr_uniqs_joinc", "entry_point": "op_revstr_uniqs_joinc", "primitives": ["revstr", "uniqs", "joinc"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then drop duplicate strings keeping the first, then join them with commas.", "solution": "def op_revstr_uniqs_joinc(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = list(dict.fromkeys(r))\n    return ','.join(r)", "tests": "assert op_revstr_uniqs_joinc(['Hello', 'world']) == 'olleH,dlrow'\nassert op_revstr_uniqs_joinc([]) == ''\nassert op_revstr_uniqs_joinc(['  a ', '', 'BC', 'bc']) == ' a  ,,CB,cb'\nassert op_revstr_uniqs_joinc(['one', 'one', 'Two']) == 'eno,owT'\nassert op_revstr_uniqs_joinc(['x']) == 'x'\nassert op_revstr_uniqs_joinc(['abc', 'de', '']) == 'cba,ed,'"}
{"id": "op_sortlen_title_revstr", "entry_point": "op_sortlen_title_revstr", "primitives": ["sortlen", "title", "revstr"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; sort by length, shortest first, then title-case each string, then reverse each string.", "solution": "def op_sortlen_title_revstr(xs):\n    r = list(xs)\n    r = sorted(r, key=len)\n    r = [s.title() for s in r]\n    r = [s[::-1] for s in r]\n    return r", "tests": "assert op_sortlen_title_revstr(['Hello', 'world']) == ['olleH', 'dlroW']\nassert op_sortlen_title_revstr([]) == []\nassert op_sortlen_title_revstr(['  a ', '', 'BC', 'bc']) == ['', 'cB', 'cB', ' A  ']\nassert op_sortlen_title_revstr(['one', 'one', 'Two']) == ['enO', 'enO', 'owT']\nassert op_sortlen_title_revstr(['x']) == ['X']\nassert op_sortlen_title_revstr(['abc', 'de', '']) == ['', 'eD', 'cbA']"}
{"id": "op_rev_square_halve", "entry_point": "op_rev_square_halve", "primitives": ["rev", "square", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; reverse the order, then square each, then halve each (integer division).", "solution": "def op_rev_square_halve(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * x for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_rev_square_halve([1, 2, 3, 4]) == [8, 4, 2, 0]\nassert op_rev_square_halve([]) == []\nassert op_rev_square_halve([-2, -1, 0, 1, 2]) == [2, 0, 0, 0, 2]\nassert op_rev_square_halve([5, 5, 5]) == [12, 12, 12]\nassert op_rev_square_halve([3, 1, 2]) == [2, 0, 4]\nassert op_rev_square_halve([10]) == [50]\nassert op_rev_square_halve([2, 4, 6]) == [18, 8, 2]\nassert op_rev_square_halve([-7, 12, -7]) == [24, 72, 24]"}
{"id": "op_cube_absval_sum", "entry_point": "op_cube_absval_sum", "primitives": ["cube", "absval", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then take the absolute value of each, then return their sum.", "solution": "def op_cube_absval_sum(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [abs(x) for x in r]\n    return sum(r)", "tests": "assert op_cube_absval_sum([1, 2, 3, 4]) == 100\nassert op_cube_absval_sum([]) == 0\nassert op_cube_absval_sum([-2, -1, 0, 1, 2]) == 18\nassert op_cube_absval_sum([5, 5, 5]) == 375\nassert op_cube_absval_sum([3, 1, 2]) == 36\nassert op_cube_absval_sum([10]) == 1000\nassert op_cube_absval_sum([2, 4, 6]) == 288\nassert op_cube_absval_sum([-7, 12, -7]) == 2414"}
{"id": "op_halve_add10_len", "entry_point": "op_halve_add10_len", "primitives": ["halve", "add10", "len"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then add ten to each, then return how many remain.", "solution": "def op_halve_add10_len(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    return len(r)", "tests": "assert op_halve_add10_len([1, 2, 3, 4]) == 4\nassert op_halve_add10_len([]) == 0\nassert op_halve_add10_len([-2, -1, 0, 1, 2]) == 5\nassert op_halve_add10_len([5, 5, 5]) == 3\nassert op_halve_add10_len([3, 1, 2]) == 3\nassert op_halve_add10_len([10]) == 1\nassert op_halve_add10_len([2, 4, 6]) == 3\nassert op_halve_add10_len([-7, 12, -7]) == 3"}
{"id": "op_cube_dropzeros_uniq", "entry_point": "op_cube_dropzeros_uniq", "primitives": ["cube", "dropzeros", "uniq"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the zeros, then drop duplicates keeping first occurrence.", "solution": "def op_cube_dropzeros_uniq(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x != 0]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_cube_dropzeros_uniq([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_cube_dropzeros_uniq([]) == []\nassert op_cube_dropzeros_uniq([-2, -1, 0, 1, 2]) == [-8, -1, 1, 8]\nassert op_cube_dropzeros_uniq([5, 5, 5]) == [125]\nassert op_cube_dropzeros_uniq([3, 1, 2]) == [27, 1, 8]\nassert op_cube_dropzeros_uniq([10]) == [1000]\nassert op_cube_dropzeros_uniq([2, 4, 6]) == [8, 64, 216]\nassert op_cube_dropzeros_uniq([-7, 12, -7]) == [-343, 1728]"}
{"id": "op_halve_dropfirst_anyeven", "entry_point": "op_halve_dropfirst_anyeven", "primitives": ["halve", "dropfirst", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the first element, then return whether any value is even.", "solution": "def op_halve_dropfirst_anyeven(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[1:]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_halve_dropfirst_anyeven([1, 2, 3, 4]) == True\nassert op_halve_dropfirst_anyeven([]) == False\nassert op_halve_dropfirst_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_halve_dropfirst_anyeven([5, 5, 5]) == True\nassert op_halve_dropfirst_anyeven([3, 1, 2]) == True\nassert op_halve_dropfirst_anyeven([10]) == False\nassert op_halve_dropfirst_anyeven([2, 4, 6]) == True\nassert op_halve_dropfirst_anyeven([-7, 12, -7]) == True"}
{"id": "op_div3_cube_double", "entry_point": "op_div3_cube_double", "primitives": ["div3", "cube", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cube each, then double each.", "solution": "def op_div3_cube_double(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x ** 3 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_div3_cube_double([1, 2, 3, 4]) == [54]\nassert op_div3_cube_double([]) == []\nassert op_div3_cube_double([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_cube_double([5, 5, 5]) == []\nassert op_div3_cube_double([3, 1, 2]) == [54]\nassert op_div3_cube_double([10]) == []\nassert op_div3_cube_double([2, 4, 6]) == [432]\nassert op_div3_cube_double([-7, 12, -7]) == [3456]"}
{"id": "op_cube_inc_allpos", "entry_point": "op_cube_inc_allpos", "primitives": ["cube", "inc", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then add one to each, then return whether all values are positive.", "solution": "def op_cube_inc_allpos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x + 1 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_cube_inc_allpos([1, 2, 3, 4]) == True\nassert op_cube_inc_allpos([]) == True\nassert op_cube_inc_allpos([-2, -1, 0, 1, 2]) == False\nassert op_cube_inc_allpos([5, 5, 5]) == True\nassert op_cube_inc_allpos([3, 1, 2]) == True\nassert op_cube_inc_allpos([10]) == True\nassert op_cube_inc_allpos([2, 4, 6]) == True\nassert op_cube_inc_allpos([-7, 12, -7]) == False"}
{"id": "op_revstr_lower_uniqs", "entry_point": "op_revstr_lower_uniqs", "primitives": ["revstr", "lower", "uniqs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then lowercase each string, then drop duplicate strings keeping the first.", "solution": "def op_revstr_lower_uniqs(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.lower() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_revstr_lower_uniqs(['Hello', 'world']) == ['olleh', 'dlrow']\nassert op_revstr_lower_uniqs([]) == []\nassert op_revstr_lower_uniqs(['  a ', '', 'BC', 'bc']) == [' a  ', '', 'cb']\nassert op_revstr_lower_uniqs(['one', 'one', 'Two']) == ['eno', 'owt']\nassert op_revstr_lower_uniqs(['x']) == ['x']\nassert op_revstr_lower_uniqs(['abc', 'de', '']) == ['cba', 'ed', '']"}
{"id": "op_add10_negate_cube", "entry_point": "op_add10_negate_cube", "primitives": ["add10", "negate", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add ten to each, then negate each, then cube each.", "solution": "def op_add10_negate_cube(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [-x for x in r]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_add10_negate_cube([1, 2, 3, 4]) == [-1331, -1728, -2197, -2744]\nassert op_add10_negate_cube([]) == []\nassert op_add10_negate_cube([-2, -1, 0, 1, 2]) == [-512, -729, -1000, -1331, -1728]\nassert op_add10_negate_cube([5, 5, 5]) == [-3375, -3375, -3375]\nassert op_add10_negate_cube([3, 1, 2]) == [-2197, -1331, -1728]\nassert op_add10_negate_cube([10]) == [-8000]\nassert op_add10_negate_cube([2, 4, 6]) == [-1728, -2744, -4096]\nassert op_add10_negate_cube([-7, 12, -7]) == [-27, -10648, -27]"}
{"id": "op_halve_rev_oremptyzero", "entry_point": "op_halve_rev_oremptyzero", "primitives": ["halve", "rev", "oremptyzero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then reverse the order, then if empty, use a single zero.", "solution": "def op_halve_rev_oremptyzero(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = list(reversed(r))\n    r = r if r else [0]\n    return r", "tests": "assert op_halve_rev_oremptyzero([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_halve_rev_oremptyzero([]) == [0]\nassert op_halve_rev_oremptyzero([-2, -1, 0, 1, 2]) == [1, 0, 0, -1, -1]\nassert op_halve_rev_oremptyzero([5, 5, 5]) == [2, 2, 2]\nassert op_halve_rev_oremptyzero([3, 1, 2]) == [1, 0, 1]\nassert op_halve_rev_oremptyzero([10]) == [5]\nassert op_halve_rev_oremptyzero([2, 4, 6]) == [3, 2, 1]\nassert op_halve_rev_oremptyzero([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_adults_ages_takewhilepos", "entry_point": "op_adults_ages_takewhilepos", "primitives": ["adults", "ages", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); keep only adults (age 18+), then extract the ages, then take values while they are positive.", "solution": "def op_adults_ages_takewhilepos(xs):\n    r = list(xs)\n    r = [d for d in r if d['age'] >= 18]\n    r = [d['age'] for d in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_adults_ages_takewhilepos([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [36]\nassert op_adults_ages_takewhilepos([]) == []\nassert op_adults_ages_takewhilepos([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [18, 65]\nassert op_adults_ages_takewhilepos([{'name': 'Fi', 'age': 41}]) == [41]"}
{"id": "op_lower_revstr_prefixup", "entry_point": "op_lower_revstr_prefixup", "primitives": ["lower", "revstr", "prefixup"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then reverse each string, then prefix each with a hash.", "solution": "def op_lower_revstr_prefixup(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[::-1] for s in r]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_lower_revstr_prefixup(['Hello', 'world']) == ['#olleh', '#dlrow']\nassert op_lower_revstr_prefixup([]) == []\nassert op_lower_revstr_prefixup(['  a ', '', 'BC', 'bc']) == ['# a  ', '#', '#cb', '#cb']\nassert op_lower_revstr_prefixup(['one', 'one', 'Two']) == ['#eno', '#eno', '#owt']\nassert op_lower_revstr_prefixup(['x']) == ['#x']\nassert op_lower_revstr_prefixup(['abc', 'de', '']) == ['#cba', '#ed', '#']"}
{"id": "op_sortd_takewhilepos_halve", "entry_point": "op_sortd_takewhilepos_halve", "primitives": ["sortd", "takewhilepos", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort descending, then take values while they are positive, then halve each (integer division).", "solution": "def op_sortd_takewhilepos_halve(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_sortd_takewhilepos_halve([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_sortd_takewhilepos_halve([]) == []\nassert op_sortd_takewhilepos_halve([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_sortd_takewhilepos_halve([5, 5, 5]) == [2, 2, 2]\nassert op_sortd_takewhilepos_halve([3, 1, 2]) == [1, 1, 0]\nassert op_sortd_takewhilepos_halve([10]) == [5]\nassert op_sortd_takewhilepos_halve([2, 4, 6]) == [3, 2, 1]\nassert op_sortd_takewhilepos_halve([-7, 12, -7]) == [6]"}
{"id": "op_first3_cube_anyeven", "entry_point": "op_first3_cube_anyeven", "primitives": ["first3", "cube", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then cube each, then return whether any value is even.", "solution": "def op_first3_cube_anyeven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x ** 3 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_first3_cube_anyeven([1, 2, 3, 4]) == True\nassert op_first3_cube_anyeven([]) == False\nassert op_first3_cube_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_first3_cube_anyeven([5, 5, 5]) == False\nassert op_first3_cube_anyeven([3, 1, 2]) == True\nassert op_first3_cube_anyeven([10]) == True\nassert op_first3_cube_anyeven([2, 4, 6]) == True\nassert op_first3_cube_anyeven([-7, 12, -7]) == True"}
{"id": "op_cube_negate_div3", "entry_point": "op_cube_negate_div3", "primitives": ["cube", "negate", "div3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then negate each, then keep multiples of three.", "solution": "def op_cube_negate_div3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_cube_negate_div3([1, 2, 3, 4]) == [-27]\nassert op_cube_negate_div3([]) == []\nassert op_cube_negate_div3([-2, -1, 0, 1, 2]) == [0]\nassert op_cube_negate_div3([5, 5, 5]) == []\nassert op_cube_negate_div3([3, 1, 2]) == [-27]\nassert op_cube_negate_div3([10]) == []\nassert op_cube_negate_div3([2, 4, 6]) == [-216]\nassert op_cube_negate_div3([-7, 12, -7]) == [-1728]"}
{"id": "op_dropwhileneg_sortd_halve", "entry_point": "op_dropwhileneg_sortd_halve", "primitives": ["dropwhileneg", "sortd", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then sort descending, then halve each (integer division).", "solution": "def op_dropwhileneg_sortd_halve(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = sorted(r, reverse=True)\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_dropwhileneg_sortd_halve([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_dropwhileneg_sortd_halve([]) == []\nassert op_dropwhileneg_sortd_halve([-2, -1, 0, 1, 2]) == [1, 0, 0]\nassert op_dropwhileneg_sortd_halve([5, 5, 5]) == [2, 2, 2]\nassert op_dropwhileneg_sortd_halve([3, 1, 2]) == [1, 1, 0]\nassert op_dropwhileneg_sortd_halve([10]) == [5]\nassert op_dropwhileneg_sortd_halve([2, 4, 6]) == [3, 2, 1]\nassert op_dropwhileneg_sortd_halve([-7, 12, -7]) == [6, -4]"}
{"id": "op_halve_dropfirst_pos", "entry_point": "op_halve_dropfirst_pos", "primitives": ["halve", "dropfirst", "pos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the first element, then keep the positive numbers.", "solution": "def op_halve_dropfirst_pos(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[1:]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_halve_dropfirst_pos([1, 2, 3, 4]) == [1, 1, 2]\nassert op_halve_dropfirst_pos([]) == []\nassert op_halve_dropfirst_pos([-2, -1, 0, 1, 2]) == [1]\nassert op_halve_dropfirst_pos([5, 5, 5]) == [2, 2]\nassert op_halve_dropfirst_pos([3, 1, 2]) == [1]\nassert op_halve_dropfirst_pos([10]) == []\nassert op_halve_dropfirst_pos([2, 4, 6]) == [2, 3]\nassert op_halve_dropfirst_pos([-7, 12, -7]) == [6]"}
{"id": "op_div3_cube_prod", "entry_point": "op_div3_cube_prod", "primitives": ["div3", "cube", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cube each, then return their product.", "solution": "def op_div3_cube_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x ** 3 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_div3_cube_prod([1, 2, 3, 4]) == 27\nassert op_div3_cube_prod([]) == 1\nassert op_div3_cube_prod([-2, -1, 0, 1, 2]) == 0\nassert op_div3_cube_prod([5, 5, 5]) == 1\nassert op_div3_cube_prod([3, 1, 2]) == 27\nassert op_div3_cube_prod([10]) == 1\nassert op_div3_cube_prod([2, 4, 6]) == 216\nassert op_div3_cube_prod([-7, 12, -7]) == 1728"}
{"id": "op_odds_halve_neg", "entry_point": "op_odds_halve_neg", "primitives": ["odds", "halve", "neg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then halve each (integer division), then keep the negative numbers.", "solution": "def op_odds_halve_neg(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x // 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_odds_halve_neg([1, 2, 3, 4]) == []\nassert op_odds_halve_neg([]) == []\nassert op_odds_halve_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_odds_halve_neg([5, 5, 5]) == []\nassert op_odds_halve_neg([3, 1, 2]) == []\nassert op_odds_halve_neg([10]) == []\nassert op_odds_halve_neg([2, 4, 6]) == []\nassert op_odds_halve_neg([-7, 12, -7]) == [-4, -4]"}
{"id": "op_halve_rev_neg", "entry_point": "op_halve_rev_neg", "primitives": ["halve", "rev", "neg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then reverse the order, then keep the negative numbers.", "solution": "def op_halve_rev_neg(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = list(reversed(r))\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_halve_rev_neg([1, 2, 3, 4]) == []\nassert op_halve_rev_neg([]) == []\nassert op_halve_rev_neg([-2, -1, 0, 1, 2]) == [-1, -1]\nassert op_halve_rev_neg([5, 5, 5]) == []\nassert op_halve_rev_neg([3, 1, 2]) == []\nassert op_halve_rev_neg([10]) == []\nassert op_halve_rev_neg([2, 4, 6]) == []\nassert op_halve_rev_neg([-7, 12, -7]) == [-4, -4]"}
{"id": "op_dropzeros_dropwhileneg_range_", "entry_point": "op_dropzeros_dropwhileneg_range_", "primitives": ["dropzeros", "dropwhileneg", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then return the range (max minus min, 0 if empty).", "solution": "def op_dropzeros_dropwhileneg_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropzeros_dropwhileneg_range_([1, 2, 3, 4]) == 3\nassert op_dropzeros_dropwhileneg_range_([]) == 0\nassert op_dropzeros_dropwhileneg_range_([-2, -1, 0, 1, 2]) == 1\nassert op_dropzeros_dropwhileneg_range_([5, 5, 5]) == 0\nassert op_dropzeros_dropwhileneg_range_([3, 1, 2]) == 2\nassert op_dropzeros_dropwhileneg_range_([10]) == 0\nassert op_dropzeros_dropwhileneg_range_([2, 4, 6]) == 4\nassert op_dropzeros_dropwhileneg_range_([-7, 12, -7]) == 19"}
{"id": "op_first3_padto3_range_", "entry_point": "op_first3_padto3_range_", "primitives": ["first3", "padto3", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then pad with zeros to at least three elements, then return the range (max minus min, 0 if empty).", "solution": "def op_first3_padto3_range_(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_first3_padto3_range_([1, 2, 3, 4]) == 2\nassert op_first3_padto3_range_([]) == 0\nassert op_first3_padto3_range_([-2, -1, 0, 1, 2]) == 2\nassert op_first3_padto3_range_([5, 5, 5]) == 0\nassert op_first3_padto3_range_([3, 1, 2]) == 2\nassert op_first3_padto3_range_([10]) == 10\nassert op_first3_padto3_range_([2, 4, 6]) == 4\nassert op_first3_padto3_range_([-7, 12, -7]) == 19"}
{"id": "op_dropzeros_add10_range_", "entry_point": "op_dropzeros_add10_range_", "primitives": ["dropzeros", "add10", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then add ten to each, then return the range (max minus min, 0 if empty).", "solution": "def op_dropzeros_add10_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x + 10 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropzeros_add10_range_([1, 2, 3, 4]) == 3\nassert op_dropzeros_add10_range_([]) == 0\nassert op_dropzeros_add10_range_([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_add10_range_([5, 5, 5]) == 0\nassert op_dropzeros_add10_range_([3, 1, 2]) == 2\nassert op_dropzeros_add10_range_([10]) == 0\nassert op_dropzeros_add10_range_([2, 4, 6]) == 4\nassert op_dropzeros_add10_range_([-7, 12, -7]) == 19"}
{"id": "op_oremptyzero_sorta_cube", "entry_point": "op_oremptyzero_sorta_cube", "primitives": ["oremptyzero", "sorta", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort ascending, then cube each.", "solution": "def op_oremptyzero_sorta_cube(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_oremptyzero_sorta_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_oremptyzero_sorta_cube([]) == [0]\nassert op_oremptyzero_sorta_cube([-2, -1, 0, 1, 2]) == [-8, -1, 0, 1, 8]\nassert op_oremptyzero_sorta_cube([5, 5, 5]) == [125, 125, 125]\nassert op_oremptyzero_sorta_cube([3, 1, 2]) == [1, 8, 27]\nassert op_oremptyzero_sorta_cube([10]) == [1000]\nassert op_oremptyzero_sorta_cube([2, 4, 6]) == [8, 64, 216]\nassert op_oremptyzero_sorta_cube([-7, 12, -7]) == [-343, -343, 1728]"}
{"id": "op_halve_takewhilepos_first3", "entry_point": "op_halve_takewhilepos_first3", "primitives": ["halve", "takewhilepos", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then take values while they are positive, then keep only the first three.", "solution": "def op_halve_takewhilepos_first3(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return r", "tests": "assert op_halve_takewhilepos_first3([1, 2, 3, 4]) == []\nassert op_halve_takewhilepos_first3([]) == []\nassert op_halve_takewhilepos_first3([-2, -1, 0, 1, 2]) == []\nassert op_halve_takewhilepos_first3([5, 5, 5]) == [2, 2, 2]\nassert op_halve_takewhilepos_first3([3, 1, 2]) == [1]\nassert op_halve_takewhilepos_first3([10]) == [5]\nassert op_halve_takewhilepos_first3([2, 4, 6]) == [1, 2, 3]\nassert op_halve_takewhilepos_first3([-7, 12, -7]) == []"}
{"id": "op_negate_halve_div3", "entry_point": "op_negate_halve_div3", "primitives": ["negate", "halve", "div3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then halve each (integer division), then keep multiples of three.", "solution": "def op_negate_halve_div3(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_negate_halve_div3([1, 2, 3, 4]) == []\nassert op_negate_halve_div3([]) == []\nassert op_negate_halve_div3([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_negate_halve_div3([5, 5, 5]) == [-3, -3, -3]\nassert op_negate_halve_div3([3, 1, 2]) == []\nassert op_negate_halve_div3([10]) == []\nassert op_negate_halve_div3([2, 4, 6]) == [-3]\nassert op_negate_halve_div3([-7, 12, -7]) == [3, -6, 3]"}
{"id": "op_cube_last3_first3", "entry_point": "op_cube_last3_first3", "primitives": ["cube", "last3", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep only the last three, then keep only the first three.", "solution": "def op_cube_last3_first3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[-3:]\n    r = r[:3]\n    return r", "tests": "assert op_cube_last3_first3([1, 2, 3, 4]) == [8, 27, 64]\nassert op_cube_last3_first3([]) == []\nassert op_cube_last3_first3([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_cube_last3_first3([5, 5, 5]) == [125, 125, 125]\nassert op_cube_last3_first3([3, 1, 2]) == [27, 1, 8]\nassert op_cube_last3_first3([10]) == [1000]\nassert op_cube_last3_first3([2, 4, 6]) == [8, 64, 216]\nassert op_cube_last3_first3([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_clamp10_double_halve", "entry_point": "op_clamp10_double_halve", "primitives": ["clamp10", "double", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then double each, then halve each (integer division).", "solution": "def op_clamp10_double_halve(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * 2 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_clamp10_double_halve([1, 2, 3, 4]) == [1, 2, 3, 4]\nassert op_clamp10_double_halve([]) == []\nassert op_clamp10_double_halve([-2, -1, 0, 1, 2]) == [-2, -1, 0, 1, 2]\nassert op_clamp10_double_halve([5, 5, 5]) == [5, 5, 5]\nassert op_clamp10_double_halve([3, 1, 2]) == [3, 1, 2]\nassert op_clamp10_double_halve([10]) == [10]\nassert op_clamp10_double_halve([2, 4, 6]) == [2, 4, 6]\nassert op_clamp10_double_halve([-7, 12, -7]) == [-7, 10, -7]"}
{"id": "op_cube_padto3_anyeven", "entry_point": "op_cube_padto3_anyeven", "primitives": ["cube", "padto3", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then pad with zeros to at least three elements, then return whether any value is even.", "solution": "def op_cube_padto3_anyeven(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_cube_padto3_anyeven([1, 2, 3, 4]) == True\nassert op_cube_padto3_anyeven([]) == True\nassert op_cube_padto3_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_cube_padto3_anyeven([5, 5, 5]) == False\nassert op_cube_padto3_anyeven([3, 1, 2]) == True\nassert op_cube_padto3_anyeven([10]) == True\nassert op_cube_padto3_anyeven([2, 4, 6]) == True\nassert op_cube_padto3_anyeven([-7, 12, -7]) == True"}
{"id": "op_uniqs_revstr_sortlen", "entry_point": "op_uniqs_revstr_sortlen", "primitives": ["uniqs", "revstr", "sortlen"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then reverse each string, then sort by length, shortest first.", "solution": "def op_uniqs_revstr_sortlen(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[::-1] for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_uniqs_revstr_sortlen(['Hello', 'world']) == ['olleH', 'dlrow']\nassert op_uniqs_revstr_sortlen([]) == []\nassert op_uniqs_revstr_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'CB', 'cb', ' a  ']\nassert op_uniqs_revstr_sortlen(['one', 'one', 'Two']) == ['eno', 'owT']\nassert op_uniqs_revstr_sortlen(['x']) == ['x']\nassert op_uniqs_revstr_sortlen(['abc', 'de', '']) == ['', 'ed', 'cba']"}
{"id": "op_rev_double_halve", "entry_point": "op_rev_double_halve", "primitives": ["rev", "double", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; reverse the order, then double each, then halve each (integer division).", "solution": "def op_rev_double_halve(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_rev_double_halve([1, 2, 3, 4]) == [4, 3, 2, 1]\nassert op_rev_double_halve([]) == []\nassert op_rev_double_halve([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_rev_double_halve([5, 5, 5]) == [5, 5, 5]\nassert op_rev_double_halve([3, 1, 2]) == [2, 1, 3]\nassert op_rev_double_halve([10]) == [10]\nassert op_rev_double_halve([2, 4, 6]) == [6, 4, 2]\nassert op_rev_double_halve([-7, 12, -7]) == [-7, 12, -7]"}
{"id": "op_cube_dropzeros_firsteven", "entry_point": "op_cube_dropzeros_firsteven", "primitives": ["cube", "dropzeros", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the zeros, then return the first even value (0 if none).", "solution": "def op_cube_dropzeros_firsteven(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x != 0]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_cube_dropzeros_firsteven([1, 2, 3, 4]) == 8\nassert op_cube_dropzeros_firsteven([]) == 0\nassert op_cube_dropzeros_firsteven([-2, -1, 0, 1, 2]) == -8\nassert op_cube_dropzeros_firsteven([5, 5, 5]) == 0\nassert op_cube_dropzeros_firsteven([3, 1, 2]) == 8\nassert op_cube_dropzeros_firsteven([10]) == 1000\nassert op_cube_dropzeros_firsteven([2, 4, 6]) == 8\nassert op_cube_dropzeros_firsteven([-7, 12, -7]) == 1728"}
{"id": "op_negate_beforezero_halve", "entry_point": "op_negate_beforezero_halve", "primitives": ["negate", "beforezero", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then keep everything before the first zero, then halve each (integer division).", "solution": "def op_negate_beforezero_halve(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_negate_beforezero_halve([1, 2, 3, 4]) == [-1, -1, -2, -2]\nassert op_negate_beforezero_halve([]) == []\nassert op_negate_beforezero_halve([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_negate_beforezero_halve([5, 5, 5]) == [-3, -3, -3]\nassert op_negate_beforezero_halve([3, 1, 2]) == [-2, -1, -1]\nassert op_negate_beforezero_halve([10]) == [-5]\nassert op_negate_beforezero_halve([2, 4, 6]) == [-1, -2, -3]\nassert op_negate_beforezero_halve([-7, 12, -7]) == [3, -6, 3]"}
{"id": "op_cube_add10", "entry_point": "op_cube_add10", "primitives": ["cube", "add10"], "difficulty": 1, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then add ten to each.", "solution": "def op_cube_add10(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_cube_add10([1, 2, 3, 4]) == [11, 18, 37, 74]\nassert op_cube_add10([]) == []\nassert op_cube_add10([-2, -1, 0, 1, 2]) == [2, 9, 10, 11, 18]\nassert op_cube_add10([5, 5, 5]) == [135, 135, 135]\nassert op_cube_add10([3, 1, 2]) == [37, 11, 18]\nassert op_cube_add10([10]) == [1010]\nassert op_cube_add10([2, 4, 6]) == [18, 74, 226]\nassert op_cube_add10([-7, 12, -7]) == [-333, 1738, -333]"}
{"id": "op_clamp10_evens_halve", "entry_point": "op_clamp10_evens_halve", "primitives": ["clamp10", "evens", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the even numbers, then halve each (integer division).", "solution": "def op_clamp10_evens_halve(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_clamp10_evens_halve([1, 2, 3, 4]) == [1, 2]\nassert op_clamp10_evens_halve([]) == []\nassert op_clamp10_evens_halve([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_clamp10_evens_halve([5, 5, 5]) == []\nassert op_clamp10_evens_halve([3, 1, 2]) == [1]\nassert op_clamp10_evens_halve([10]) == [5]\nassert op_clamp10_evens_halve([2, 4, 6]) == [1, 2, 3]\nassert op_clamp10_evens_halve([-7, 12, -7]) == [5]"}
{"id": "op_halve_neg_max", "entry_point": "op_halve_neg_max", "primitives": ["halve", "neg", "max"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the negative numbers, then return the maximum (0 if empty).", "solution": "def op_halve_neg_max(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x < 0]\n    return max(r) if r else 0", "tests": "assert op_halve_neg_max([1, 2, 3, 4]) == 0\nassert op_halve_neg_max([]) == 0\nassert op_halve_neg_max([-2, -1, 0, 1, 2]) == -1\nassert op_halve_neg_max([5, 5, 5]) == 0\nassert op_halve_neg_max([3, 1, 2]) == 0\nassert op_halve_neg_max([10]) == 0\nassert op_halve_neg_max([2, 4, 6]) == 0\nassert op_halve_neg_max([-7, 12, -7]) == -4"}
{"id": "op_cube_div3_dropwhileneg", "entry_point": "op_cube_div3_dropwhileneg", "primitives": ["cube", "div3", "dropwhileneg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep multiples of three, then drop the leading negative values.", "solution": "def op_cube_div3_dropwhileneg(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_cube_div3_dropwhileneg([1, 2, 3, 4]) == [27]\nassert op_cube_div3_dropwhileneg([]) == []\nassert op_cube_div3_dropwhileneg([-2, -1, 0, 1, 2]) == [0]\nassert op_cube_div3_dropwhileneg([5, 5, 5]) == []\nassert op_cube_div3_dropwhileneg([3, 1, 2]) == [27]\nassert op_cube_div3_dropwhileneg([10]) == []\nassert op_cube_div3_dropwhileneg([2, 4, 6]) == [216]\nassert op_cube_div3_dropwhileneg([-7, 12, -7]) == [1728]"}
{"id": "op_inc_add10_range_", "entry_point": "op_inc_add10_range_", "primitives": ["inc", "add10", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then add ten to each, then return the range (max minus min, 0 if empty).", "solution": "def op_inc_add10_range_(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x + 10 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_inc_add10_range_([1, 2, 3, 4]) == 3\nassert op_inc_add10_range_([]) == 0\nassert op_inc_add10_range_([-2, -1, 0, 1, 2]) == 4\nassert op_inc_add10_range_([5, 5, 5]) == 0\nassert op_inc_add10_range_([3, 1, 2]) == 2\nassert op_inc_add10_range_([10]) == 0\nassert op_inc_add10_range_([2, 4, 6]) == 4\nassert op_inc_add10_range_([-7, 12, -7]) == 19"}
{"id": "op_padto3_halve_sum", "entry_point": "op_padto3_halve_sum", "primitives": ["padto3", "halve", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then halve each (integer division), then return their sum.", "solution": "def op_padto3_halve_sum(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x // 2 for x in r]\n    return sum(r)", "tests": "assert op_padto3_halve_sum([1, 2, 3, 4]) == 4\nassert op_padto3_halve_sum([]) == 0\nassert op_padto3_halve_sum([-2, -1, 0, 1, 2]) == -1\nassert op_padto3_halve_sum([5, 5, 5]) == 6\nassert op_padto3_halve_sum([3, 1, 2]) == 2\nassert op_padto3_halve_sum([10]) == 5\nassert op_padto3_halve_sum([2, 4, 6]) == 6\nassert op_padto3_halve_sum([-7, 12, -7]) == -2"}
{"id": "op_dec_halve_sorta", "entry_point": "op_dec_halve_sorta", "primitives": ["dec", "halve", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then halve each (integer division), then sort ascending.", "solution": "def op_dec_halve_sorta(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x // 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dec_halve_sorta([1, 2, 3, 4]) == [0, 0, 1, 1]\nassert op_dec_halve_sorta([]) == []\nassert op_dec_halve_sorta([-2, -1, 0, 1, 2]) == [-2, -1, -1, 0, 0]\nassert op_dec_halve_sorta([5, 5, 5]) == [2, 2, 2]\nassert op_dec_halve_sorta([3, 1, 2]) == [0, 0, 1]\nassert op_dec_halve_sorta([10]) == [4]\nassert op_dec_halve_sorta([2, 4, 6]) == [0, 1, 2]\nassert op_dec_halve_sorta([-7, 12, -7]) == [-4, -4, 5]"}
{"id": "op_inc_sorta_range_", "entry_point": "op_inc_sorta_range_", "primitives": ["inc", "sorta", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then sort ascending, then return the range (max minus min, 0 if empty).", "solution": "def op_inc_sorta_range_(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = sorted(r)\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_inc_sorta_range_([1, 2, 3, 4]) == 3\nassert op_inc_sorta_range_([]) == 0\nassert op_inc_sorta_range_([-2, -1, 0, 1, 2]) == 4\nassert op_inc_sorta_range_([5, 5, 5]) == 0\nassert op_inc_sorta_range_([3, 1, 2]) == 2\nassert op_inc_sorta_range_([10]) == 0\nassert op_inc_sorta_range_([2, 4, 6]) == 4\nassert op_inc_sorta_range_([-7, 12, -7]) == 19"}
{"id": "op_lower_revstr_sortlen", "entry_point": "op_lower_revstr_sortlen", "primitives": ["lower", "revstr", "sortlen"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; lowercase each string, then reverse each string, then sort by length, shortest first.", "solution": "def op_lower_revstr_sortlen(xs):\n    r = list(xs)\n    r = [s.lower() for s in r]\n    r = [s[::-1] for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_lower_revstr_sortlen(['Hello', 'world']) == ['olleh', 'dlrow']\nassert op_lower_revstr_sortlen([]) == []\nassert op_lower_revstr_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'cb', 'cb', ' a  ']\nassert op_lower_revstr_sortlen(['one', 'one', 'Two']) == ['eno', 'eno', 'owt']\nassert op_lower_revstr_sortlen(['x']) == ['x']\nassert op_lower_revstr_sortlen(['abc', 'de', '']) == ['', 'ed', 'cba']"}
{"id": "op_beforezero_halve_min", "entry_point": "op_beforezero_halve_min", "primitives": ["beforezero", "halve", "min"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then halve each (integer division), then return the minimum (0 if empty).", "solution": "def op_beforezero_halve_min(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x // 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_beforezero_halve_min([1, 2, 3, 4]) == 0\nassert op_beforezero_halve_min([]) == 0\nassert op_beforezero_halve_min([-2, -1, 0, 1, 2]) == -1\nassert op_beforezero_halve_min([5, 5, 5]) == 2\nassert op_beforezero_halve_min([3, 1, 2]) == 0\nassert op_beforezero_halve_min([10]) == 5\nassert op_beforezero_halve_min([2, 4, 6]) == 1\nassert op_beforezero_halve_min([-7, 12, -7]) == -4"}
{"id": "op_cube_trimends_sorta", "entry_point": "op_cube_trimends_sorta", "primitives": ["cube", "trimends", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the first and last elements, then sort ascending.", "solution": "def op_cube_trimends_sorta(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    r = sorted(r)\n    return r", "tests": "assert op_cube_trimends_sorta([1, 2, 3, 4]) == [8, 27]\nassert op_cube_trimends_sorta([]) == []\nassert op_cube_trimends_sorta([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_cube_trimends_sorta([5, 5, 5]) == [125]\nassert op_cube_trimends_sorta([3, 1, 2]) == [1]\nassert op_cube_trimends_sorta([10]) == []\nassert op_cube_trimends_sorta([2, 4, 6]) == [64]\nassert op_cube_trimends_sorta([-7, 12, -7]) == [1728]"}
{"id": "op_clamp10_halve_evens", "entry_point": "op_clamp10_halve_evens", "primitives": ["clamp10", "halve", "evens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then halve each (integer division), then keep the even numbers.", "solution": "def op_clamp10_halve_evens(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_clamp10_halve_evens([1, 2, 3, 4]) == [0, 2]\nassert op_clamp10_halve_evens([]) == []\nassert op_clamp10_halve_evens([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_clamp10_halve_evens([5, 5, 5]) == [2, 2, 2]\nassert op_clamp10_halve_evens([3, 1, 2]) == [0]\nassert op_clamp10_halve_evens([10]) == []\nassert op_clamp10_halve_evens([2, 4, 6]) == [2]\nassert op_clamp10_halve_evens([-7, 12, -7]) == [-4, -4]"}
{"id": "op_halve_oremptyzero_rev", "entry_point": "op_halve_oremptyzero_rev", "primitives": ["halve", "oremptyzero", "rev"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then if empty, use a single zero, then reverse the order.", "solution": "def op_halve_oremptyzero_rev(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r if r else [0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_halve_oremptyzero_rev([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_halve_oremptyzero_rev([]) == [0]\nassert op_halve_oremptyzero_rev([-2, -1, 0, 1, 2]) == [1, 0, 0, -1, -1]\nassert op_halve_oremptyzero_rev([5, 5, 5]) == [2, 2, 2]\nassert op_halve_oremptyzero_rev([3, 1, 2]) == [1, 0, 1]\nassert op_halve_oremptyzero_rev([10]) == [5]\nassert op_halve_oremptyzero_rev([2, 4, 6]) == [3, 2, 1]\nassert op_halve_oremptyzero_rev([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_cube_trimends_range_", "entry_point": "op_cube_trimends_range_", "primitives": ["cube", "trimends", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the first and last elements, then return the range (max minus min, 0 if empty).", "solution": "def op_cube_trimends_range_(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_cube_trimends_range_([1, 2, 3, 4]) == 19\nassert op_cube_trimends_range_([]) == 0\nassert op_cube_trimends_range_([-2, -1, 0, 1, 2]) == 2\nassert op_cube_trimends_range_([5, 5, 5]) == 0\nassert op_cube_trimends_range_([3, 1, 2]) == 0\nassert op_cube_trimends_range_([10]) == 0\nassert op_cube_trimends_range_([2, 4, 6]) == 0\nassert op_cube_trimends_range_([-7, 12, -7]) == 0"}
{"id": "op_evens_div3_halve", "entry_point": "op_evens_div3_halve", "primitives": ["evens", "div3", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then keep multiples of three, then halve each (integer division).", "solution": "def op_evens_div3_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_evens_div3_halve([1, 2, 3, 4]) == []\nassert op_evens_div3_halve([]) == []\nassert op_evens_div3_halve([-2, -1, 0, 1, 2]) == [0]\nassert op_evens_div3_halve([5, 5, 5]) == []\nassert op_evens_div3_halve([3, 1, 2]) == []\nassert op_evens_div3_halve([10]) == []\nassert op_evens_div3_halve([2, 4, 6]) == [3]\nassert op_evens_div3_halve([-7, 12, -7]) == [6]"}
{"id": "op_halve_last3_prod", "entry_point": "op_halve_last3_prod", "primitives": ["halve", "last3", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep only the last three, then return their product.", "solution": "def op_halve_last3_prod(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[-3:]\n    return __import__('math').prod(r)", "tests": "assert op_halve_last3_prod([1, 2, 3, 4]) == 2\nassert op_halve_last3_prod([]) == 1\nassert op_halve_last3_prod([-2, -1, 0, 1, 2]) == 0\nassert op_halve_last3_prod([5, 5, 5]) == 8\nassert op_halve_last3_prod([3, 1, 2]) == 0\nassert op_halve_last3_prod([10]) == 5\nassert op_halve_last3_prod([2, 4, 6]) == 6\nassert op_halve_last3_prod([-7, 12, -7]) == 96"}
{"id": "op_clamp10_odds_halve", "entry_point": "op_clamp10_odds_halve", "primitives": ["clamp10", "odds", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then keep the odd numbers, then halve each (integer division).", "solution": "def op_clamp10_odds_halve(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_clamp10_odds_halve([1, 2, 3, 4]) == [0, 1]\nassert op_clamp10_odds_halve([]) == []\nassert op_clamp10_odds_halve([-2, -1, 0, 1, 2]) == [-1, 0]\nassert op_clamp10_odds_halve([5, 5, 5]) == [2, 2, 2]\nassert op_clamp10_odds_halve([3, 1, 2]) == [1, 0]\nassert op_clamp10_odds_halve([10]) == []\nassert op_clamp10_odds_halve([2, 4, 6]) == []\nassert op_clamp10_odds_halve([-7, 12, -7]) == [-4, -4]"}
{"id": "op_halve_negate_uniq", "entry_point": "op_halve_negate_uniq", "primitives": ["halve", "negate", "uniq"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then negate each, then drop duplicates keeping first occurrence.", "solution": "def op_halve_negate_uniq(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [-x for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_halve_negate_uniq([1, 2, 3, 4]) == [0, -1, -2]\nassert op_halve_negate_uniq([]) == []\nassert op_halve_negate_uniq([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_halve_negate_uniq([5, 5, 5]) == [-2]\nassert op_halve_negate_uniq([3, 1, 2]) == [-1, 0]\nassert op_halve_negate_uniq([10]) == [-5]\nassert op_halve_negate_uniq([2, 4, 6]) == [-1, -2, -3]\nassert op_halve_negate_uniq([-7, 12, -7]) == [4, -6]"}
{"id": "op_dropfirst_halve_counteven", "entry_point": "op_dropfirst_halve_counteven", "primitives": ["dropfirst", "halve", "counteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then halve each (integer division), then return how many values are even.", "solution": "def op_dropfirst_halve_counteven(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x // 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_dropfirst_halve_counteven([1, 2, 3, 4]) == 1\nassert op_dropfirst_halve_counteven([]) == 0\nassert op_dropfirst_halve_counteven([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_halve_counteven([5, 5, 5]) == 2\nassert op_dropfirst_halve_counteven([3, 1, 2]) == 1\nassert op_dropfirst_halve_counteven([10]) == 0\nassert op_dropfirst_halve_counteven([2, 4, 6]) == 1\nassert op_dropfirst_halve_counteven([-7, 12, -7]) == 2"}
{"id": "op_halve_dropzeros_sortabs", "entry_point": "op_halve_dropzeros_sortabs", "primitives": ["halve", "dropzeros", "sortabs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the zeros, then sort by absolute value.", "solution": "def op_halve_dropzeros_sortabs(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x != 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_halve_dropzeros_sortabs([1, 2, 3, 4]) == [1, 1, 2]\nassert op_halve_dropzeros_sortabs([]) == []\nassert op_halve_dropzeros_sortabs([-2, -1, 0, 1, 2]) == [-1, -1, 1]\nassert op_halve_dropzeros_sortabs([5, 5, 5]) == [2, 2, 2]\nassert op_halve_dropzeros_sortabs([3, 1, 2]) == [1, 1]\nassert op_halve_dropzeros_sortabs([10]) == [5]\nassert op_halve_dropzeros_sortabs([2, 4, 6]) == [1, 2, 3]\nassert op_halve_dropzeros_sortabs([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_revstr_upper_dropshort", "entry_point": "op_revstr_upper_dropshort", "primitives": ["revstr", "upper", "dropshort"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then uppercase each string, then drop strings shorter than three characters.", "solution": "def op_revstr_upper_dropshort(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.upper() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_revstr_upper_dropshort(['Hello', 'world']) == ['OLLEH', 'DLROW']\nassert op_revstr_upper_dropshort([]) == []\nassert op_revstr_upper_dropshort(['  a ', '', 'BC', 'bc']) == [' A  ']\nassert op_revstr_upper_dropshort(['one', 'one', 'Two']) == ['ENO', 'ENO', 'OWT']\nassert op_revstr_upper_dropshort(['x']) == []\nassert op_revstr_upper_dropshort(['abc', 'de', '']) == ['CBA']"}
{"id": "op_halve_odds_rev", "entry_point": "op_halve_odds_rev", "primitives": ["halve", "odds", "rev"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the odd numbers, then reverse the order.", "solution": "def op_halve_odds_rev(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_halve_odds_rev([1, 2, 3, 4]) == [1, 1]\nassert op_halve_odds_rev([]) == []\nassert op_halve_odds_rev([-2, -1, 0, 1, 2]) == [1, -1, -1]\nassert op_halve_odds_rev([5, 5, 5]) == []\nassert op_halve_odds_rev([3, 1, 2]) == [1, 1]\nassert op_halve_odds_rev([10]) == [5]\nassert op_halve_odds_rev([2, 4, 6]) == [3, 1]\nassert op_halve_odds_rev([-7, 12, -7]) == []"}
{"id": "op_cube_clamp10_allpos", "entry_point": "op_cube_clamp10_allpos", "primitives": ["cube", "clamp10", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then cap each value at 10, then return whether all values are positive.", "solution": "def op_cube_clamp10_allpos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [min(x, 10) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_cube_clamp10_allpos([1, 2, 3, 4]) == True\nassert op_cube_clamp10_allpos([]) == True\nassert op_cube_clamp10_allpos([-2, -1, 0, 1, 2]) == False\nassert op_cube_clamp10_allpos([5, 5, 5]) == True\nassert op_cube_clamp10_allpos([3, 1, 2]) == True\nassert op_cube_clamp10_allpos([10]) == True\nassert op_cube_clamp10_allpos([2, 4, 6]) == True\nassert op_cube_clamp10_allpos([-7, 12, -7]) == False"}
{"id": "op_uniq_dropfirst_cube", "entry_point": "op_uniq_dropfirst_cube", "primitives": ["uniq", "dropfirst", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop duplicates keeping first occurrence, then drop the first element, then cube each.", "solution": "def op_uniq_dropfirst_cube(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_uniq_dropfirst_cube([1, 2, 3, 4]) == [8, 27, 64]\nassert op_uniq_dropfirst_cube([]) == []\nassert op_uniq_dropfirst_cube([-2, -1, 0, 1, 2]) == [-1, 0, 1, 8]\nassert op_uniq_dropfirst_cube([5, 5, 5]) == []\nassert op_uniq_dropfirst_cube([3, 1, 2]) == [1, 8]\nassert op_uniq_dropfirst_cube([10]) == []\nassert op_uniq_dropfirst_cube([2, 4, 6]) == [64, 216]\nassert op_uniq_dropfirst_cube([-7, 12, -7]) == [1728]"}
{"id": "op_title_sortlen_firstchar", "entry_point": "op_title_sortlen_firstchar", "primitives": ["title", "sortlen", "firstchar"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then sort by length, shortest first, then keep the first character of each (dropping empties).", "solution": "def op_title_sortlen_firstchar(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = sorted(r, key=len)\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_title_sortlen_firstchar(['Hello', 'world']) == ['H', 'W']\nassert op_title_sortlen_firstchar([]) == []\nassert op_title_sortlen_firstchar(['  a ', '', 'BC', 'bc']) == ['B', 'B', ' ']\nassert op_title_sortlen_firstchar(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_title_sortlen_firstchar(['x']) == ['X']\nassert op_title_sortlen_firstchar(['abc', 'de', '']) == ['D', 'A']"}
{"id": "op_cube_sortd_first3", "entry_point": "op_cube_sortd_first3", "primitives": ["cube", "sortd", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then sort descending, then keep only the first three.", "solution": "def op_cube_sortd_first3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:3]\n    return r", "tests": "assert op_cube_sortd_first3([1, 2, 3, 4]) == [64, 27, 8]\nassert op_cube_sortd_first3([]) == []\nassert op_cube_sortd_first3([-2, -1, 0, 1, 2]) == [8, 1, 0]\nassert op_cube_sortd_first3([5, 5, 5]) == [125, 125, 125]\nassert op_cube_sortd_first3([3, 1, 2]) == [27, 8, 1]\nassert op_cube_sortd_first3([10]) == [1000]\nassert op_cube_sortd_first3([2, 4, 6]) == [216, 64, 8]\nassert op_cube_sortd_first3([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_oremptyzero_cube_dec", "entry_point": "op_oremptyzero_cube_dec", "primitives": ["oremptyzero", "cube", "dec"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cube each, then subtract one from each.", "solution": "def op_oremptyzero_cube_dec(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x ** 3 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_oremptyzero_cube_dec([1, 2, 3, 4]) == [0, 7, 26, 63]\nassert op_oremptyzero_cube_dec([]) == [-1]\nassert op_oremptyzero_cube_dec([-2, -1, 0, 1, 2]) == [-9, -2, -1, 0, 7]\nassert op_oremptyzero_cube_dec([5, 5, 5]) == [124, 124, 124]\nassert op_oremptyzero_cube_dec([3, 1, 2]) == [26, 0, 7]\nassert op_oremptyzero_cube_dec([10]) == [999]\nassert op_oremptyzero_cube_dec([2, 4, 6]) == [7, 63, 215]\nassert op_oremptyzero_cube_dec([-7, 12, -7]) == [-344, 1727, -344]"}
{"id": "op_trimends_cube_max", "entry_point": "op_trimends_cube_max", "primitives": ["trimends", "cube", "max"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then cube each, then return the maximum (0 if empty).", "solution": "def op_trimends_cube_max(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x ** 3 for x in r]\n    return max(r) if r else 0", "tests": "assert op_trimends_cube_max([1, 2, 3, 4]) == 27\nassert op_trimends_cube_max([]) == 0\nassert op_trimends_cube_max([-2, -1, 0, 1, 2]) == 1\nassert op_trimends_cube_max([5, 5, 5]) == 125\nassert op_trimends_cube_max([3, 1, 2]) == 1\nassert op_trimends_cube_max([10]) == 0\nassert op_trimends_cube_max([2, 4, 6]) == 64\nassert op_trimends_cube_max([-7, 12, -7]) == 1728"}
{"id": "op_clamp10_negate_halve", "entry_point": "op_clamp10_negate_halve", "primitives": ["clamp10", "negate", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then negate each, then halve each (integer division).", "solution": "def op_clamp10_negate_halve(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [-x for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_clamp10_negate_halve([1, 2, 3, 4]) == [-1, -1, -2, -2]\nassert op_clamp10_negate_halve([]) == []\nassert op_clamp10_negate_halve([-2, -1, 0, 1, 2]) == [1, 0, 0, -1, -1]\nassert op_clamp10_negate_halve([5, 5, 5]) == [-3, -3, -3]\nassert op_clamp10_negate_halve([3, 1, 2]) == [-2, -1, -1]\nassert op_clamp10_negate_halve([10]) == [-5]\nassert op_clamp10_negate_halve([2, 4, 6]) == [-1, -2, -3]\nassert op_clamp10_negate_halve([-7, 12, -7]) == [3, -5, 3]"}
{"id": "op_cube_negate_dropzeros", "entry_point": "op_cube_negate_dropzeros", "primitives": ["cube", "negate", "dropzeros"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then negate each, then drop the zeros.", "solution": "def op_cube_negate_dropzeros(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [-x for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_cube_negate_dropzeros([1, 2, 3, 4]) == [-1, -8, -27, -64]\nassert op_cube_negate_dropzeros([]) == []\nassert op_cube_negate_dropzeros([-2, -1, 0, 1, 2]) == [8, 1, -1, -8]\nassert op_cube_negate_dropzeros([5, 5, 5]) == [-125, -125, -125]\nassert op_cube_negate_dropzeros([3, 1, 2]) == [-27, -1, -8]\nassert op_cube_negate_dropzeros([10]) == [-1000]\nassert op_cube_negate_dropzeros([2, 4, 6]) == [-8, -64, -216]\nassert op_cube_negate_dropzeros([-7, 12, -7]) == [343, -1728, 343]"}
{"id": "op_cube_add10_dropfirst", "entry_point": "op_cube_add10_dropfirst", "primitives": ["cube", "add10", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then add ten to each, then drop the first element.", "solution": "def op_cube_add10_dropfirst(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_cube_add10_dropfirst([1, 2, 3, 4]) == [18, 37, 74]\nassert op_cube_add10_dropfirst([]) == []\nassert op_cube_add10_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 11, 18]\nassert op_cube_add10_dropfirst([5, 5, 5]) == [135, 135]\nassert op_cube_add10_dropfirst([3, 1, 2]) == [11, 18]\nassert op_cube_add10_dropfirst([10]) == []\nassert op_cube_add10_dropfirst([2, 4, 6]) == [74, 226]\nassert op_cube_add10_dropfirst([-7, 12, -7]) == [1738, -333]"}
{"id": "op_uniqs_sortlen_title", "entry_point": "op_uniqs_sortlen_title", "primitives": ["uniqs", "sortlen", "title"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then sort by length, shortest first, then title-case each string.", "solution": "def op_uniqs_sortlen_title(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = sorted(r, key=len)\n    r = [s.title() for s in r]\n    return r", "tests": "assert op_uniqs_sortlen_title(['Hello', 'world']) == ['Hello', 'World']\nassert op_uniqs_sortlen_title([]) == []\nassert op_uniqs_sortlen_title(['  a ', '', 'BC', 'bc']) == ['', 'Bc', 'Bc', '  A ']\nassert op_uniqs_sortlen_title(['one', 'one', 'Two']) == ['One', 'Two']\nassert op_uniqs_sortlen_title(['x']) == ['X']\nassert op_uniqs_sortlen_title(['abc', 'de', '']) == ['', 'De', 'Abc']"}
{"id": "op_halve_add10_evens", "entry_point": "op_halve_add10_evens", "primitives": ["halve", "add10", "evens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then add ten to each, then keep the even numbers.", "solution": "def op_halve_add10_evens(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_halve_add10_evens([1, 2, 3, 4]) == [10, 12]\nassert op_halve_add10_evens([]) == []\nassert op_halve_add10_evens([-2, -1, 0, 1, 2]) == [10, 10]\nassert op_halve_add10_evens([5, 5, 5]) == [12, 12, 12]\nassert op_halve_add10_evens([3, 1, 2]) == [10]\nassert op_halve_add10_evens([10]) == []\nassert op_halve_add10_evens([2, 4, 6]) == [12]\nassert op_halve_add10_evens([-7, 12, -7]) == [6, 16, 6]"}
{"id": "op_cube_trimends_sortd", "entry_point": "op_cube_trimends_sortd", "primitives": ["cube", "trimends", "sortd"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the first and last elements, then sort descending.", "solution": "def op_cube_trimends_sortd(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_cube_trimends_sortd([1, 2, 3, 4]) == [27, 8]\nassert op_cube_trimends_sortd([]) == []\nassert op_cube_trimends_sortd([-2, -1, 0, 1, 2]) == [1, 0, -1]\nassert op_cube_trimends_sortd([5, 5, 5]) == [125]\nassert op_cube_trimends_sortd([3, 1, 2]) == [1]\nassert op_cube_trimends_sortd([10]) == []\nassert op_cube_trimends_sortd([2, 4, 6]) == [64]\nassert op_cube_trimends_sortd([-7, 12, -7]) == [1728]"}
{"id": "op_negate_cube_sortd", "entry_point": "op_negate_cube_sortd", "primitives": ["negate", "cube", "sortd"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then cube each, then sort descending.", "solution": "def op_negate_cube_sortd(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x ** 3 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_negate_cube_sortd([1, 2, 3, 4]) == [-1, -8, -27, -64]\nassert op_negate_cube_sortd([]) == []\nassert op_negate_cube_sortd([-2, -1, 0, 1, 2]) == [8, 1, 0, -1, -8]\nassert op_negate_cube_sortd([5, 5, 5]) == [-125, -125, -125]\nassert op_negate_cube_sortd([3, 1, 2]) == [-1, -8, -27]\nassert op_negate_cube_sortd([10]) == [-1000]\nassert op_negate_cube_sortd([2, 4, 6]) == [-8, -64, -216]\nassert op_negate_cube_sortd([-7, 12, -7]) == [343, 343, -1728]"}
{"id": "op_cube_div3_issorted", "entry_point": "op_cube_div3_issorted", "primitives": ["cube", "div3", "issorted"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep multiples of three, then return whether the list is sorted ascending.", "solution": "def op_cube_div3_issorted(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r == sorted(r)", "tests": "assert op_cube_div3_issorted([1, 2, 3, 4]) == True\nassert op_cube_div3_issorted([]) == True\nassert op_cube_div3_issorted([-2, -1, 0, 1, 2]) == True\nassert op_cube_div3_issorted([5, 5, 5]) == True\nassert op_cube_div3_issorted([3, 1, 2]) == True\nassert op_cube_div3_issorted([10]) == True\nassert op_cube_div3_issorted([2, 4, 6]) == True\nassert op_cube_div3_issorted([-7, 12, -7]) == True"}
{"id": "op_halve_dropfirst_max", "entry_point": "op_halve_dropfirst_max", "primitives": ["halve", "dropfirst", "max"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the first element, then return the maximum (0 if empty).", "solution": "def op_halve_dropfirst_max(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[1:]\n    return max(r) if r else 0", "tests": "assert op_halve_dropfirst_max([1, 2, 3, 4]) == 2\nassert op_halve_dropfirst_max([]) == 0\nassert op_halve_dropfirst_max([-2, -1, 0, 1, 2]) == 1\nassert op_halve_dropfirst_max([5, 5, 5]) == 2\nassert op_halve_dropfirst_max([3, 1, 2]) == 1\nassert op_halve_dropfirst_max([10]) == 0\nassert op_halve_dropfirst_max([2, 4, 6]) == 3\nassert op_halve_dropfirst_max([-7, 12, -7]) == 6"}
{"id": "op_div3_cube_halve", "entry_point": "op_div3_cube_halve", "primitives": ["div3", "cube", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then cube each, then halve each (integer division).", "solution": "def op_div3_cube_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x ** 3 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_div3_cube_halve([1, 2, 3, 4]) == [13]\nassert op_div3_cube_halve([]) == []\nassert op_div3_cube_halve([-2, -1, 0, 1, 2]) == [0]\nassert op_div3_cube_halve([5, 5, 5]) == []\nassert op_div3_cube_halve([3, 1, 2]) == [13]\nassert op_div3_cube_halve([10]) == []\nassert op_div3_cube_halve([2, 4, 6]) == [108]\nassert op_div3_cube_halve([-7, 12, -7]) == [864]"}
{"id": "op_first3_rev_halve", "entry_point": "op_first3_rev_halve", "primitives": ["first3", "rev", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then reverse the order, then halve each (integer division).", "solution": "def op_first3_rev_halve(xs):\n    r = list(xs)\n    r = r[:3]\n    r = list(reversed(r))\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_first3_rev_halve([1, 2, 3, 4]) == [1, 1, 0]\nassert op_first3_rev_halve([]) == []\nassert op_first3_rev_halve([-2, -1, 0, 1, 2]) == [0, -1, -1]\nassert op_first3_rev_halve([5, 5, 5]) == [2, 2, 2]\nassert op_first3_rev_halve([3, 1, 2]) == [1, 0, 1]\nassert op_first3_rev_halve([10]) == [5]\nassert op_first3_rev_halve([2, 4, 6]) == [3, 2, 1]\nassert op_first3_rev_halve([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_revstr_nonempty_prefixup", "entry_point": "op_revstr_nonempty_prefixup", "primitives": ["revstr", "nonempty", "prefixup"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then drop empty strings, then prefix each with a hash.", "solution": "def op_revstr_nonempty_prefixup(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_revstr_nonempty_prefixup(['Hello', 'world']) == ['#olleH', '#dlrow']\nassert op_revstr_nonempty_prefixup([]) == []\nassert op_revstr_nonempty_prefixup(['  a ', '', 'BC', 'bc']) == ['# a  ', '#CB', '#cb']\nassert op_revstr_nonempty_prefixup(['one', 'one', 'Two']) == ['#eno', '#eno', '#owT']\nassert op_revstr_nonempty_prefixup(['x']) == ['#x']\nassert op_revstr_nonempty_prefixup(['abc', 'de', '']) == ['#cba', '#ed']"}
{"id": "op_neg_cube_evens", "entry_point": "op_neg_cube_evens", "primitives": ["neg", "cube", "evens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cube each, then keep the even numbers.", "solution": "def op_neg_cube_evens(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_neg_cube_evens([1, 2, 3, 4]) == []\nassert op_neg_cube_evens([]) == []\nassert op_neg_cube_evens([-2, -1, 0, 1, 2]) == [-8]\nassert op_neg_cube_evens([5, 5, 5]) == []\nassert op_neg_cube_evens([3, 1, 2]) == []\nassert op_neg_cube_evens([10]) == []\nassert op_neg_cube_evens([2, 4, 6]) == []\nassert op_neg_cube_evens([-7, 12, -7]) == []"}
{"id": "op_neg_padto3_cube", "entry_point": "op_neg_padto3_cube", "primitives": ["neg", "padto3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then pad with zeros to at least three elements, then cube each.", "solution": "def op_neg_padto3_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_neg_padto3_cube([1, 2, 3, 4]) == [0, 0, 0]\nassert op_neg_padto3_cube([]) == [0, 0, 0]\nassert op_neg_padto3_cube([-2, -1, 0, 1, 2]) == [-8, -1, 0]\nassert op_neg_padto3_cube([5, 5, 5]) == [0, 0, 0]\nassert op_neg_padto3_cube([3, 1, 2]) == [0, 0, 0]\nassert op_neg_padto3_cube([10]) == [0, 0, 0]\nassert op_neg_padto3_cube([2, 4, 6]) == [0, 0, 0]\nassert op_neg_padto3_cube([-7, 12, -7]) == [-343, -343, 0]"}
{"id": "op_dropzeros_dropwhileneg_cube", "entry_point": "op_dropzeros_dropwhileneg_cube", "primitives": ["dropzeros", "dropwhileneg", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then drop the leading negative values, then cube each.", "solution": "def op_dropzeros_dropwhileneg_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropzeros_dropwhileneg_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_dropzeros_dropwhileneg_cube([]) == []\nassert op_dropzeros_dropwhileneg_cube([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_dropzeros_dropwhileneg_cube([5, 5, 5]) == [125, 125, 125]\nassert op_dropzeros_dropwhileneg_cube([3, 1, 2]) == [27, 1, 8]\nassert op_dropzeros_dropwhileneg_cube([10]) == [1000]\nassert op_dropzeros_dropwhileneg_cube([2, 4, 6]) == [8, 64, 216]\nassert op_dropzeros_dropwhileneg_cube([-7, 12, -7]) == [1728, -343]"}
{"id": "op_padto3_dropzeros_range_", "entry_point": "op_padto3_dropzeros_range_", "primitives": ["padto3", "dropzeros", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros, then return the range (max minus min, 0 if empty).", "solution": "def op_padto3_dropzeros_range_(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_padto3_dropzeros_range_([1, 2, 3, 4]) == 3\nassert op_padto3_dropzeros_range_([]) == 0\nassert op_padto3_dropzeros_range_([-2, -1, 0, 1, 2]) == 4\nassert op_padto3_dropzeros_range_([5, 5, 5]) == 0\nassert op_padto3_dropzeros_range_([3, 1, 2]) == 2\nassert op_padto3_dropzeros_range_([10]) == 0\nassert op_padto3_dropzeros_range_([2, 4, 6]) == 4\nassert op_padto3_dropzeros_range_([-7, 12, -7]) == 19"}
{"id": "op_revstr_strip_lens", "entry_point": "op_revstr_strip_lens", "primitives": ["revstr", "strip", "lens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then trim whitespace from each, then return the total number of characters.", "solution": "def op_revstr_strip_lens(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.strip() for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_revstr_strip_lens(['Hello', 'world']) == 10\nassert op_revstr_strip_lens([]) == 0\nassert op_revstr_strip_lens(['  a ', '', 'BC', 'bc']) == 5\nassert op_revstr_strip_lens(['one', 'one', 'Two']) == 9\nassert op_revstr_strip_lens(['x']) == 1\nassert op_revstr_strip_lens(['abc', 'de', '']) == 5"}
{"id": "op_absval_halve_inc", "entry_point": "op_absval_halve_inc", "primitives": ["absval", "halve", "inc"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then halve each (integer division), then add one to each.", "solution": "def op_absval_halve_inc(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x // 2 for x in r]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_absval_halve_inc([1, 2, 3, 4]) == [1, 2, 2, 3]\nassert op_absval_halve_inc([]) == []\nassert op_absval_halve_inc([-2, -1, 0, 1, 2]) == [2, 1, 1, 1, 2]\nassert op_absval_halve_inc([5, 5, 5]) == [3, 3, 3]\nassert op_absval_halve_inc([3, 1, 2]) == [2, 1, 2]\nassert op_absval_halve_inc([10]) == [6]\nassert op_absval_halve_inc([2, 4, 6]) == [2, 3, 4]\nassert op_absval_halve_inc([-7, 12, -7]) == [4, 7, 4]"}
{"id": "op_pos_halve_sortd", "entry_point": "op_pos_halve_sortd", "primitives": ["pos", "halve", "sortd"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then halve each (integer division), then sort descending.", "solution": "def op_pos_halve_sortd(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x // 2 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_pos_halve_sortd([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_pos_halve_sortd([]) == []\nassert op_pos_halve_sortd([-2, -1, 0, 1, 2]) == [1, 0]\nassert op_pos_halve_sortd([5, 5, 5]) == [2, 2, 2]\nassert op_pos_halve_sortd([3, 1, 2]) == [1, 1, 0]\nassert op_pos_halve_sortd([10]) == [5]\nassert op_pos_halve_sortd([2, 4, 6]) == [3, 2, 1]\nassert op_pos_halve_sortd([-7, 12, -7]) == [6]"}
{"id": "op_negate_cube_takewhilepos", "entry_point": "op_negate_cube_takewhilepos", "primitives": ["negate", "cube", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then cube each, then take values while they are positive.", "solution": "def op_negate_cube_takewhilepos(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x ** 3 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_negate_cube_takewhilepos([1, 2, 3, 4]) == []\nassert op_negate_cube_takewhilepos([]) == []\nassert op_negate_cube_takewhilepos([-2, -1, 0, 1, 2]) == [8, 1]\nassert op_negate_cube_takewhilepos([5, 5, 5]) == []\nassert op_negate_cube_takewhilepos([3, 1, 2]) == []\nassert op_negate_cube_takewhilepos([10]) == []\nassert op_negate_cube_takewhilepos([2, 4, 6]) == []\nassert op_negate_cube_takewhilepos([-7, 12, -7]) == [343]"}
{"id": "op_beforezero_halve_counteven", "entry_point": "op_beforezero_halve_counteven", "primitives": ["beforezero", "halve", "counteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then halve each (integer division), then return how many values are even.", "solution": "def op_beforezero_halve_counteven(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x // 2 for x in r]\n    return sum(1 for x in r if x % 2 == 0)", "tests": "assert op_beforezero_halve_counteven([1, 2, 3, 4]) == 2\nassert op_beforezero_halve_counteven([]) == 0\nassert op_beforezero_halve_counteven([-2, -1, 0, 1, 2]) == 0\nassert op_beforezero_halve_counteven([5, 5, 5]) == 3\nassert op_beforezero_halve_counteven([3, 1, 2]) == 1\nassert op_beforezero_halve_counteven([10]) == 0\nassert op_beforezero_halve_counteven([2, 4, 6]) == 1\nassert op_beforezero_halve_counteven([-7, 12, -7]) == 3"}
{"id": "op_halve_absval_dropfirst", "entry_point": "op_halve_absval_dropfirst", "primitives": ["halve", "absval", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then take the absolute value of each, then drop the first element.", "solution": "def op_halve_absval_dropfirst(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [abs(x) for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_halve_absval_dropfirst([1, 2, 3, 4]) == [1, 1, 2]\nassert op_halve_absval_dropfirst([]) == []\nassert op_halve_absval_dropfirst([-2, -1, 0, 1, 2]) == [1, 0, 0, 1]\nassert op_halve_absval_dropfirst([5, 5, 5]) == [2, 2]\nassert op_halve_absval_dropfirst([3, 1, 2]) == [0, 1]\nassert op_halve_absval_dropfirst([10]) == []\nassert op_halve_absval_dropfirst([2, 4, 6]) == [2, 3]\nassert op_halve_absval_dropfirst([-7, 12, -7]) == [6, 4]"}
{"id": "op_double_halve_prod", "entry_point": "op_double_halve_prod", "primitives": ["double", "halve", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then halve each (integer division), then return their product.", "solution": "def op_double_halve_prod(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x // 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_double_halve_prod([1, 2, 3, 4]) == 24\nassert op_double_halve_prod([]) == 1\nassert op_double_halve_prod([-2, -1, 0, 1, 2]) == 0\nassert op_double_halve_prod([5, 5, 5]) == 125\nassert op_double_halve_prod([3, 1, 2]) == 6\nassert op_double_halve_prod([10]) == 10\nassert op_double_halve_prod([2, 4, 6]) == 48\nassert op_double_halve_prod([-7, 12, -7]) == 588"}
{"id": "op_halve_pos_double", "entry_point": "op_halve_pos_double", "primitives": ["halve", "pos", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the positive numbers, then double each.", "solution": "def op_halve_pos_double(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_halve_pos_double([1, 2, 3, 4]) == [2, 2, 4]\nassert op_halve_pos_double([]) == []\nassert op_halve_pos_double([-2, -1, 0, 1, 2]) == [2]\nassert op_halve_pos_double([5, 5, 5]) == [4, 4, 4]\nassert op_halve_pos_double([3, 1, 2]) == [2, 2]\nassert op_halve_pos_double([10]) == [10]\nassert op_halve_pos_double([2, 4, 6]) == [2, 4, 6]\nassert op_halve_pos_double([-7, 12, -7]) == [12]"}
{"id": "op_dropzeros_negate_range_", "entry_point": "op_dropzeros_negate_range_", "primitives": ["dropzeros", "negate", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then negate each, then return the range (max minus min, 0 if empty).", "solution": "def op_dropzeros_negate_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [-x for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropzeros_negate_range_([1, 2, 3, 4]) == 3\nassert op_dropzeros_negate_range_([]) == 0\nassert op_dropzeros_negate_range_([-2, -1, 0, 1, 2]) == 4\nassert op_dropzeros_negate_range_([5, 5, 5]) == 0\nassert op_dropzeros_negate_range_([3, 1, 2]) == 2\nassert op_dropzeros_negate_range_([10]) == 0\nassert op_dropzeros_negate_range_([2, 4, 6]) == 4\nassert op_dropzeros_negate_range_([-7, 12, -7]) == 19"}
{"id": "op_sorta_cube_sortabs", "entry_point": "op_sorta_cube_sortabs", "primitives": ["sorta", "cube", "sortabs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then cube each, then sort by absolute value.", "solution": "def op_sorta_cube_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x ** 3 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_cube_sortabs([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_sorta_cube_sortabs([]) == []\nassert op_sorta_cube_sortabs([-2, -1, 0, 1, 2]) == [0, -1, 1, -8, 8]\nassert op_sorta_cube_sortabs([5, 5, 5]) == [125, 125, 125]\nassert op_sorta_cube_sortabs([3, 1, 2]) == [1, 8, 27]\nassert op_sorta_cube_sortabs([10]) == [1000]\nassert op_sorta_cube_sortabs([2, 4, 6]) == [8, 64, 216]\nassert op_sorta_cube_sortabs([-7, 12, -7]) == [-343, -343, 1728]"}
{"id": "op_inc_halve_double", "entry_point": "op_inc_halve_double", "primitives": ["inc", "halve", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then halve each (integer division), then double each.", "solution": "def op_inc_halve_double(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x // 2 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_inc_halve_double([1, 2, 3, 4]) == [2, 2, 4, 4]\nassert op_inc_halve_double([]) == []\nassert op_inc_halve_double([-2, -1, 0, 1, 2]) == [-2, 0, 0, 2, 2]\nassert op_inc_halve_double([5, 5, 5]) == [6, 6, 6]\nassert op_inc_halve_double([3, 1, 2]) == [4, 2, 2]\nassert op_inc_halve_double([10]) == [10]\nassert op_inc_halve_double([2, 4, 6]) == [2, 4, 6]\nassert op_inc_halve_double([-7, 12, -7]) == [-6, 12, -6]"}
{"id": "op_pos_cube_firsteven", "entry_point": "op_pos_cube_firsteven", "primitives": ["pos", "cube", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cube each, then return the first even value (0 if none).", "solution": "def op_pos_cube_firsteven(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x ** 3 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_pos_cube_firsteven([1, 2, 3, 4]) == 8\nassert op_pos_cube_firsteven([]) == 0\nassert op_pos_cube_firsteven([-2, -1, 0, 1, 2]) == 8\nassert op_pos_cube_firsteven([5, 5, 5]) == 0\nassert op_pos_cube_firsteven([3, 1, 2]) == 8\nassert op_pos_cube_firsteven([10]) == 1000\nassert op_pos_cube_firsteven([2, 4, 6]) == 8\nassert op_pos_cube_firsteven([-7, 12, -7]) == 1728"}
{"id": "op_halve_neg_anyeven", "entry_point": "op_halve_neg_anyeven", "primitives": ["halve", "neg", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the negative numbers, then return whether any value is even.", "solution": "def op_halve_neg_anyeven(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x < 0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_halve_neg_anyeven([1, 2, 3, 4]) == False\nassert op_halve_neg_anyeven([]) == False\nassert op_halve_neg_anyeven([-2, -1, 0, 1, 2]) == False\nassert op_halve_neg_anyeven([5, 5, 5]) == False\nassert op_halve_neg_anyeven([3, 1, 2]) == False\nassert op_halve_neg_anyeven([10]) == False\nassert op_halve_neg_anyeven([2, 4, 6]) == False\nassert op_halve_neg_anyeven([-7, 12, -7]) == True"}
{"id": "op_clamp10_square_range_", "entry_point": "op_clamp10_square_range_", "primitives": ["clamp10", "square", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then square each, then return the range (max minus min, 0 if empty).", "solution": "def op_clamp10_square_range_(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x * x for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_clamp10_square_range_([1, 2, 3, 4]) == 15\nassert op_clamp10_square_range_([]) == 0\nassert op_clamp10_square_range_([-2, -1, 0, 1, 2]) == 4\nassert op_clamp10_square_range_([5, 5, 5]) == 0\nassert op_clamp10_square_range_([3, 1, 2]) == 8\nassert op_clamp10_square_range_([10]) == 0\nassert op_clamp10_square_range_([2, 4, 6]) == 32\nassert op_clamp10_square_range_([-7, 12, -7]) == 51"}
{"id": "op_double_cube_rev", "entry_point": "op_double_cube_rev", "primitives": ["double", "cube", "rev"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then cube each, then reverse the order.", "solution": "def op_double_cube_rev(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x ** 3 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_double_cube_rev([1, 2, 3, 4]) == [512, 216, 64, 8]\nassert op_double_cube_rev([]) == []\nassert op_double_cube_rev([-2, -1, 0, 1, 2]) == [64, 8, 0, -8, -64]\nassert op_double_cube_rev([5, 5, 5]) == [1000, 1000, 1000]\nassert op_double_cube_rev([3, 1, 2]) == [64, 8, 216]\nassert op_double_cube_rev([10]) == [8000]\nassert op_double_cube_rev([2, 4, 6]) == [1728, 512, 64]\nassert op_double_cube_rev([-7, 12, -7]) == [-2744, 13824, -2744]"}
{"id": "op_dropfirst_halve_dropwhileneg", "entry_point": "op_dropfirst_halve_dropwhileneg", "primitives": ["dropfirst", "halve", "dropwhileneg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then halve each (integer division), then drop the leading negative values.", "solution": "def op_dropfirst_halve_dropwhileneg(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x // 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_dropfirst_halve_dropwhileneg([1, 2, 3, 4]) == [1, 1, 2]\nassert op_dropfirst_halve_dropwhileneg([]) == []\nassert op_dropfirst_halve_dropwhileneg([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_dropfirst_halve_dropwhileneg([5, 5, 5]) == [2, 2]\nassert op_dropfirst_halve_dropwhileneg([3, 1, 2]) == [0, 1]\nassert op_dropfirst_halve_dropwhileneg([10]) == []\nassert op_dropfirst_halve_dropwhileneg([2, 4, 6]) == [2, 3]\nassert op_dropfirst_halve_dropwhileneg([-7, 12, -7]) == [6, -4]"}
{"id": "op_oremptyzero_cube_dropzeros", "entry_point": "op_oremptyzero_cube_dropzeros", "primitives": ["oremptyzero", "cube", "dropzeros"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then cube each, then drop the zeros.", "solution": "def op_oremptyzero_cube_dropzeros(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_oremptyzero_cube_dropzeros([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_oremptyzero_cube_dropzeros([]) == []\nassert op_oremptyzero_cube_dropzeros([-2, -1, 0, 1, 2]) == [-8, -1, 1, 8]\nassert op_oremptyzero_cube_dropzeros([5, 5, 5]) == [125, 125, 125]\nassert op_oremptyzero_cube_dropzeros([3, 1, 2]) == [27, 1, 8]\nassert op_oremptyzero_cube_dropzeros([10]) == [1000]\nassert op_oremptyzero_cube_dropzeros([2, 4, 6]) == [8, 64, 216]\nassert op_oremptyzero_cube_dropzeros([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_pos_halve_square", "entry_point": "op_pos_halve_square", "primitives": ["pos", "halve", "square"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then halve each (integer division), then square each.", "solution": "def op_pos_halve_square(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x // 2 for x in r]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_pos_halve_square([1, 2, 3, 4]) == [0, 1, 1, 4]\nassert op_pos_halve_square([]) == []\nassert op_pos_halve_square([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_halve_square([5, 5, 5]) == [4, 4, 4]\nassert op_pos_halve_square([3, 1, 2]) == [1, 0, 1]\nassert op_pos_halve_square([10]) == [25]\nassert op_pos_halve_square([2, 4, 6]) == [1, 4, 9]\nassert op_pos_halve_square([-7, 12, -7]) == [36]"}
{"id": "op_dropwhileneg_cube_sorta", "entry_point": "op_dropwhileneg_cube_sorta", "primitives": ["dropwhileneg", "cube", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then cube each, then sort ascending.", "solution": "def op_dropwhileneg_cube_sorta(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x ** 3 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_dropwhileneg_cube_sorta([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_dropwhileneg_cube_sorta([]) == []\nassert op_dropwhileneg_cube_sorta([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_dropwhileneg_cube_sorta([5, 5, 5]) == [125, 125, 125]\nassert op_dropwhileneg_cube_sorta([3, 1, 2]) == [1, 8, 27]\nassert op_dropwhileneg_cube_sorta([10]) == [1000]\nassert op_dropwhileneg_cube_sorta([2, 4, 6]) == [8, 64, 216]\nassert op_dropwhileneg_cube_sorta([-7, 12, -7]) == [-343, 1728]"}
{"id": "op_title_sortlen_strip", "entry_point": "op_title_sortlen_strip", "primitives": ["title", "sortlen", "strip"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then sort by length, shortest first, then trim whitespace from each.", "solution": "def op_title_sortlen_strip(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = sorted(r, key=len)\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_title_sortlen_strip(['Hello', 'world']) == ['Hello', 'World']\nassert op_title_sortlen_strip([]) == []\nassert op_title_sortlen_strip(['  a ', '', 'BC', 'bc']) == ['', 'Bc', 'Bc', 'A']\nassert op_title_sortlen_strip(['one', 'one', 'Two']) == ['One', 'One', 'Two']\nassert op_title_sortlen_strip(['x']) == ['X']\nassert op_title_sortlen_strip(['abc', 'de', '']) == ['', 'De', 'Abc']"}
{"id": "op_pos_takewhilepos_cube", "entry_point": "op_pos_takewhilepos_cube", "primitives": ["pos", "takewhilepos", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive, then cube each.", "solution": "def op_pos_takewhilepos_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_pos_takewhilepos_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_pos_takewhilepos_cube([]) == []\nassert op_pos_takewhilepos_cube([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_pos_takewhilepos_cube([5, 5, 5]) == [125, 125, 125]\nassert op_pos_takewhilepos_cube([3, 1, 2]) == [27, 1, 8]\nassert op_pos_takewhilepos_cube([10]) == [1000]\nassert op_pos_takewhilepos_cube([2, 4, 6]) == [8, 64, 216]\nassert op_pos_takewhilepos_cube([-7, 12, -7]) == [1728]"}
{"id": "op_double_cube_pos", "entry_point": "op_double_cube_pos", "primitives": ["double", "cube", "pos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then cube each, then keep the positive numbers.", "solution": "def op_double_cube_pos(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_double_cube_pos([1, 2, 3, 4]) == [8, 64, 216, 512]\nassert op_double_cube_pos([]) == []\nassert op_double_cube_pos([-2, -1, 0, 1, 2]) == [8, 64]\nassert op_double_cube_pos([5, 5, 5]) == [1000, 1000, 1000]\nassert op_double_cube_pos([3, 1, 2]) == [216, 8, 64]\nassert op_double_cube_pos([10]) == [8000]\nassert op_double_cube_pos([2, 4, 6]) == [64, 512, 1728]\nassert op_double_cube_pos([-7, 12, -7]) == [13824]"}
{"id": "op_title_dropshort_joinc", "entry_point": "op_title_dropshort_joinc", "primitives": ["title", "dropshort", "joinc"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then drop strings shorter than three characters, then join them with commas.", "solution": "def op_title_dropshort_joinc(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return ','.join(r)", "tests": "assert op_title_dropshort_joinc(['Hello', 'world']) == 'Hello,World'\nassert op_title_dropshort_joinc([]) == ''\nassert op_title_dropshort_joinc(['  a ', '', 'BC', 'bc']) == '  A '\nassert op_title_dropshort_joinc(['one', 'one', 'Two']) == 'One,One,Two'\nassert op_title_dropshort_joinc(['x']) == ''\nassert op_title_dropshort_joinc(['abc', 'de', '']) == 'Abc'"}
{"id": "op_cube_clamp10_neg", "entry_point": "op_cube_clamp10_neg", "primitives": ["cube", "clamp10", "neg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then cap each value at 10, then keep the negative numbers.", "solution": "def op_cube_clamp10_neg(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_cube_clamp10_neg([1, 2, 3, 4]) == []\nassert op_cube_clamp10_neg([]) == []\nassert op_cube_clamp10_neg([-2, -1, 0, 1, 2]) == [-8, -1]\nassert op_cube_clamp10_neg([5, 5, 5]) == []\nassert op_cube_clamp10_neg([3, 1, 2]) == []\nassert op_cube_clamp10_neg([10]) == []\nassert op_cube_clamp10_neg([2, 4, 6]) == []\nassert op_cube_clamp10_neg([-7, 12, -7]) == [-343, -343]"}
{"id": "op_last3_first3_cube", "entry_point": "op_last3_first3_cube", "primitives": ["last3", "first3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then keep only the first three, then cube each.", "solution": "def op_last3_first3_cube(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[:3]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_last3_first3_cube([1, 2, 3, 4]) == [8, 27, 64]\nassert op_last3_first3_cube([]) == []\nassert op_last3_first3_cube([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_last3_first3_cube([5, 5, 5]) == [125, 125, 125]\nassert op_last3_first3_cube([3, 1, 2]) == [27, 1, 8]\nassert op_last3_first3_cube([10]) == [1000]\nassert op_last3_first3_cube([2, 4, 6]) == [8, 64, 216]\nassert op_last3_first3_cube([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_halve_cube_evens", "entry_point": "op_halve_cube_evens", "primitives": ["halve", "cube", "evens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then cube each, then keep the even numbers.", "solution": "def op_halve_cube_evens(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_halve_cube_evens([1, 2, 3, 4]) == [0, 8]\nassert op_halve_cube_evens([]) == []\nassert op_halve_cube_evens([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_halve_cube_evens([5, 5, 5]) == [8, 8, 8]\nassert op_halve_cube_evens([3, 1, 2]) == [0]\nassert op_halve_cube_evens([10]) == []\nassert op_halve_cube_evens([2, 4, 6]) == [8]\nassert op_halve_cube_evens([-7, 12, -7]) == [-64, 216, -64]"}
{"id": "op_cube_double_odds", "entry_point": "op_cube_double_odds", "primitives": ["cube", "double", "odds"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then double each, then keep the odd numbers.", "solution": "def op_cube_double_odds(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_cube_double_odds([1, 2, 3, 4]) == []\nassert op_cube_double_odds([]) == []\nassert op_cube_double_odds([-2, -1, 0, 1, 2]) == []\nassert op_cube_double_odds([5, 5, 5]) == []\nassert op_cube_double_odds([3, 1, 2]) == []\nassert op_cube_double_odds([10]) == []\nassert op_cube_double_odds([2, 4, 6]) == []\nassert op_cube_double_odds([-7, 12, -7]) == []"}
{"id": "op_ages_first3_halve", "entry_point": "op_ages_first3_halve", "primitives": ["ages", "first3", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then keep only the first three, then halve each (integer division).", "solution": "def op_ages_first3_halve(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = r[:3]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_ages_first3_halve([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [18, 6]\nassert op_ages_first3_halve([]) == []\nassert op_ages_first3_halve([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [9, 32, 8]\nassert op_ages_first3_halve([{'name': 'Fi', 'age': 41}]) == [20]"}
{"id": "op_cube_neg_first3", "entry_point": "op_cube_neg_first3", "primitives": ["cube", "neg", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the negative numbers, then keep only the first three.", "solution": "def op_cube_neg_first3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x < 0]\n    r = r[:3]\n    return r", "tests": "assert op_cube_neg_first3([1, 2, 3, 4]) == []\nassert op_cube_neg_first3([]) == []\nassert op_cube_neg_first3([-2, -1, 0, 1, 2]) == [-8, -1]\nassert op_cube_neg_first3([5, 5, 5]) == []\nassert op_cube_neg_first3([3, 1, 2]) == []\nassert op_cube_neg_first3([10]) == []\nassert op_cube_neg_first3([2, 4, 6]) == []\nassert op_cube_neg_first3([-7, 12, -7]) == [-343, -343]"}
{"id": "op_revstr_uniqs_anyempty", "entry_point": "op_revstr_uniqs_anyempty", "primitives": ["revstr", "uniqs", "anyempty"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then drop duplicate strings keeping the first, then return whether any string is empty.", "solution": "def op_revstr_uniqs_anyempty(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = list(dict.fromkeys(r))\n    return any(s == '' for s in r)", "tests": "assert op_revstr_uniqs_anyempty(['Hello', 'world']) == False\nassert op_revstr_uniqs_anyempty([]) == False\nassert op_revstr_uniqs_anyempty(['  a ', '', 'BC', 'bc']) == True\nassert op_revstr_uniqs_anyempty(['one', 'one', 'Two']) == False\nassert op_revstr_uniqs_anyempty(['x']) == False\nassert op_revstr_uniqs_anyempty(['abc', 'de', '']) == True"}
{"id": "op_halve_clamp10_oremptyzero", "entry_point": "op_halve_clamp10_oremptyzero", "primitives": ["halve", "clamp10", "oremptyzero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then cap each value at 10, then if empty, use a single zero.", "solution": "def op_halve_clamp10_oremptyzero(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_halve_clamp10_oremptyzero([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_halve_clamp10_oremptyzero([]) == [0]\nassert op_halve_clamp10_oremptyzero([-2, -1, 0, 1, 2]) == [-1, -1, 0, 0, 1]\nassert op_halve_clamp10_oremptyzero([5, 5, 5]) == [2, 2, 2]\nassert op_halve_clamp10_oremptyzero([3, 1, 2]) == [1, 0, 1]\nassert op_halve_clamp10_oremptyzero([10]) == [5]\nassert op_halve_clamp10_oremptyzero([2, 4, 6]) == [1, 2, 3]\nassert op_halve_clamp10_oremptyzero([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_cube_beforezero_takewhilepos", "entry_point": "op_cube_beforezero_takewhilepos", "primitives": ["cube", "beforezero", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep everything before the first zero, then take values while they are positive.", "solution": "def op_cube_beforezero_takewhilepos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_cube_beforezero_takewhilepos([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_cube_beforezero_takewhilepos([]) == []\nassert op_cube_beforezero_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_cube_beforezero_takewhilepos([5, 5, 5]) == [125, 125, 125]\nassert op_cube_beforezero_takewhilepos([3, 1, 2]) == [27, 1, 8]\nassert op_cube_beforezero_takewhilepos([10]) == [1000]\nassert op_cube_beforezero_takewhilepos([2, 4, 6]) == [8, 64, 216]\nassert op_cube_beforezero_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_cube_trimends_uniq", "entry_point": "op_cube_trimends_uniq", "primitives": ["cube", "trimends", "uniq"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the first and last elements, then drop duplicates keeping first occurrence.", "solution": "def op_cube_trimends_uniq(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_cube_trimends_uniq([1, 2, 3, 4]) == [8, 27]\nassert op_cube_trimends_uniq([]) == []\nassert op_cube_trimends_uniq([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_cube_trimends_uniq([5, 5, 5]) == [125]\nassert op_cube_trimends_uniq([3, 1, 2]) == [1]\nassert op_cube_trimends_uniq([10]) == []\nassert op_cube_trimends_uniq([2, 4, 6]) == [64]\nassert op_cube_trimends_uniq([-7, 12, -7]) == [1728]"}
{"id": "op_oremptyzero_square_halve", "entry_point": "op_oremptyzero_square_halve", "primitives": ["oremptyzero", "square", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then square each, then halve each (integer division).", "solution": "def op_oremptyzero_square_halve(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x * x for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_square_halve([1, 2, 3, 4]) == [0, 2, 4, 8]\nassert op_oremptyzero_square_halve([]) == [0]\nassert op_oremptyzero_square_halve([-2, -1, 0, 1, 2]) == [2, 0, 0, 0, 2]\nassert op_oremptyzero_square_halve([5, 5, 5]) == [12, 12, 12]\nassert op_oremptyzero_square_halve([3, 1, 2]) == [4, 0, 2]\nassert op_oremptyzero_square_halve([10]) == [50]\nassert op_oremptyzero_square_halve([2, 4, 6]) == [2, 8, 18]\nassert op_oremptyzero_square_halve([-7, 12, -7]) == [24, 72, 24]"}
{"id": "op_pos_cube_dropwhileneg", "entry_point": "op_pos_cube_dropwhileneg", "primitives": ["pos", "cube", "dropwhileneg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then cube each, then drop the leading negative values.", "solution": "def op_pos_cube_dropwhileneg(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = [x ** 3 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    return r", "tests": "assert op_pos_cube_dropwhileneg([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_pos_cube_dropwhileneg([]) == []\nassert op_pos_cube_dropwhileneg([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_pos_cube_dropwhileneg([5, 5, 5]) == [125, 125, 125]\nassert op_pos_cube_dropwhileneg([3, 1, 2]) == [27, 1, 8]\nassert op_pos_cube_dropwhileneg([10]) == [1000]\nassert op_pos_cube_dropwhileneg([2, 4, 6]) == [8, 64, 216]\nassert op_pos_cube_dropwhileneg([-7, 12, -7]) == [1728]"}
{"id": "op_sortabs_halve_prod", "entry_point": "op_sortabs_halve_prod", "primitives": ["sortabs", "halve", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then halve each (integer division), then return their product.", "solution": "def op_sortabs_halve_prod(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x // 2 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_sortabs_halve_prod([1, 2, 3, 4]) == 0\nassert op_sortabs_halve_prod([]) == 1\nassert op_sortabs_halve_prod([-2, -1, 0, 1, 2]) == 0\nassert op_sortabs_halve_prod([5, 5, 5]) == 8\nassert op_sortabs_halve_prod([3, 1, 2]) == 0\nassert op_sortabs_halve_prod([10]) == 5\nassert op_sortabs_halve_prod([2, 4, 6]) == 6\nassert op_sortabs_halve_prod([-7, 12, -7]) == 96"}
{"id": "op_cube_uniq_dropfirst", "entry_point": "op_cube_uniq_dropfirst", "primitives": ["cube", "uniq", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop duplicates keeping first occurrence, then drop the first element.", "solution": "def op_cube_uniq_dropfirst(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = list(dict.fromkeys(r))\n    r = r[1:]\n    return r", "tests": "assert op_cube_uniq_dropfirst([1, 2, 3, 4]) == [8, 27, 64]\nassert op_cube_uniq_dropfirst([]) == []\nassert op_cube_uniq_dropfirst([-2, -1, 0, 1, 2]) == [-1, 0, 1, 8]\nassert op_cube_uniq_dropfirst([5, 5, 5]) == []\nassert op_cube_uniq_dropfirst([3, 1, 2]) == [1, 8]\nassert op_cube_uniq_dropfirst([10]) == []\nassert op_cube_uniq_dropfirst([2, 4, 6]) == [64, 216]\nassert op_cube_uniq_dropfirst([-7, 12, -7]) == [1728]"}
{"id": "op_halve_sortd_negate", "entry_point": "op_halve_sortd_negate", "primitives": ["halve", "sortd", "negate"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then sort descending, then negate each.", "solution": "def op_halve_sortd_negate(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = sorted(r, reverse=True)\n    r = [-x for x in r]\n    return r", "tests": "assert op_halve_sortd_negate([1, 2, 3, 4]) == [-2, -1, -1, 0]\nassert op_halve_sortd_negate([]) == []\nassert op_halve_sortd_negate([-2, -1, 0, 1, 2]) == [-1, 0, 0, 1, 1]\nassert op_halve_sortd_negate([5, 5, 5]) == [-2, -2, -2]\nassert op_halve_sortd_negate([3, 1, 2]) == [-1, -1, 0]\nassert op_halve_sortd_negate([10]) == [-5]\nassert op_halve_sortd_negate([2, 4, 6]) == [-3, -2, -1]\nassert op_halve_sortd_negate([-7, 12, -7]) == [-6, 4, 4]"}
{"id": "op_gt5_add10_range_", "entry_point": "op_gt5_add10_range_", "primitives": ["gt5", "add10", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then add ten to each, then return the range (max minus min, 0 if empty).", "solution": "def op_gt5_add10_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = [x + 10 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_gt5_add10_range_([1, 2, 3, 4]) == 0\nassert op_gt5_add10_range_([]) == 0\nassert op_gt5_add10_range_([-2, -1, 0, 1, 2]) == 0\nassert op_gt5_add10_range_([5, 5, 5]) == 0\nassert op_gt5_add10_range_([3, 1, 2]) == 0\nassert op_gt5_add10_range_([10]) == 0\nassert op_gt5_add10_range_([2, 4, 6]) == 0\nassert op_gt5_add10_range_([-7, 12, -7]) == 0"}
{"id": "op_sortabs_halve_takewhilepos", "entry_point": "op_sortabs_halve_takewhilepos", "primitives": ["sortabs", "halve", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then halve each (integer division), then take values while they are positive.", "solution": "def op_sortabs_halve_takewhilepos(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x // 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_sortabs_halve_takewhilepos([1, 2, 3, 4]) == []\nassert op_sortabs_halve_takewhilepos([]) == []\nassert op_sortabs_halve_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_sortabs_halve_takewhilepos([5, 5, 5]) == [2, 2, 2]\nassert op_sortabs_halve_takewhilepos([3, 1, 2]) == []\nassert op_sortabs_halve_takewhilepos([10]) == [5]\nassert op_sortabs_halve_takewhilepos([2, 4, 6]) == [1, 2, 3]\nassert op_sortabs_halve_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_takewhilepos_padto3_halve", "entry_point": "op_takewhilepos_padto3_halve", "primitives": ["takewhilepos", "padto3", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then pad with zeros to at least three elements, then halve each (integer division).", "solution": "def op_takewhilepos_padto3_halve(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_takewhilepos_padto3_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_takewhilepos_padto3_halve([]) == [0, 0, 0]\nassert op_takewhilepos_padto3_halve([-2, -1, 0, 1, 2]) == [0, 0, 0]\nassert op_takewhilepos_padto3_halve([5, 5, 5]) == [2, 2, 2]\nassert op_takewhilepos_padto3_halve([3, 1, 2]) == [1, 0, 1]\nassert op_takewhilepos_padto3_halve([10]) == [5, 0, 0]\nassert op_takewhilepos_padto3_halve([2, 4, 6]) == [1, 2, 3]\nassert op_takewhilepos_padto3_halve([-7, 12, -7]) == [0, 0, 0]"}
{"id": "op_cube_beforezero_clamp10", "entry_point": "op_cube_beforezero_clamp10", "primitives": ["cube", "beforezero", "clamp10"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep everything before the first zero, then cap each value at 10.", "solution": "def op_cube_beforezero_clamp10(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_cube_beforezero_clamp10([1, 2, 3, 4]) == [1, 8, 10, 10]\nassert op_cube_beforezero_clamp10([]) == []\nassert op_cube_beforezero_clamp10([-2, -1, 0, 1, 2]) == [-8, -1]\nassert op_cube_beforezero_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_cube_beforezero_clamp10([3, 1, 2]) == [10, 1, 8]\nassert op_cube_beforezero_clamp10([10]) == [10]\nassert op_cube_beforezero_clamp10([2, 4, 6]) == [8, 10, 10]\nassert op_cube_beforezero_clamp10([-7, 12, -7]) == [-343, 10, -343]"}
{"id": "op_add10_dropzeros_range_", "entry_point": "op_add10_dropzeros_range_", "primitives": ["add10", "dropzeros", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add ten to each, then drop the zeros, then return the range (max minus min, 0 if empty).", "solution": "def op_add10_dropzeros_range_(xs):\n    r = list(xs)\n    r = [x + 10 for x in r]\n    r = [x for x in r if x != 0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_add10_dropzeros_range_([1, 2, 3, 4]) == 3\nassert op_add10_dropzeros_range_([]) == 0\nassert op_add10_dropzeros_range_([-2, -1, 0, 1, 2]) == 4\nassert op_add10_dropzeros_range_([5, 5, 5]) == 0\nassert op_add10_dropzeros_range_([3, 1, 2]) == 2\nassert op_add10_dropzeros_range_([10]) == 0\nassert op_add10_dropzeros_range_([2, 4, 6]) == 4\nassert op_add10_dropzeros_range_([-7, 12, -7]) == 19"}
{"id": "op_revstr_title_counts", "entry_point": "op_revstr_title_counts", "primitives": ["revstr", "title", "counts"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then title-case each string, then return how many strings remain.", "solution": "def op_revstr_title_counts(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.title() for s in r]\n    return len(r)", "tests": "assert op_revstr_title_counts(['Hello', 'world']) == 2\nassert op_revstr_title_counts([]) == 0\nassert op_revstr_title_counts(['  a ', '', 'BC', 'bc']) == 4\nassert op_revstr_title_counts(['one', 'one', 'Two']) == 3\nassert op_revstr_title_counts(['x']) == 1\nassert op_revstr_title_counts(['abc', 'de', '']) == 3"}
{"id": "op_sortabs_cube_gt5", "entry_point": "op_sortabs_cube_gt5", "primitives": ["sortabs", "cube", "gt5"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cube each, then keep values greater than five.", "solution": "def op_sortabs_cube_gt5(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_sortabs_cube_gt5([1, 2, 3, 4]) == [8, 27, 64]\nassert op_sortabs_cube_gt5([]) == []\nassert op_sortabs_cube_gt5([-2, -1, 0, 1, 2]) == [8]\nassert op_sortabs_cube_gt5([5, 5, 5]) == [125, 125, 125]\nassert op_sortabs_cube_gt5([3, 1, 2]) == [8, 27]\nassert op_sortabs_cube_gt5([10]) == [1000]\nassert op_sortabs_cube_gt5([2, 4, 6]) == [8, 64, 216]\nassert op_sortabs_cube_gt5([-7, 12, -7]) == [1728]"}
{"id": "op_inc_cube_div3", "entry_point": "op_inc_cube_div3", "primitives": ["inc", "cube", "div3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then cube each, then keep multiples of three.", "solution": "def op_inc_cube_div3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_inc_cube_div3([1, 2, 3, 4]) == [27]\nassert op_inc_cube_div3([]) == []\nassert op_inc_cube_div3([-2, -1, 0, 1, 2]) == [0, 27]\nassert op_inc_cube_div3([5, 5, 5]) == [216, 216, 216]\nassert op_inc_cube_div3([3, 1, 2]) == [27]\nassert op_inc_cube_div3([10]) == []\nassert op_inc_cube_div3([2, 4, 6]) == [27]\nassert op_inc_cube_div3([-7, 12, -7]) == [-216, -216]"}
{"id": "op_cube_evens_odds", "entry_point": "op_cube_evens_odds", "primitives": ["cube", "evens", "odds"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the even numbers, then keep the odd numbers.", "solution": "def op_cube_evens_odds(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_cube_evens_odds([1, 2, 3, 4]) == []\nassert op_cube_evens_odds([]) == []\nassert op_cube_evens_odds([-2, -1, 0, 1, 2]) == []\nassert op_cube_evens_odds([5, 5, 5]) == []\nassert op_cube_evens_odds([3, 1, 2]) == []\nassert op_cube_evens_odds([10]) == []\nassert op_cube_evens_odds([2, 4, 6]) == []\nassert op_cube_evens_odds([-7, 12, -7]) == []"}
{"id": "op_sortage_ages_halve", "entry_point": "op_sortage_ages_halve", "primitives": ["sortage", "ages", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); sort records by age, youngest first, then extract the ages, then halve each (integer division).", "solution": "def op_sortage_ages_halve(xs):\n    r = list(xs)\n    r = sorted(r, key=lambda d: d['age'])\n    r = [d['age'] for d in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_sortage_ages_halve([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [6, 18]\nassert op_sortage_ages_halve([]) == []\nassert op_sortage_ages_halve([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [8, 9, 32]\nassert op_sortage_ages_halve([{'name': 'Fi', 'age': 41}]) == [20]"}
{"id": "op_neg_cube_prod", "entry_point": "op_neg_cube_prod", "primitives": ["neg", "cube", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cube each, then return their product.", "solution": "def op_neg_cube_prod(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [x ** 3 for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_neg_cube_prod([1, 2, 3, 4]) == 1\nassert op_neg_cube_prod([]) == 1\nassert op_neg_cube_prod([-2, -1, 0, 1, 2]) == 8\nassert op_neg_cube_prod([5, 5, 5]) == 1\nassert op_neg_cube_prod([3, 1, 2]) == 1\nassert op_neg_cube_prod([10]) == 1\nassert op_neg_cube_prod([2, 4, 6]) == 1\nassert op_neg_cube_prod([-7, 12, -7]) == 117649"}
{"id": "op_cube_oremptyzero_trimends", "entry_point": "op_cube_oremptyzero_trimends", "primitives": ["cube", "oremptyzero", "trimends"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then if empty, use a single zero, then drop the first and last elements.", "solution": "def op_cube_oremptyzero_trimends(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r if r else [0]\n    r = r[1:-1]\n    return r", "tests": "assert op_cube_oremptyzero_trimends([1, 2, 3, 4]) == [8, 27]\nassert op_cube_oremptyzero_trimends([]) == []\nassert op_cube_oremptyzero_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_cube_oremptyzero_trimends([5, 5, 5]) == [125]\nassert op_cube_oremptyzero_trimends([3, 1, 2]) == [1]\nassert op_cube_oremptyzero_trimends([10]) == []\nassert op_cube_oremptyzero_trimends([2, 4, 6]) == [64]\nassert op_cube_oremptyzero_trimends([-7, 12, -7]) == [1728]"}
{"id": "op_halve_uniq_dropzeros", "entry_point": "op_halve_uniq_dropzeros", "primitives": ["halve", "uniq", "dropzeros"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop duplicates keeping first occurrence, then drop the zeros.", "solution": "def op_halve_uniq_dropzeros(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = list(dict.fromkeys(r))\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_halve_uniq_dropzeros([1, 2, 3, 4]) == [1, 2]\nassert op_halve_uniq_dropzeros([]) == []\nassert op_halve_uniq_dropzeros([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_halve_uniq_dropzeros([5, 5, 5]) == [2]\nassert op_halve_uniq_dropzeros([3, 1, 2]) == [1]\nassert op_halve_uniq_dropzeros([10]) == [5]\nassert op_halve_uniq_dropzeros([2, 4, 6]) == [1, 2, 3]\nassert op_halve_uniq_dropzeros([-7, 12, -7]) == [-4, 6]"}
{"id": "op_padto3_cube_sorta", "entry_point": "op_padto3_cube_sorta", "primitives": ["padto3", "cube", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then cube each, then sort ascending.", "solution": "def op_padto3_cube_sorta(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x ** 3 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_padto3_cube_sorta([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_padto3_cube_sorta([]) == [0, 0, 0]\nassert op_padto3_cube_sorta([-2, -1, 0, 1, 2]) == [-8, -1, 0, 1, 8]\nassert op_padto3_cube_sorta([5, 5, 5]) == [125, 125, 125]\nassert op_padto3_cube_sorta([3, 1, 2]) == [1, 8, 27]\nassert op_padto3_cube_sorta([10]) == [0, 0, 1000]\nassert op_padto3_cube_sorta([2, 4, 6]) == [8, 64, 216]\nassert op_padto3_cube_sorta([-7, 12, -7]) == [-343, -343, 1728]"}
{"id": "op_negate_cube_sortabs", "entry_point": "op_negate_cube_sortabs", "primitives": ["negate", "cube", "sortabs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then cube each, then sort by absolute value.", "solution": "def op_negate_cube_sortabs(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x ** 3 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_negate_cube_sortabs([1, 2, 3, 4]) == [-1, -8, -27, -64]\nassert op_negate_cube_sortabs([]) == []\nassert op_negate_cube_sortabs([-2, -1, 0, 1, 2]) == [0, 1, -1, 8, -8]\nassert op_negate_cube_sortabs([5, 5, 5]) == [-125, -125, -125]\nassert op_negate_cube_sortabs([3, 1, 2]) == [-1, -8, -27]\nassert op_negate_cube_sortabs([10]) == [-1000]\nassert op_negate_cube_sortabs([2, 4, 6]) == [-8, -64, -216]\nassert op_negate_cube_sortabs([-7, 12, -7]) == [343, 343, -1728]"}
{"id": "op_evens_halve_add10", "entry_point": "op_evens_halve_add10", "primitives": ["evens", "halve", "add10"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then halve each (integer division), then add ten to each.", "solution": "def op_evens_halve_add10(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    return r", "tests": "assert op_evens_halve_add10([1, 2, 3, 4]) == [11, 12]\nassert op_evens_halve_add10([]) == []\nassert op_evens_halve_add10([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_evens_halve_add10([5, 5, 5]) == []\nassert op_evens_halve_add10([3, 1, 2]) == [11]\nassert op_evens_halve_add10([10]) == [15]\nassert op_evens_halve_add10([2, 4, 6]) == [11, 12, 13]\nassert op_evens_halve_add10([-7, 12, -7]) == [16]"}
{"id": "op_sortd_sortabs_cube", "entry_point": "op_sortd_sortabs_cube", "primitives": ["sortd", "sortabs", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort descending, then sort by absolute value, then cube each.", "solution": "def op_sortd_sortabs_cube(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = sorted(r, key=abs)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_sortd_sortabs_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_sortd_sortabs_cube([]) == []\nassert op_sortd_sortabs_cube([-2, -1, 0, 1, 2]) == [0, 1, -1, 8, -8]\nassert op_sortd_sortabs_cube([5, 5, 5]) == [125, 125, 125]\nassert op_sortd_sortabs_cube([3, 1, 2]) == [1, 8, 27]\nassert op_sortd_sortabs_cube([10]) == [1000]\nassert op_sortd_sortabs_cube([2, 4, 6]) == [8, 64, 216]\nassert op_sortd_sortabs_cube([-7, 12, -7]) == [-343, -343, 1728]"}
{"id": "op_inc_evens_halve", "entry_point": "op_inc_evens_halve", "primitives": ["inc", "evens", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep the even numbers, then halve each (integer division).", "solution": "def op_inc_evens_halve(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_inc_evens_halve([1, 2, 3, 4]) == [1, 2]\nassert op_inc_evens_halve([]) == []\nassert op_inc_evens_halve([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_inc_evens_halve([5, 5, 5]) == [3, 3, 3]\nassert op_inc_evens_halve([3, 1, 2]) == [2, 1]\nassert op_inc_evens_halve([10]) == []\nassert op_inc_evens_halve([2, 4, 6]) == []\nassert op_inc_evens_halve([-7, 12, -7]) == [-3, -3]"}
{"id": "op_beforezero_inc_range_", "entry_point": "op_beforezero_inc_range_", "primitives": ["beforezero", "inc", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then add one to each, then return the range (max minus min, 0 if empty).", "solution": "def op_beforezero_inc_range_(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x + 1 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_beforezero_inc_range_([1, 2, 3, 4]) == 3\nassert op_beforezero_inc_range_([]) == 0\nassert op_beforezero_inc_range_([-2, -1, 0, 1, 2]) == 1\nassert op_beforezero_inc_range_([5, 5, 5]) == 0\nassert op_beforezero_inc_range_([3, 1, 2]) == 2\nassert op_beforezero_inc_range_([10]) == 0\nassert op_beforezero_inc_range_([2, 4, 6]) == 4\nassert op_beforezero_inc_range_([-7, 12, -7]) == 19"}
{"id": "op_halve_last3_absval", "entry_point": "op_halve_last3_absval", "primitives": ["halve", "last3", "absval"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep only the last three, then take the absolute value of each.", "solution": "def op_halve_last3_absval(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[-3:]\n    r = [abs(x) for x in r]\n    return r", "tests": "assert op_halve_last3_absval([1, 2, 3, 4]) == [1, 1, 2]\nassert op_halve_last3_absval([]) == []\nassert op_halve_last3_absval([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_halve_last3_absval([5, 5, 5]) == [2, 2, 2]\nassert op_halve_last3_absval([3, 1, 2]) == [1, 0, 1]\nassert op_halve_last3_absval([10]) == [5]\nassert op_halve_last3_absval([2, 4, 6]) == [1, 2, 3]\nassert op_halve_last3_absval([-7, 12, -7]) == [4, 6, 4]"}
{"id": "op_neg_uniq_range_", "entry_point": "op_neg_uniq_range_", "primitives": ["neg", "uniq", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then drop duplicates keeping first occurrence, then return the range (max minus min, 0 if empty).", "solution": "def op_neg_uniq_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = list(dict.fromkeys(r))\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_neg_uniq_range_([1, 2, 3, 4]) == 0\nassert op_neg_uniq_range_([]) == 0\nassert op_neg_uniq_range_([-2, -1, 0, 1, 2]) == 1\nassert op_neg_uniq_range_([5, 5, 5]) == 0\nassert op_neg_uniq_range_([3, 1, 2]) == 0\nassert op_neg_uniq_range_([10]) == 0\nassert op_neg_uniq_range_([2, 4, 6]) == 0\nassert op_neg_uniq_range_([-7, 12, -7]) == 0"}
{"id": "op_cube_pos_neg", "entry_point": "op_cube_pos_neg", "primitives": ["cube", "pos", "neg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the positive numbers, then keep the negative numbers.", "solution": "def op_cube_pos_neg(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 0]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_cube_pos_neg([1, 2, 3, 4]) == []\nassert op_cube_pos_neg([]) == []\nassert op_cube_pos_neg([-2, -1, 0, 1, 2]) == []\nassert op_cube_pos_neg([5, 5, 5]) == []\nassert op_cube_pos_neg([3, 1, 2]) == []\nassert op_cube_pos_neg([10]) == []\nassert op_cube_pos_neg([2, 4, 6]) == []\nassert op_cube_pos_neg([-7, 12, -7]) == []"}
{"id": "op_div3_halve_dropzeros", "entry_point": "op_div3_halve_dropzeros", "primitives": ["div3", "halve", "dropzeros"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then halve each (integer division), then drop the zeros.", "solution": "def op_div3_halve_dropzeros(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x // 2 for x in r]\n    r = [x for x in r if x != 0]\n    return r", "tests": "assert op_div3_halve_dropzeros([1, 2, 3, 4]) == [1]\nassert op_div3_halve_dropzeros([]) == []\nassert op_div3_halve_dropzeros([-2, -1, 0, 1, 2]) == []\nassert op_div3_halve_dropzeros([5, 5, 5]) == []\nassert op_div3_halve_dropzeros([3, 1, 2]) == [1]\nassert op_div3_halve_dropzeros([10]) == []\nassert op_div3_halve_dropzeros([2, 4, 6]) == [3]\nassert op_div3_halve_dropzeros([-7, 12, -7]) == [6]"}
{"id": "op_absval_last3_cube", "entry_point": "op_absval_last3_cube", "primitives": ["absval", "last3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then cube each.", "solution": "def op_absval_last3_cube(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_absval_last3_cube([1, 2, 3, 4]) == [8, 27, 64]\nassert op_absval_last3_cube([]) == []\nassert op_absval_last3_cube([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_absval_last3_cube([5, 5, 5]) == [125, 125, 125]\nassert op_absval_last3_cube([3, 1, 2]) == [27, 1, 8]\nassert op_absval_last3_cube([10]) == [1000]\nassert op_absval_last3_cube([2, 4, 6]) == [8, 64, 216]\nassert op_absval_last3_cube([-7, 12, -7]) == [343, 1728, 343]"}
{"id": "op_revstr_upper_lower", "entry_point": "op_revstr_upper_lower", "primitives": ["revstr", "upper", "lower"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then uppercase each string, then lowercase each string.", "solution": "def op_revstr_upper_lower(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.upper() for s in r]\n    r = [s.lower() for s in r]\n    return r", "tests": "assert op_revstr_upper_lower(['Hello', 'world']) == ['olleh', 'dlrow']\nassert op_revstr_upper_lower([]) == []\nassert op_revstr_upper_lower(['  a ', '', 'BC', 'bc']) == [' a  ', '', 'cb', 'cb']\nassert op_revstr_upper_lower(['one', 'one', 'Two']) == ['eno', 'eno', 'owt']\nassert op_revstr_upper_lower(['x']) == ['x']\nassert op_revstr_upper_lower(['abc', 'de', '']) == ['cba', 'ed', '']"}
{"id": "op_first3_takewhilepos_cube", "entry_point": "op_first3_takewhilepos_cube", "primitives": ["first3", "takewhilepos", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then take values while they are positive, then cube each.", "solution": "def op_first3_takewhilepos_cube(xs):\n    r = list(xs)\n    r = r[:3]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_first3_takewhilepos_cube([1, 2, 3, 4]) == [1, 8, 27]\nassert op_first3_takewhilepos_cube([]) == []\nassert op_first3_takewhilepos_cube([-2, -1, 0, 1, 2]) == []\nassert op_first3_takewhilepos_cube([5, 5, 5]) == [125, 125, 125]\nassert op_first3_takewhilepos_cube([3, 1, 2]) == [27, 1, 8]\nassert op_first3_takewhilepos_cube([10]) == [1000]\nassert op_first3_takewhilepos_cube([2, 4, 6]) == [8, 64, 216]\nassert op_first3_takewhilepos_cube([-7, 12, -7]) == []"}
{"id": "op_square_cube_alldistinct", "entry_point": "op_square_cube_alldistinct", "primitives": ["square", "cube", "alldistinct"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; square each, then cube each, then return whether all values are distinct.", "solution": "def op_square_cube_alldistinct(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x ** 3 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_square_cube_alldistinct([1, 2, 3, 4]) == True\nassert op_square_cube_alldistinct([]) == True\nassert op_square_cube_alldistinct([-2, -1, 0, 1, 2]) == False\nassert op_square_cube_alldistinct([5, 5, 5]) == False\nassert op_square_cube_alldistinct([3, 1, 2]) == True\nassert op_square_cube_alldistinct([10]) == True\nassert op_square_cube_alldistinct([2, 4, 6]) == True\nassert op_square_cube_alldistinct([-7, 12, -7]) == False"}
{"id": "op_revstr_dropshort_prefixup", "entry_point": "op_revstr_dropshort_prefixup", "primitives": ["revstr", "dropshort", "prefixup"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then drop strings shorter than three characters, then prefix each with a hash.", "solution": "def op_revstr_dropshort_prefixup(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s for s in r if len(s) >= 3]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_revstr_dropshort_prefixup(['Hello', 'world']) == ['#olleH', '#dlrow']\nassert op_revstr_dropshort_prefixup([]) == []\nassert op_revstr_dropshort_prefixup(['  a ', '', 'BC', 'bc']) == ['# a  ']\nassert op_revstr_dropshort_prefixup(['one', 'one', 'Two']) == ['#eno', '#eno', '#owT']\nassert op_revstr_dropshort_prefixup(['x']) == []\nassert op_revstr_dropshort_prefixup(['abc', 'de', '']) == ['#cba']"}
{"id": "op_halve_add10_clamp10", "entry_point": "op_halve_add10_clamp10", "primitives": ["halve", "add10", "clamp10"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then add ten to each, then cap each value at 10.", "solution": "def op_halve_add10_clamp10(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_halve_add10_clamp10([1, 2, 3, 4]) == [10, 10, 10, 10]\nassert op_halve_add10_clamp10([]) == []\nassert op_halve_add10_clamp10([-2, -1, 0, 1, 2]) == [9, 9, 10, 10, 10]\nassert op_halve_add10_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_halve_add10_clamp10([3, 1, 2]) == [10, 10, 10]\nassert op_halve_add10_clamp10([10]) == [10]\nassert op_halve_add10_clamp10([2, 4, 6]) == [10, 10, 10]\nassert op_halve_add10_clamp10([-7, 12, -7]) == [6, 10, 6]"}
{"id": "op_beforezero_sortd_cube", "entry_point": "op_beforezero_sortd_cube", "primitives": ["beforezero", "sortd", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then sort descending, then cube each.", "solution": "def op_beforezero_sortd_cube(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = sorted(r, reverse=True)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_beforezero_sortd_cube([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_beforezero_sortd_cube([]) == []\nassert op_beforezero_sortd_cube([-2, -1, 0, 1, 2]) == [-1, -8]\nassert op_beforezero_sortd_cube([5, 5, 5]) == [125, 125, 125]\nassert op_beforezero_sortd_cube([3, 1, 2]) == [27, 8, 1]\nassert op_beforezero_sortd_cube([10]) == [1000]\nassert op_beforezero_sortd_cube([2, 4, 6]) == [216, 64, 8]\nassert op_beforezero_sortd_cube([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_inc_halve_takewhilepos", "entry_point": "op_inc_halve_takewhilepos", "primitives": ["inc", "halve", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then halve each (integer division), then take values while they are positive.", "solution": "def op_inc_halve_takewhilepos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x // 2 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_inc_halve_takewhilepos([1, 2, 3, 4]) == [1, 1, 2, 2]\nassert op_inc_halve_takewhilepos([]) == []\nassert op_inc_halve_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_inc_halve_takewhilepos([5, 5, 5]) == [3, 3, 3]\nassert op_inc_halve_takewhilepos([3, 1, 2]) == [2, 1, 1]\nassert op_inc_halve_takewhilepos([10]) == [5]\nassert op_inc_halve_takewhilepos([2, 4, 6]) == [1, 2, 3]\nassert op_inc_halve_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_trimends_pos_range_", "entry_point": "op_trimends_pos_range_", "primitives": ["trimends", "pos", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then keep the positive numbers, then return the range (max minus min, 0 if empty).", "solution": "def op_trimends_pos_range_(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x for x in r if x > 0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_trimends_pos_range_([1, 2, 3, 4]) == 1\nassert op_trimends_pos_range_([]) == 0\nassert op_trimends_pos_range_([-2, -1, 0, 1, 2]) == 0\nassert op_trimends_pos_range_([5, 5, 5]) == 0\nassert op_trimends_pos_range_([3, 1, 2]) == 0\nassert op_trimends_pos_range_([10]) == 0\nassert op_trimends_pos_range_([2, 4, 6]) == 0\nassert op_trimends_pos_range_([-7, 12, -7]) == 0"}
{"id": "op_double_halve_negate", "entry_point": "op_double_halve_negate", "primitives": ["double", "halve", "negate"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then halve each (integer division), then negate each.", "solution": "def op_double_halve_negate(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x // 2 for x in r]\n    r = [-x for x in r]\n    return r", "tests": "assert op_double_halve_negate([1, 2, 3, 4]) == [-1, -2, -3, -4]\nassert op_double_halve_negate([]) == []\nassert op_double_halve_negate([-2, -1, 0, 1, 2]) == [2, 1, 0, -1, -2]\nassert op_double_halve_negate([5, 5, 5]) == [-5, -5, -5]\nassert op_double_halve_negate([3, 1, 2]) == [-3, -1, -2]\nassert op_double_halve_negate([10]) == [-10]\nassert op_double_halve_negate([2, 4, 6]) == [-2, -4, -6]\nassert op_double_halve_negate([-7, 12, -7]) == [7, -12, 7]"}
{"id": "op_cube_sortabs_firsteven", "entry_point": "op_cube_sortabs_firsteven", "primitives": ["cube", "sortabs", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then sort by absolute value, then return the first even value (0 if none).", "solution": "def op_cube_sortabs_firsteven(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = sorted(r, key=abs)\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_cube_sortabs_firsteven([1, 2, 3, 4]) == 8\nassert op_cube_sortabs_firsteven([]) == 0\nassert op_cube_sortabs_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_cube_sortabs_firsteven([5, 5, 5]) == 0\nassert op_cube_sortabs_firsteven([3, 1, 2]) == 8\nassert op_cube_sortabs_firsteven([10]) == 1000\nassert op_cube_sortabs_firsteven([2, 4, 6]) == 8\nassert op_cube_sortabs_firsteven([-7, 12, -7]) == 1728"}
{"id": "op_dropshort_title_strip", "entry_point": "op_dropshort_title_strip", "primitives": ["dropshort", "title", "strip"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop strings shorter than three characters, then title-case each string, then trim whitespace from each.", "solution": "def op_dropshort_title_strip(xs):\n    r = list(xs)\n    r = [s for s in r if len(s) >= 3]\n    r = [s.title() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_dropshort_title_strip(['Hello', 'world']) == ['Hello', 'World']\nassert op_dropshort_title_strip([]) == []\nassert op_dropshort_title_strip(['  a ', '', 'BC', 'bc']) == ['A']\nassert op_dropshort_title_strip(['one', 'one', 'Two']) == ['One', 'One', 'Two']\nassert op_dropshort_title_strip(['x']) == []\nassert op_dropshort_title_strip(['abc', 'de', '']) == ['Abc']"}
{"id": "op_dec_oremptyzero_range_", "entry_point": "op_dec_oremptyzero_range_", "primitives": ["dec", "oremptyzero", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then if empty, use a single zero, then return the range (max minus min, 0 if empty).", "solution": "def op_dec_oremptyzero_range_(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r if r else [0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dec_oremptyzero_range_([1, 2, 3, 4]) == 3\nassert op_dec_oremptyzero_range_([]) == 0\nassert op_dec_oremptyzero_range_([-2, -1, 0, 1, 2]) == 4\nassert op_dec_oremptyzero_range_([5, 5, 5]) == 0\nassert op_dec_oremptyzero_range_([3, 1, 2]) == 2\nassert op_dec_oremptyzero_range_([10]) == 0\nassert op_dec_oremptyzero_range_([2, 4, 6]) == 4\nassert op_dec_oremptyzero_range_([-7, 12, -7]) == 19"}
{"id": "op_padto3_halve_len", "entry_point": "op_padto3_halve_len", "primitives": ["padto3", "halve", "len"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then halve each (integer division), then return how many remain.", "solution": "def op_padto3_halve_len(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x // 2 for x in r]\n    return len(r)", "tests": "assert op_padto3_halve_len([1, 2, 3, 4]) == 4\nassert op_padto3_halve_len([]) == 3\nassert op_padto3_halve_len([-2, -1, 0, 1, 2]) == 5\nassert op_padto3_halve_len([5, 5, 5]) == 3\nassert op_padto3_halve_len([3, 1, 2]) == 3\nassert op_padto3_halve_len([10]) == 3\nassert op_padto3_halve_len([2, 4, 6]) == 3\nassert op_padto3_halve_len([-7, 12, -7]) == 3"}
{"id": "op_cube_sortd_beforezero", "entry_point": "op_cube_sortd_beforezero", "primitives": ["cube", "sortd", "beforezero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then sort descending, then keep everything before the first zero.", "solution": "def op_cube_sortd_beforezero(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = sorted(r, reverse=True)\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_cube_sortd_beforezero([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_cube_sortd_beforezero([]) == []\nassert op_cube_sortd_beforezero([-2, -1, 0, 1, 2]) == [8, 1]\nassert op_cube_sortd_beforezero([5, 5, 5]) == [125, 125, 125]\nassert op_cube_sortd_beforezero([3, 1, 2]) == [27, 8, 1]\nassert op_cube_sortd_beforezero([10]) == [1000]\nassert op_cube_sortd_beforezero([2, 4, 6]) == [216, 64, 8]\nassert op_cube_sortd_beforezero([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_pos_takewhilepos_halve", "entry_point": "op_pos_takewhilepos_halve", "primitives": ["pos", "takewhilepos", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the positive numbers, then take values while they are positive, then halve each (integer division).", "solution": "def op_pos_takewhilepos_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x > 0]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_pos_takewhilepos_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_pos_takewhilepos_halve([]) == []\nassert op_pos_takewhilepos_halve([-2, -1, 0, 1, 2]) == [0, 1]\nassert op_pos_takewhilepos_halve([5, 5, 5]) == [2, 2, 2]\nassert op_pos_takewhilepos_halve([3, 1, 2]) == [1, 0, 1]\nassert op_pos_takewhilepos_halve([10]) == [5]\nassert op_pos_takewhilepos_halve([2, 4, 6]) == [1, 2, 3]\nassert op_pos_takewhilepos_halve([-7, 12, -7]) == [6]"}
{"id": "op_dropwhileneg_rev_range_", "entry_point": "op_dropwhileneg_rev_range_", "primitives": ["dropwhileneg", "rev", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then reverse the order, then return the range (max minus min, 0 if empty).", "solution": "def op_dropwhileneg_rev_range_(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = list(reversed(r))\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropwhileneg_rev_range_([1, 2, 3, 4]) == 3\nassert op_dropwhileneg_rev_range_([]) == 0\nassert op_dropwhileneg_rev_range_([-2, -1, 0, 1, 2]) == 2\nassert op_dropwhileneg_rev_range_([5, 5, 5]) == 0\nassert op_dropwhileneg_rev_range_([3, 1, 2]) == 2\nassert op_dropwhileneg_rev_range_([10]) == 0\nassert op_dropwhileneg_rev_range_([2, 4, 6]) == 4\nassert op_dropwhileneg_rev_range_([-7, 12, -7]) == 19"}
{"id": "op_cube_neg_square", "entry_point": "op_cube_neg_square", "primitives": ["cube", "neg", "square"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the negative numbers, then square each.", "solution": "def op_cube_neg_square(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x * x for x in r]\n    return r", "tests": "assert op_cube_neg_square([1, 2, 3, 4]) == []\nassert op_cube_neg_square([]) == []\nassert op_cube_neg_square([-2, -1, 0, 1, 2]) == [64, 1]\nassert op_cube_neg_square([5, 5, 5]) == []\nassert op_cube_neg_square([3, 1, 2]) == []\nassert op_cube_neg_square([10]) == []\nassert op_cube_neg_square([2, 4, 6]) == []\nassert op_cube_neg_square([-7, 12, -7]) == [117649, 117649]"}
{"id": "op_cube_neg_sum", "entry_point": "op_cube_neg_sum", "primitives": ["cube", "neg", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the negative numbers, then return their sum.", "solution": "def op_cube_neg_sum(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x < 0]\n    return sum(r)", "tests": "assert op_cube_neg_sum([1, 2, 3, 4]) == 0\nassert op_cube_neg_sum([]) == 0\nassert op_cube_neg_sum([-2, -1, 0, 1, 2]) == -9\nassert op_cube_neg_sum([5, 5, 5]) == 0\nassert op_cube_neg_sum([3, 1, 2]) == 0\nassert op_cube_neg_sum([10]) == 0\nassert op_cube_neg_sum([2, 4, 6]) == 0\nassert op_cube_neg_sum([-7, 12, -7]) == -686"}
{"id": "op_neg_clamp10_halve", "entry_point": "op_neg_clamp10_halve", "primitives": ["neg", "clamp10", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the negative numbers, then cap each value at 10, then halve each (integer division).", "solution": "def op_neg_clamp10_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x < 0]\n    r = [min(x, 10) for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_neg_clamp10_halve([1, 2, 3, 4]) == []\nassert op_neg_clamp10_halve([]) == []\nassert op_neg_clamp10_halve([-2, -1, 0, 1, 2]) == [-1, -1]\nassert op_neg_clamp10_halve([5, 5, 5]) == []\nassert op_neg_clamp10_halve([3, 1, 2]) == []\nassert op_neg_clamp10_halve([10]) == []\nassert op_neg_clamp10_halve([2, 4, 6]) == []\nassert op_neg_clamp10_halve([-7, 12, -7]) == [-4, -4]"}
{"id": "op_halve_absval_allpos", "entry_point": "op_halve_absval_allpos", "primitives": ["halve", "absval", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then take the absolute value of each, then return whether all values are positive.", "solution": "def op_halve_absval_allpos(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [abs(x) for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_halve_absval_allpos([1, 2, 3, 4]) == False\nassert op_halve_absval_allpos([]) == True\nassert op_halve_absval_allpos([-2, -1, 0, 1, 2]) == False\nassert op_halve_absval_allpos([5, 5, 5]) == True\nassert op_halve_absval_allpos([3, 1, 2]) == False\nassert op_halve_absval_allpos([10]) == True\nassert op_halve_absval_allpos([2, 4, 6]) == True\nassert op_halve_absval_allpos([-7, 12, -7]) == True"}
{"id": "op_dropzeros_first3_cube", "entry_point": "op_dropzeros_first3_cube", "primitives": ["dropzeros", "first3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then keep only the first three, then cube each.", "solution": "def op_dropzeros_first3_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = r[:3]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropzeros_first3_cube([1, 2, 3, 4]) == [1, 8, 27]\nassert op_dropzeros_first3_cube([]) == []\nassert op_dropzeros_first3_cube([-2, -1, 0, 1, 2]) == [-8, -1, 1]\nassert op_dropzeros_first3_cube([5, 5, 5]) == [125, 125, 125]\nassert op_dropzeros_first3_cube([3, 1, 2]) == [27, 1, 8]\nassert op_dropzeros_first3_cube([10]) == [1000]\nassert op_dropzeros_first3_cube([2, 4, 6]) == [8, 64, 216]\nassert op_dropzeros_first3_cube([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_sortd_cube_alldistinct", "entry_point": "op_sortd_cube_alldistinct", "primitives": ["sortd", "cube", "alldistinct"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort descending, then cube each, then return whether all values are distinct.", "solution": "def op_sortd_cube_alldistinct(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = [x ** 3 for x in r]\n    return len(r) == len(set(r))", "tests": "assert op_sortd_cube_alldistinct([1, 2, 3, 4]) == True\nassert op_sortd_cube_alldistinct([]) == True\nassert op_sortd_cube_alldistinct([-2, -1, 0, 1, 2]) == True\nassert op_sortd_cube_alldistinct([5, 5, 5]) == False\nassert op_sortd_cube_alldistinct([3, 1, 2]) == True\nassert op_sortd_cube_alldistinct([10]) == True\nassert op_sortd_cube_alldistinct([2, 4, 6]) == True\nassert op_sortd_cube_alldistinct([-7, 12, -7]) == False"}
{"id": "op_sortalpha_uniqs_revstr", "entry_point": "op_sortalpha_uniqs_revstr", "primitives": ["sortalpha", "uniqs", "revstr"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then drop duplicate strings keeping the first, then reverse each string.", "solution": "def op_sortalpha_uniqs_revstr(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(dict.fromkeys(r))\n    r = [s[::-1] for s in r]\n    return r", "tests": "assert op_sortalpha_uniqs_revstr(['Hello', 'world']) == ['olleH', 'dlrow']\nassert op_sortalpha_uniqs_revstr([]) == []\nassert op_sortalpha_uniqs_revstr(['  a ', '', 'BC', 'bc']) == ['', ' a  ', 'CB', 'cb']\nassert op_sortalpha_uniqs_revstr(['one', 'one', 'Two']) == ['owT', 'eno']\nassert op_sortalpha_uniqs_revstr(['x']) == ['x']\nassert op_sortalpha_uniqs_revstr(['abc', 'de', '']) == ['', 'cba', 'ed']"}
{"id": "op_dropwhileneg_dropfirst_cube", "entry_point": "op_dropwhileneg_dropfirst_cube", "primitives": ["dropwhileneg", "dropfirst", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then drop the first element, then cube each.", "solution": "def op_dropwhileneg_dropfirst_cube(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r[1:]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropwhileneg_dropfirst_cube([1, 2, 3, 4]) == [8, 27, 64]\nassert op_dropwhileneg_dropfirst_cube([]) == []\nassert op_dropwhileneg_dropfirst_cube([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_dropwhileneg_dropfirst_cube([5, 5, 5]) == [125, 125]\nassert op_dropwhileneg_dropfirst_cube([3, 1, 2]) == [1, 8]\nassert op_dropwhileneg_dropfirst_cube([10]) == []\nassert op_dropwhileneg_dropfirst_cube([2, 4, 6]) == [64, 216]\nassert op_dropwhileneg_dropfirst_cube([-7, 12, -7]) == [-343]"}
{"id": "op_halve_double_gt5", "entry_point": "op_halve_double_gt5", "primitives": ["halve", "double", "gt5"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then double each, then keep values greater than five.", "solution": "def op_halve_double_gt5(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_halve_double_gt5([1, 2, 3, 4]) == []\nassert op_halve_double_gt5([]) == []\nassert op_halve_double_gt5([-2, -1, 0, 1, 2]) == []\nassert op_halve_double_gt5([5, 5, 5]) == []\nassert op_halve_double_gt5([3, 1, 2]) == []\nassert op_halve_double_gt5([10]) == [10]\nassert op_halve_double_gt5([2, 4, 6]) == [6]\nassert op_halve_double_gt5([-7, 12, -7]) == [12]"}
{"id": "op_beforezero_cube", "entry_point": "op_beforezero_cube", "primitives": ["beforezero", "cube"], "difficulty": 1, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then cube each.", "solution": "def op_beforezero_cube(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_beforezero_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_beforezero_cube([]) == []\nassert op_beforezero_cube([-2, -1, 0, 1, 2]) == [-8, -1]\nassert op_beforezero_cube([5, 5, 5]) == [125, 125, 125]\nassert op_beforezero_cube([3, 1, 2]) == [27, 1, 8]\nassert op_beforezero_cube([10]) == [1000]\nassert op_beforezero_cube([2, 4, 6]) == [8, 64, 216]\nassert op_beforezero_cube([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_upper_title_joinc", "entry_point": "op_upper_title_joinc", "primitives": ["upper", "title", "joinc"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then title-case each string, then join them with commas.", "solution": "def op_upper_title_joinc(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s.title() for s in r]\n    return ','.join(r)", "tests": "assert op_upper_title_joinc(['Hello', 'world']) == 'Hello,World'\nassert op_upper_title_joinc([]) == ''\nassert op_upper_title_joinc(['  a ', '', 'BC', 'bc']) == '  A ,,Bc,Bc'\nassert op_upper_title_joinc(['one', 'one', 'Two']) == 'One,One,Two'\nassert op_upper_title_joinc(['x']) == 'X'\nassert op_upper_title_joinc(['abc', 'de', '']) == 'Abc,De,'"}
{"id": "op_clamp10_cube_issorted", "entry_point": "op_clamp10_cube_issorted", "primitives": ["clamp10", "cube", "issorted"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then cube each, then return whether the list is sorted ascending.", "solution": "def op_clamp10_cube_issorted(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x ** 3 for x in r]\n    return r == sorted(r)", "tests": "assert op_clamp10_cube_issorted([1, 2, 3, 4]) == True\nassert op_clamp10_cube_issorted([]) == True\nassert op_clamp10_cube_issorted([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_cube_issorted([5, 5, 5]) == True\nassert op_clamp10_cube_issorted([3, 1, 2]) == False\nassert op_clamp10_cube_issorted([10]) == True\nassert op_clamp10_cube_issorted([2, 4, 6]) == True\nassert op_clamp10_cube_issorted([-7, 12, -7]) == False"}
{"id": "op_double_uniq_range_", "entry_point": "op_double_uniq_range_", "primitives": ["double", "uniq", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then drop duplicates keeping first occurrence, then return the range (max minus min, 0 if empty).", "solution": "def op_double_uniq_range_(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = list(dict.fromkeys(r))\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_double_uniq_range_([1, 2, 3, 4]) == 6\nassert op_double_uniq_range_([]) == 0\nassert op_double_uniq_range_([-2, -1, 0, 1, 2]) == 8\nassert op_double_uniq_range_([5, 5, 5]) == 0\nassert op_double_uniq_range_([3, 1, 2]) == 4\nassert op_double_uniq_range_([10]) == 0\nassert op_double_uniq_range_([2, 4, 6]) == 8\nassert op_double_uniq_range_([-7, 12, -7]) == 38"}
{"id": "op_absval_pos_range_", "entry_point": "op_absval_pos_range_", "primitives": ["absval", "pos", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep the positive numbers, then return the range (max minus min, 0 if empty).", "solution": "def op_absval_pos_range_(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = [x for x in r if x > 0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_absval_pos_range_([1, 2, 3, 4]) == 3\nassert op_absval_pos_range_([]) == 0\nassert op_absval_pos_range_([-2, -1, 0, 1, 2]) == 1\nassert op_absval_pos_range_([5, 5, 5]) == 0\nassert op_absval_pos_range_([3, 1, 2]) == 2\nassert op_absval_pos_range_([10]) == 0\nassert op_absval_pos_range_([2, 4, 6]) == 4\nassert op_absval_pos_range_([-7, 12, -7]) == 5"}
{"id": "op_beforezero_takewhilepos_cube", "entry_point": "op_beforezero_takewhilepos_cube", "primitives": ["beforezero", "takewhilepos", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep everything before the first zero, then take values while they are positive, then cube each.", "solution": "def op_beforezero_takewhilepos_cube(xs):\n    r = list(xs)\n    r = r[:r.index(0)] if 0 in r else r\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_beforezero_takewhilepos_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_beforezero_takewhilepos_cube([]) == []\nassert op_beforezero_takewhilepos_cube([-2, -1, 0, 1, 2]) == []\nassert op_beforezero_takewhilepos_cube([5, 5, 5]) == [125, 125, 125]\nassert op_beforezero_takewhilepos_cube([3, 1, 2]) == [27, 1, 8]\nassert op_beforezero_takewhilepos_cube([10]) == [1000]\nassert op_beforezero_takewhilepos_cube([2, 4, 6]) == [8, 64, 216]\nassert op_beforezero_takewhilepos_cube([-7, 12, -7]) == []"}
{"id": "op_gt5_last3_halve", "entry_point": "op_gt5_last3_halve", "primitives": ["gt5", "last3", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep values greater than five, then keep only the last three, then halve each (integer division).", "solution": "def op_gt5_last3_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x > 5]\n    r = r[-3:]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_gt5_last3_halve([1, 2, 3, 4]) == []\nassert op_gt5_last3_halve([]) == []\nassert op_gt5_last3_halve([-2, -1, 0, 1, 2]) == []\nassert op_gt5_last3_halve([5, 5, 5]) == []\nassert op_gt5_last3_halve([3, 1, 2]) == []\nassert op_gt5_last3_halve([10]) == [5]\nassert op_gt5_last3_halve([2, 4, 6]) == [3]\nassert op_gt5_last3_halve([-7, 12, -7]) == [6]"}
{"id": "op_title_prefixup_upper", "entry_point": "op_title_prefixup_upper", "primitives": ["title", "prefixup", "upper"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then prefix each with a hash, then uppercase each string.", "solution": "def op_title_prefixup_upper(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = ['#' + s for s in r]\n    r = [s.upper() for s in r]\n    return r", "tests": "assert op_title_prefixup_upper(['Hello', 'world']) == ['#HELLO', '#WORLD']\nassert op_title_prefixup_upper([]) == []\nassert op_title_prefixup_upper(['  a ', '', 'BC', 'bc']) == ['#  A ', '#', '#BC', '#BC']\nassert op_title_prefixup_upper(['one', 'one', 'Two']) == ['#ONE', '#ONE', '#TWO']\nassert op_title_prefixup_upper(['x']) == ['#X']\nassert op_title_prefixup_upper(['abc', 'de', '']) == ['#ABC', '#DE', '#']"}
{"id": "op_square_sorta_range_", "entry_point": "op_square_sorta_range_", "primitives": ["square", "sorta", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; square each, then sort ascending, then return the range (max minus min, 0 if empty).", "solution": "def op_square_sorta_range_(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = sorted(r)\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_square_sorta_range_([1, 2, 3, 4]) == 15\nassert op_square_sorta_range_([]) == 0\nassert op_square_sorta_range_([-2, -1, 0, 1, 2]) == 4\nassert op_square_sorta_range_([5, 5, 5]) == 0\nassert op_square_sorta_range_([3, 1, 2]) == 8\nassert op_square_sorta_range_([10]) == 0\nassert op_square_sorta_range_([2, 4, 6]) == 32\nassert op_square_sorta_range_([-7, 12, -7]) == 95"}
{"id": "op_inc_cube_allpos", "entry_point": "op_inc_cube_allpos", "primitives": ["inc", "cube", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then cube each, then return whether all values are positive.", "solution": "def op_inc_cube_allpos(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x ** 3 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_inc_cube_allpos([1, 2, 3, 4]) == True\nassert op_inc_cube_allpos([]) == True\nassert op_inc_cube_allpos([-2, -1, 0, 1, 2]) == False\nassert op_inc_cube_allpos([5, 5, 5]) == True\nassert op_inc_cube_allpos([3, 1, 2]) == True\nassert op_inc_cube_allpos([10]) == True\nassert op_inc_cube_allpos([2, 4, 6]) == True\nassert op_inc_cube_allpos([-7, 12, -7]) == False"}
{"id": "op_upper_revstr_sortalpha", "entry_point": "op_upper_revstr_sortalpha", "primitives": ["upper", "revstr", "sortalpha"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; uppercase each string, then reverse each string, then sort alphabetically.", "solution": "def op_upper_revstr_sortalpha(xs):\n    r = list(xs)\n    r = [s.upper() for s in r]\n    r = [s[::-1] for s in r]\n    r = sorted(r)\n    return r", "tests": "assert op_upper_revstr_sortalpha(['Hello', 'world']) == ['DLROW', 'OLLEH']\nassert op_upper_revstr_sortalpha([]) == []\nassert op_upper_revstr_sortalpha(['  a ', '', 'BC', 'bc']) == ['', ' A  ', 'CB', 'CB']\nassert op_upper_revstr_sortalpha(['one', 'one', 'Two']) == ['ENO', 'ENO', 'OWT']\nassert op_upper_revstr_sortalpha(['x']) == ['X']\nassert op_upper_revstr_sortalpha(['abc', 'de', '']) == ['', 'CBA', 'ED']"}
{"id": "op_halve_first3_sorta", "entry_point": "op_halve_first3_sorta", "primitives": ["halve", "first3", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep only the first three, then sort ascending.", "solution": "def op_halve_first3_sorta(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[:3]\n    r = sorted(r)\n    return r", "tests": "assert op_halve_first3_sorta([1, 2, 3, 4]) == [0, 1, 1]\nassert op_halve_first3_sorta([]) == []\nassert op_halve_first3_sorta([-2, -1, 0, 1, 2]) == [-1, -1, 0]\nassert op_halve_first3_sorta([5, 5, 5]) == [2, 2, 2]\nassert op_halve_first3_sorta([3, 1, 2]) == [0, 1, 1]\nassert op_halve_first3_sorta([10]) == [5]\nassert op_halve_first3_sorta([2, 4, 6]) == [1, 2, 3]\nassert op_halve_first3_sorta([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_cube_absval_prod", "entry_point": "op_cube_absval_prod", "primitives": ["cube", "absval", "prod"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then take the absolute value of each, then return their product.", "solution": "def op_cube_absval_prod(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [abs(x) for x in r]\n    return __import__('math').prod(r)", "tests": "assert op_cube_absval_prod([1, 2, 3, 4]) == 13824\nassert op_cube_absval_prod([]) == 1\nassert op_cube_absval_prod([-2, -1, 0, 1, 2]) == 0\nassert op_cube_absval_prod([5, 5, 5]) == 1953125\nassert op_cube_absval_prod([3, 1, 2]) == 216\nassert op_cube_absval_prod([10]) == 1000\nassert op_cube_absval_prod([2, 4, 6]) == 110592\nassert op_cube_absval_prod([-7, 12, -7]) == 203297472"}
{"id": "op_cube_pos_beforezero", "entry_point": "op_cube_pos_beforezero", "primitives": ["cube", "pos", "beforezero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the positive numbers, then keep everything before the first zero.", "solution": "def op_cube_pos_beforezero(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 0]\n    r = r[:r.index(0)] if 0 in r else r\n    return r", "tests": "assert op_cube_pos_beforezero([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_cube_pos_beforezero([]) == []\nassert op_cube_pos_beforezero([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_cube_pos_beforezero([5, 5, 5]) == [125, 125, 125]\nassert op_cube_pos_beforezero([3, 1, 2]) == [27, 1, 8]\nassert op_cube_pos_beforezero([10]) == [1000]\nassert op_cube_pos_beforezero([2, 4, 6]) == [8, 64, 216]\nassert op_cube_pos_beforezero([-7, 12, -7]) == [1728]"}
{"id": "op_halve_evens_sortabs", "entry_point": "op_halve_evens_sortabs", "primitives": ["halve", "evens", "sortabs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the even numbers, then sort by absolute value.", "solution": "def op_halve_evens_sortabs(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_halve_evens_sortabs([1, 2, 3, 4]) == [0, 2]\nassert op_halve_evens_sortabs([]) == []\nassert op_halve_evens_sortabs([-2, -1, 0, 1, 2]) == [0, 0]\nassert op_halve_evens_sortabs([5, 5, 5]) == [2, 2, 2]\nassert op_halve_evens_sortabs([3, 1, 2]) == [0]\nassert op_halve_evens_sortabs([10]) == []\nassert op_halve_evens_sortabs([2, 4, 6]) == [2]\nassert op_halve_evens_sortabs([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_dropfirst_halve_range_", "entry_point": "op_dropfirst_halve_range_", "primitives": ["dropfirst", "halve", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then halve each (integer division), then return the range (max minus min, 0 if empty).", "solution": "def op_dropfirst_halve_range_(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x // 2 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropfirst_halve_range_([1, 2, 3, 4]) == 1\nassert op_dropfirst_halve_range_([]) == 0\nassert op_dropfirst_halve_range_([-2, -1, 0, 1, 2]) == 2\nassert op_dropfirst_halve_range_([5, 5, 5]) == 0\nassert op_dropfirst_halve_range_([3, 1, 2]) == 1\nassert op_dropfirst_halve_range_([10]) == 0\nassert op_dropfirst_halve_range_([2, 4, 6]) == 1\nassert op_dropfirst_halve_range_([-7, 12, -7]) == 10"}
{"id": "op_ages_sortd_range_", "entry_point": "op_ages_sortd_range_", "primitives": ["ages", "sortd", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then sort descending, then return the range (max minus min, 0 if empty).", "solution": "def op_ages_sortd_range_(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = sorted(r, reverse=True)\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_ages_sortd_range_([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == 24\nassert op_ages_sortd_range_([]) == 0\nassert op_ages_sortd_range_([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == 48\nassert op_ages_sortd_range_([{'name': 'Fi', 'age': 41}]) == 0"}
{"id": "op_dropzeros_sortd_cube", "entry_point": "op_dropzeros_sortd_cube", "primitives": ["dropzeros", "sortd", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending, then cube each.", "solution": "def op_dropzeros_sortd_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropzeros_sortd_cube([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_dropzeros_sortd_cube([]) == []\nassert op_dropzeros_sortd_cube([-2, -1, 0, 1, 2]) == [8, 1, -1, -8]\nassert op_dropzeros_sortd_cube([5, 5, 5]) == [125, 125, 125]\nassert op_dropzeros_sortd_cube([3, 1, 2]) == [27, 8, 1]\nassert op_dropzeros_sortd_cube([10]) == [1000]\nassert op_dropzeros_sortd_cube([2, 4, 6]) == [216, 64, 8]\nassert op_dropzeros_sortd_cube([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_dropfirst_cube_gt5", "entry_point": "op_dropfirst_cube_gt5", "primitives": ["dropfirst", "cube", "gt5"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cube each, then keep values greater than five.", "solution": "def op_dropfirst_cube_gt5(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 5]\n    return r", "tests": "assert op_dropfirst_cube_gt5([1, 2, 3, 4]) == [8, 27, 64]\nassert op_dropfirst_cube_gt5([]) == []\nassert op_dropfirst_cube_gt5([-2, -1, 0, 1, 2]) == [8]\nassert op_dropfirst_cube_gt5([5, 5, 5]) == [125, 125]\nassert op_dropfirst_cube_gt5([3, 1, 2]) == [8]\nassert op_dropfirst_cube_gt5([10]) == []\nassert op_dropfirst_cube_gt5([2, 4, 6]) == [64, 216]\nassert op_dropfirst_cube_gt5([-7, 12, -7]) == [1728]"}
{"id": "op_clamp10_halve_anyeven", "entry_point": "op_clamp10_halve_anyeven", "primitives": ["clamp10", "halve", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then halve each (integer division), then return whether any value is even.", "solution": "def op_clamp10_halve_anyeven(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x // 2 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_clamp10_halve_anyeven([1, 2, 3, 4]) == True\nassert op_clamp10_halve_anyeven([]) == False\nassert op_clamp10_halve_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_clamp10_halve_anyeven([5, 5, 5]) == True\nassert op_clamp10_halve_anyeven([3, 1, 2]) == True\nassert op_clamp10_halve_anyeven([10]) == False\nassert op_clamp10_halve_anyeven([2, 4, 6]) == True\nassert op_clamp10_halve_anyeven([-7, 12, -7]) == True"}
{"id": "op_dropzeros_sortd_halve", "entry_point": "op_dropzeros_sortd_halve", "primitives": ["dropzeros", "sortd", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then sort descending, then halve each (integer division).", "solution": "def op_dropzeros_sortd_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = sorted(r, reverse=True)\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_dropzeros_sortd_halve([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_dropzeros_sortd_halve([]) == []\nassert op_dropzeros_sortd_halve([-2, -1, 0, 1, 2]) == [1, 0, -1, -1]\nassert op_dropzeros_sortd_halve([5, 5, 5]) == [2, 2, 2]\nassert op_dropzeros_sortd_halve([3, 1, 2]) == [1, 1, 0]\nassert op_dropzeros_sortd_halve([10]) == [5]\nassert op_dropzeros_sortd_halve([2, 4, 6]) == [3, 2, 1]\nassert op_dropzeros_sortd_halve([-7, 12, -7]) == [6, -4, -4]"}
{"id": "op_dropzeros_halve_anyeven", "entry_point": "op_dropzeros_halve_anyeven", "primitives": ["dropzeros", "halve", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then halve each (integer division), then return whether any value is even.", "solution": "def op_dropzeros_halve_anyeven(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x // 2 for x in r]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_dropzeros_halve_anyeven([1, 2, 3, 4]) == True\nassert op_dropzeros_halve_anyeven([]) == False\nassert op_dropzeros_halve_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_dropzeros_halve_anyeven([5, 5, 5]) == True\nassert op_dropzeros_halve_anyeven([3, 1, 2]) == True\nassert op_dropzeros_halve_anyeven([10]) == False\nassert op_dropzeros_halve_anyeven([2, 4, 6]) == True\nassert op_dropzeros_halve_anyeven([-7, 12, -7]) == True"}
{"id": "op_takewhilepos_first3_range_", "entry_point": "op_takewhilepos_first3_range_", "primitives": ["takewhilepos", "first3", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep only the first three, then return the range (max minus min, 0 if empty).", "solution": "def op_takewhilepos_first3_range_(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = r[:3]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_takewhilepos_first3_range_([1, 2, 3, 4]) == 2\nassert op_takewhilepos_first3_range_([]) == 0\nassert op_takewhilepos_first3_range_([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_first3_range_([5, 5, 5]) == 0\nassert op_takewhilepos_first3_range_([3, 1, 2]) == 2\nassert op_takewhilepos_first3_range_([10]) == 0\nassert op_takewhilepos_first3_range_([2, 4, 6]) == 4\nassert op_takewhilepos_first3_range_([-7, 12, -7]) == 0"}
{"id": "op_div3_odds_cube", "entry_point": "op_div3_odds_cube", "primitives": ["div3", "odds", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep multiples of three, then keep the odd numbers, then cube each.", "solution": "def op_div3_odds_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x % 2 != 0]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_div3_odds_cube([1, 2, 3, 4]) == [27]\nassert op_div3_odds_cube([]) == []\nassert op_div3_odds_cube([-2, -1, 0, 1, 2]) == []\nassert op_div3_odds_cube([5, 5, 5]) == []\nassert op_div3_odds_cube([3, 1, 2]) == [27]\nassert op_div3_odds_cube([10]) == []\nassert op_div3_odds_cube([2, 4, 6]) == []\nassert op_div3_odds_cube([-7, 12, -7]) == []"}
{"id": "op_names_upper_title", "entry_point": "op_names_upper_title", "primitives": ["names", "upper", "title"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then uppercase each string, then title-case each string.", "solution": "def op_names_upper_title(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.upper() for s in r]\n    r = [s.title() for s in r]\n    return r", "tests": "assert op_names_upper_title([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['Ada', 'Bo']\nassert op_names_upper_title([]) == []\nassert op_names_upper_title([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['Cy', 'Dee', 'El']\nassert op_names_upper_title([{'name': 'Fi', 'age': 41}]) == ['Fi']"}
{"id": "op_strip_title_dropshort", "entry_point": "op_strip_title_dropshort", "primitives": ["strip", "title", "dropshort"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; trim whitespace from each, then title-case each string, then drop strings shorter than three characters.", "solution": "def op_strip_title_dropshort(xs):\n    r = list(xs)\n    r = [s.strip() for s in r]\n    r = [s.title() for s in r]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_strip_title_dropshort(['Hello', 'world']) == ['Hello', 'World']\nassert op_strip_title_dropshort([]) == []\nassert op_strip_title_dropshort(['  a ', '', 'BC', 'bc']) == []\nassert op_strip_title_dropshort(['one', 'one', 'Two']) == ['One', 'One', 'Two']\nassert op_strip_title_dropshort(['x']) == []\nassert op_strip_title_dropshort(['abc', 'de', '']) == ['Abc']"}
{"id": "op_uniqs_revstr_nonempty", "entry_point": "op_uniqs_revstr_nonempty", "primitives": ["uniqs", "revstr", "nonempty"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then reverse each string, then drop empty strings.", "solution": "def op_uniqs_revstr_nonempty(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[::-1] for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_uniqs_revstr_nonempty(['Hello', 'world']) == ['olleH', 'dlrow']\nassert op_uniqs_revstr_nonempty([]) == []\nassert op_uniqs_revstr_nonempty(['  a ', '', 'BC', 'bc']) == [' a  ', 'CB', 'cb']\nassert op_uniqs_revstr_nonempty(['one', 'one', 'Two']) == ['eno', 'owT']\nassert op_uniqs_revstr_nonempty(['x']) == ['x']\nassert op_uniqs_revstr_nonempty(['abc', 'de', '']) == ['cba', 'ed']"}
{"id": "op_dropzeros_cube_dropfirst", "entry_point": "op_dropzeros_cube_dropfirst", "primitives": ["dropzeros", "cube", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then cube each, then drop the first element.", "solution": "def op_dropzeros_cube_dropfirst(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x ** 3 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_dropzeros_cube_dropfirst([1, 2, 3, 4]) == [8, 27, 64]\nassert op_dropzeros_cube_dropfirst([]) == []\nassert op_dropzeros_cube_dropfirst([-2, -1, 0, 1, 2]) == [-1, 1, 8]\nassert op_dropzeros_cube_dropfirst([5, 5, 5]) == [125, 125]\nassert op_dropzeros_cube_dropfirst([3, 1, 2]) == [1, 8]\nassert op_dropzeros_cube_dropfirst([10]) == []\nassert op_dropzeros_cube_dropfirst([2, 4, 6]) == [64, 216]\nassert op_dropzeros_cube_dropfirst([-7, 12, -7]) == [1728, -343]"}
{"id": "op_inc_last3_halve", "entry_point": "op_inc_last3_halve", "primitives": ["inc", "last3", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep only the last three, then halve each (integer division).", "solution": "def op_inc_last3_halve(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[-3:]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_inc_last3_halve([1, 2, 3, 4]) == [1, 2, 2]\nassert op_inc_last3_halve([]) == []\nassert op_inc_last3_halve([-2, -1, 0, 1, 2]) == [0, 1, 1]\nassert op_inc_last3_halve([5, 5, 5]) == [3, 3, 3]\nassert op_inc_last3_halve([3, 1, 2]) == [2, 1, 1]\nassert op_inc_last3_halve([10]) == [5]\nassert op_inc_last3_halve([2, 4, 6]) == [1, 2, 3]\nassert op_inc_last3_halve([-7, 12, -7]) == [-3, 6, -3]"}
{"id": "op_dropfirst_cube_oremptyzero", "entry_point": "op_dropfirst_cube_oremptyzero", "primitives": ["dropfirst", "cube", "oremptyzero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cube each, then if empty, use a single zero.", "solution": "def op_dropfirst_cube_oremptyzero(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x ** 3 for x in r]\n    r = r if r else [0]\n    return r", "tests": "assert op_dropfirst_cube_oremptyzero([1, 2, 3, 4]) == [8, 27, 64]\nassert op_dropfirst_cube_oremptyzero([]) == [0]\nassert op_dropfirst_cube_oremptyzero([-2, -1, 0, 1, 2]) == [-1, 0, 1, 8]\nassert op_dropfirst_cube_oremptyzero([5, 5, 5]) == [125, 125]\nassert op_dropfirst_cube_oremptyzero([3, 1, 2]) == [1, 8]\nassert op_dropfirst_cube_oremptyzero([10]) == [0]\nassert op_dropfirst_cube_oremptyzero([2, 4, 6]) == [64, 216]\nassert op_dropfirst_cube_oremptyzero([-7, 12, -7]) == [1728, -343]"}
{"id": "op_title_strip_nonempty", "entry_point": "op_title_strip_nonempty", "primitives": ["title", "strip", "nonempty"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then trim whitespace from each, then drop empty strings.", "solution": "def op_title_strip_nonempty(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = [s.strip() for s in r]\n    r = [s for s in r if s]\n    return r", "tests": "assert op_title_strip_nonempty(['Hello', 'world']) == ['Hello', 'World']\nassert op_title_strip_nonempty([]) == []\nassert op_title_strip_nonempty(['  a ', '', 'BC', 'bc']) == ['A', 'Bc', 'Bc']\nassert op_title_strip_nonempty(['one', 'one', 'Two']) == ['One', 'One', 'Two']\nassert op_title_strip_nonempty(['x']) == ['X']\nassert op_title_strip_nonempty(['abc', 'de', '']) == ['Abc', 'De']"}
{"id": "op_names_title_revstr", "entry_point": "op_names_title_revstr", "primitives": ["names", "title", "revstr"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the names, then title-case each string, then reverse each string.", "solution": "def op_names_title_revstr(xs):\n    r = list(xs)\n    r = [d['name'] for d in r]\n    r = [s.title() for s in r]\n    r = [s[::-1] for s in r]\n    return r", "tests": "assert op_names_title_revstr([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == ['adA', 'oB']\nassert op_names_title_revstr([]) == []\nassert op_names_title_revstr([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == ['yC', 'eeD', 'lE']\nassert op_names_title_revstr([{'name': 'Fi', 'age': 41}]) == ['iF']"}
{"id": "op_oremptyzero_div3_cube", "entry_point": "op_oremptyzero_div3_cube", "primitives": ["oremptyzero", "div3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then keep multiples of three, then cube each.", "solution": "def op_oremptyzero_div3_cube(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x for x in r if x % 3 == 0]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_oremptyzero_div3_cube([1, 2, 3, 4]) == [27]\nassert op_oremptyzero_div3_cube([]) == [0]\nassert op_oremptyzero_div3_cube([-2, -1, 0, 1, 2]) == [0]\nassert op_oremptyzero_div3_cube([5, 5, 5]) == []\nassert op_oremptyzero_div3_cube([3, 1, 2]) == [27]\nassert op_oremptyzero_div3_cube([10]) == []\nassert op_oremptyzero_div3_cube([2, 4, 6]) == [216]\nassert op_oremptyzero_div3_cube([-7, 12, -7]) == [1728]"}
{"id": "op_halve_dropwhileneg_oremptyzero", "entry_point": "op_halve_dropwhileneg_oremptyzero", "primitives": ["halve", "dropwhileneg", "oremptyzero"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the leading negative values, then if empty, use a single zero.", "solution": "def op_halve_dropwhileneg_oremptyzero(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = r if r else [0]\n    return r", "tests": "assert op_halve_dropwhileneg_oremptyzero([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_halve_dropwhileneg_oremptyzero([]) == [0]\nassert op_halve_dropwhileneg_oremptyzero([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_halve_dropwhileneg_oremptyzero([5, 5, 5]) == [2, 2, 2]\nassert op_halve_dropwhileneg_oremptyzero([3, 1, 2]) == [1, 0, 1]\nassert op_halve_dropwhileneg_oremptyzero([10]) == [5]\nassert op_halve_dropwhileneg_oremptyzero([2, 4, 6]) == [1, 2, 3]\nassert op_halve_dropwhileneg_oremptyzero([-7, 12, -7]) == [6, -4]"}
{"id": "op_dropzeros_halve_min", "entry_point": "op_dropzeros_halve_min", "primitives": ["dropzeros", "halve", "min"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then halve each (integer division), then return the minimum (0 if empty).", "solution": "def op_dropzeros_halve_min(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x // 2 for x in r]\n    return min(r) if r else 0", "tests": "assert op_dropzeros_halve_min([1, 2, 3, 4]) == 0\nassert op_dropzeros_halve_min([]) == 0\nassert op_dropzeros_halve_min([-2, -1, 0, 1, 2]) == -1\nassert op_dropzeros_halve_min([5, 5, 5]) == 2\nassert op_dropzeros_halve_min([3, 1, 2]) == 0\nassert op_dropzeros_halve_min([10]) == 5\nassert op_dropzeros_halve_min([2, 4, 6]) == 1\nassert op_dropzeros_halve_min([-7, 12, -7]) == -4"}
{"id": "op_cube_square_double", "entry_point": "op_cube_square_double", "primitives": ["cube", "square", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then square each, then double each.", "solution": "def op_cube_square_double(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x * x for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_cube_square_double([1, 2, 3, 4]) == [2, 128, 1458, 8192]\nassert op_cube_square_double([]) == []\nassert op_cube_square_double([-2, -1, 0, 1, 2]) == [128, 2, 0, 2, 128]\nassert op_cube_square_double([5, 5, 5]) == [31250, 31250, 31250]\nassert op_cube_square_double([3, 1, 2]) == [1458, 2, 128]\nassert op_cube_square_double([10]) == [2000000]\nassert op_cube_square_double([2, 4, 6]) == [128, 8192, 93312]\nassert op_cube_square_double([-7, 12, -7]) == [235298, 5971968, 235298]"}
{"id": "op_halve_div3_min", "entry_point": "op_halve_div3_min", "primitives": ["halve", "div3", "min"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep multiples of three, then return the minimum (0 if empty).", "solution": "def op_halve_div3_min(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    return min(r) if r else 0", "tests": "assert op_halve_div3_min([1, 2, 3, 4]) == 0\nassert op_halve_div3_min([]) == 0\nassert op_halve_div3_min([-2, -1, 0, 1, 2]) == 0\nassert op_halve_div3_min([5, 5, 5]) == 0\nassert op_halve_div3_min([3, 1, 2]) == 0\nassert op_halve_div3_min([10]) == 0\nassert op_halve_div3_min([2, 4, 6]) == 3\nassert op_halve_div3_min([-7, 12, -7]) == 6"}
{"id": "op_dec_trimends_range_", "entry_point": "op_dec_trimends_range_", "primitives": ["dec", "trimends", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then drop the first and last elements, then return the range (max minus min, 0 if empty).", "solution": "def op_dec_trimends_range_(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = r[1:-1]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dec_trimends_range_([1, 2, 3, 4]) == 1\nassert op_dec_trimends_range_([]) == 0\nassert op_dec_trimends_range_([-2, -1, 0, 1, 2]) == 2\nassert op_dec_trimends_range_([5, 5, 5]) == 0\nassert op_dec_trimends_range_([3, 1, 2]) == 0\nassert op_dec_trimends_range_([10]) == 0\nassert op_dec_trimends_range_([2, 4, 6]) == 0\nassert op_dec_trimends_range_([-7, 12, -7]) == 0"}
{"id": "op_oremptyzero_dropwhileneg_cube", "entry_point": "op_oremptyzero_dropwhileneg_cube", "primitives": ["oremptyzero", "dropwhileneg", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the leading negative values, then cube each.", "solution": "def op_oremptyzero_dropwhileneg_cube(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_oremptyzero_dropwhileneg_cube([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_oremptyzero_dropwhileneg_cube([]) == [0]\nassert op_oremptyzero_dropwhileneg_cube([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_oremptyzero_dropwhileneg_cube([5, 5, 5]) == [125, 125, 125]\nassert op_oremptyzero_dropwhileneg_cube([3, 1, 2]) == [27, 1, 8]\nassert op_oremptyzero_dropwhileneg_cube([10]) == [1000]\nassert op_oremptyzero_dropwhileneg_cube([2, 4, 6]) == [8, 64, 216]\nassert op_oremptyzero_dropwhileneg_cube([-7, 12, -7]) == [1728, -343]"}
{"id": "op_evens_add10_halve", "entry_point": "op_evens_add10_halve", "primitives": ["evens", "add10", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then add ten to each, then halve each (integer division).", "solution": "def op_evens_add10_halve(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x + 10 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_evens_add10_halve([1, 2, 3, 4]) == [6, 7]\nassert op_evens_add10_halve([]) == []\nassert op_evens_add10_halve([-2, -1, 0, 1, 2]) == [4, 5, 6]\nassert op_evens_add10_halve([5, 5, 5]) == []\nassert op_evens_add10_halve([3, 1, 2]) == [6]\nassert op_evens_add10_halve([10]) == [10]\nassert op_evens_add10_halve([2, 4, 6]) == [6, 7, 8]\nassert op_evens_add10_halve([-7, 12, -7]) == [11]"}
{"id": "op_inc_halve_sum", "entry_point": "op_inc_halve_sum", "primitives": ["inc", "halve", "sum"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then halve each (integer division), then return their sum.", "solution": "def op_inc_halve_sum(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x // 2 for x in r]\n    return sum(r)", "tests": "assert op_inc_halve_sum([1, 2, 3, 4]) == 6\nassert op_inc_halve_sum([]) == 0\nassert op_inc_halve_sum([-2, -1, 0, 1, 2]) == 1\nassert op_inc_halve_sum([5, 5, 5]) == 9\nassert op_inc_halve_sum([3, 1, 2]) == 4\nassert op_inc_halve_sum([10]) == 5\nassert op_inc_halve_sum([2, 4, 6]) == 6\nassert op_inc_halve_sum([-7, 12, -7]) == 0"}
{"id": "op_rev_halve_sorta", "entry_point": "op_rev_halve_sorta", "primitives": ["rev", "halve", "sorta"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; reverse the order, then halve each (integer division), then sort ascending.", "solution": "def op_rev_halve_sorta(xs):\n    r = list(xs)\n    r = list(reversed(r))\n    r = [x // 2 for x in r]\n    r = sorted(r)\n    return r", "tests": "assert op_rev_halve_sorta([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_rev_halve_sorta([]) == []\nassert op_rev_halve_sorta([-2, -1, 0, 1, 2]) == [-1, -1, 0, 0, 1]\nassert op_rev_halve_sorta([5, 5, 5]) == [2, 2, 2]\nassert op_rev_halve_sorta([3, 1, 2]) == [0, 1, 1]\nassert op_rev_halve_sorta([10]) == [5]\nassert op_rev_halve_sorta([2, 4, 6]) == [1, 2, 3]\nassert op_rev_halve_sorta([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_cube_inc_min", "entry_point": "op_cube_inc_min", "primitives": ["cube", "inc", "min"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then add one to each, then return the minimum (0 if empty).", "solution": "def op_cube_inc_min(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x + 1 for x in r]\n    return min(r) if r else 0", "tests": "assert op_cube_inc_min([1, 2, 3, 4]) == 2\nassert op_cube_inc_min([]) == 0\nassert op_cube_inc_min([-2, -1, 0, 1, 2]) == -7\nassert op_cube_inc_min([5, 5, 5]) == 126\nassert op_cube_inc_min([3, 1, 2]) == 2\nassert op_cube_inc_min([10]) == 1001\nassert op_cube_inc_min([2, 4, 6]) == 9\nassert op_cube_inc_min([-7, 12, -7]) == -342"}
{"id": "op_padto3_dropzeros_halve", "entry_point": "op_padto3_dropzeros_halve", "primitives": ["padto3", "dropzeros", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then drop the zeros, then halve each (integer division).", "solution": "def op_padto3_dropzeros_halve(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x for x in r if x != 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_padto3_dropzeros_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_padto3_dropzeros_halve([]) == []\nassert op_padto3_dropzeros_halve([-2, -1, 0, 1, 2]) == [-1, -1, 0, 1]\nassert op_padto3_dropzeros_halve([5, 5, 5]) == [2, 2, 2]\nassert op_padto3_dropzeros_halve([3, 1, 2]) == [1, 0, 1]\nassert op_padto3_dropzeros_halve([10]) == [5]\nassert op_padto3_dropzeros_halve([2, 4, 6]) == [1, 2, 3]\nassert op_padto3_dropzeros_halve([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_sortabs_halve_odds", "entry_point": "op_sortabs_halve_odds", "primitives": ["sortabs", "halve", "odds"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then halve each (integer division), then keep the odd numbers.", "solution": "def op_sortabs_halve_odds(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_sortabs_halve_odds([1, 2, 3, 4]) == [1, 1]\nassert op_sortabs_halve_odds([]) == []\nassert op_sortabs_halve_odds([-2, -1, 0, 1, 2]) == [-1, -1, 1]\nassert op_sortabs_halve_odds([5, 5, 5]) == []\nassert op_sortabs_halve_odds([3, 1, 2]) == [1, 1]\nassert op_sortabs_halve_odds([10]) == [5]\nassert op_sortabs_halve_odds([2, 4, 6]) == [1, 3]\nassert op_sortabs_halve_odds([-7, 12, -7]) == []"}
{"id": "op_halve_add10_dropfirst", "entry_point": "op_halve_add10_dropfirst", "primitives": ["halve", "add10", "dropfirst"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then add ten to each, then drop the first element.", "solution": "def op_halve_add10_dropfirst(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    r = r[1:]\n    return r", "tests": "assert op_halve_add10_dropfirst([1, 2, 3, 4]) == [11, 11, 12]\nassert op_halve_add10_dropfirst([]) == []\nassert op_halve_add10_dropfirst([-2, -1, 0, 1, 2]) == [9, 10, 10, 11]\nassert op_halve_add10_dropfirst([5, 5, 5]) == [12, 12]\nassert op_halve_add10_dropfirst([3, 1, 2]) == [10, 11]\nassert op_halve_add10_dropfirst([10]) == []\nassert op_halve_add10_dropfirst([2, 4, 6]) == [12, 13]\nassert op_halve_add10_dropfirst([-7, 12, -7]) == [16, 6]"}
{"id": "op_dropzeros_double_cube", "entry_point": "op_dropzeros_double_cube", "primitives": ["dropzeros", "double", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then cube each.", "solution": "def op_dropzeros_double_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropzeros_double_cube([1, 2, 3, 4]) == [8, 64, 216, 512]\nassert op_dropzeros_double_cube([]) == []\nassert op_dropzeros_double_cube([-2, -1, 0, 1, 2]) == [-64, -8, 8, 64]\nassert op_dropzeros_double_cube([5, 5, 5]) == [1000, 1000, 1000]\nassert op_dropzeros_double_cube([3, 1, 2]) == [216, 8, 64]\nassert op_dropzeros_double_cube([10]) == [8000]\nassert op_dropzeros_double_cube([2, 4, 6]) == [64, 512, 1728]\nassert op_dropzeros_double_cube([-7, 12, -7]) == [-2744, 13824, -2744]"}
{"id": "op_takewhilepos_div3_range_", "entry_point": "op_takewhilepos_div3_range_", "primitives": ["takewhilepos", "div3", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take values while they are positive, then keep multiples of three, then return the range (max minus min, 0 if empty).", "solution": "def op_takewhilepos_div3_range_(xs):\n    r = list(xs)\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    r = [x for x in r if x % 3 == 0]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_takewhilepos_div3_range_([1, 2, 3, 4]) == 0\nassert op_takewhilepos_div3_range_([]) == 0\nassert op_takewhilepos_div3_range_([-2, -1, 0, 1, 2]) == 0\nassert op_takewhilepos_div3_range_([5, 5, 5]) == 0\nassert op_takewhilepos_div3_range_([3, 1, 2]) == 0\nassert op_takewhilepos_div3_range_([10]) == 0\nassert op_takewhilepos_div3_range_([2, 4, 6]) == 0\nassert op_takewhilepos_div3_range_([-7, 12, -7]) == 0"}
{"id": "op_cube_div3_pos", "entry_point": "op_cube_div3_pos", "primitives": ["cube", "div3", "pos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep multiples of three, then keep the positive numbers.", "solution": "def op_cube_div3_pos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 3 == 0]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_cube_div3_pos([1, 2, 3, 4]) == [27]\nassert op_cube_div3_pos([]) == []\nassert op_cube_div3_pos([-2, -1, 0, 1, 2]) == []\nassert op_cube_div3_pos([5, 5, 5]) == []\nassert op_cube_div3_pos([3, 1, 2]) == [27]\nassert op_cube_div3_pos([10]) == []\nassert op_cube_div3_pos([2, 4, 6]) == [216]\nassert op_cube_div3_pos([-7, 12, -7]) == [1728]"}
{"id": "op_halve_sortabs_allpos", "entry_point": "op_halve_sortabs_allpos", "primitives": ["halve", "sortabs", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then sort by absolute value, then return whether all values are positive.", "solution": "def op_halve_sortabs_allpos(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = sorted(r, key=abs)\n    return all(x > 0 for x in r)", "tests": "assert op_halve_sortabs_allpos([1, 2, 3, 4]) == False\nassert op_halve_sortabs_allpos([]) == True\nassert op_halve_sortabs_allpos([-2, -1, 0, 1, 2]) == False\nassert op_halve_sortabs_allpos([5, 5, 5]) == True\nassert op_halve_sortabs_allpos([3, 1, 2]) == False\nassert op_halve_sortabs_allpos([10]) == True\nassert op_halve_sortabs_allpos([2, 4, 6]) == True\nassert op_halve_sortabs_allpos([-7, 12, -7]) == False"}
{"id": "op_sorta_halve_firsteven", "entry_point": "op_sorta_halve_firsteven", "primitives": ["sorta", "halve", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then halve each (integer division), then return the first even value (0 if none).", "solution": "def op_sorta_halve_firsteven(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x // 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_sorta_halve_firsteven([1, 2, 3, 4]) == 0\nassert op_sorta_halve_firsteven([]) == 0\nassert op_sorta_halve_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_sorta_halve_firsteven([5, 5, 5]) == 2\nassert op_sorta_halve_firsteven([3, 1, 2]) == 0\nassert op_sorta_halve_firsteven([10]) == 0\nassert op_sorta_halve_firsteven([2, 4, 6]) == 2\nassert op_sorta_halve_firsteven([-7, 12, -7]) == -4"}
{"id": "op_firstchar_title_strip", "entry_point": "op_firstchar_title_strip", "primitives": ["firstchar", "title", "strip"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; keep the first character of each (dropping empties), then title-case each string, then trim whitespace from each.", "solution": "def op_firstchar_title_strip(xs):\n    r = list(xs)\n    r = [s[0] for s in r if s]\n    r = [s.title() for s in r]\n    r = [s.strip() for s in r]\n    return r", "tests": "assert op_firstchar_title_strip(['Hello', 'world']) == ['H', 'W']\nassert op_firstchar_title_strip([]) == []\nassert op_firstchar_title_strip(['  a ', '', 'BC', 'bc']) == ['', 'B', 'B']\nassert op_firstchar_title_strip(['one', 'one', 'Two']) == ['O', 'O', 'T']\nassert op_firstchar_title_strip(['x']) == ['X']\nassert op_firstchar_title_strip(['abc', 'de', '']) == ['A', 'D']"}
{"id": "op_uniqs_revstr_lens", "entry_point": "op_uniqs_revstr_lens", "primitives": ["uniqs", "revstr", "lens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop duplicate strings keeping the first, then reverse each string, then return the total number of characters.", "solution": "def op_uniqs_revstr_lens(xs):\n    r = list(xs)\n    r = list(dict.fromkeys(r))\n    r = [s[::-1] for s in r]\n    return sum(len(s) for s in r)", "tests": "assert op_uniqs_revstr_lens(['Hello', 'world']) == 10\nassert op_uniqs_revstr_lens([]) == 0\nassert op_uniqs_revstr_lens(['  a ', '', 'BC', 'bc']) == 8\nassert op_uniqs_revstr_lens(['one', 'one', 'Two']) == 6\nassert op_uniqs_revstr_lens(['x']) == 1\nassert op_uniqs_revstr_lens(['abc', 'de', '']) == 5"}
{"id": "op_halve_clamp10_dec", "entry_point": "op_halve_clamp10_dec", "primitives": ["halve", "clamp10", "dec"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then cap each value at 10, then subtract one from each.", "solution": "def op_halve_clamp10_dec(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_halve_clamp10_dec([1, 2, 3, 4]) == [-1, 0, 0, 1]\nassert op_halve_clamp10_dec([]) == []\nassert op_halve_clamp10_dec([-2, -1, 0, 1, 2]) == [-2, -2, -1, -1, 0]\nassert op_halve_clamp10_dec([5, 5, 5]) == [1, 1, 1]\nassert op_halve_clamp10_dec([3, 1, 2]) == [0, -1, 0]\nassert op_halve_clamp10_dec([10]) == [4]\nassert op_halve_clamp10_dec([2, 4, 6]) == [0, 1, 2]\nassert op_halve_clamp10_dec([-7, 12, -7]) == [-5, 5, -5]"}
{"id": "op_sortabs_absval_halve", "entry_point": "op_sortabs_absval_halve", "primitives": ["sortabs", "absval", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then take the absolute value of each, then halve each (integer division).", "solution": "def op_sortabs_absval_halve(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [abs(x) for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_sortabs_absval_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_sortabs_absval_halve([]) == []\nassert op_sortabs_absval_halve([-2, -1, 0, 1, 2]) == [0, 0, 0, 1, 1]\nassert op_sortabs_absval_halve([5, 5, 5]) == [2, 2, 2]\nassert op_sortabs_absval_halve([3, 1, 2]) == [0, 1, 1]\nassert op_sortabs_absval_halve([10]) == [5]\nassert op_sortabs_absval_halve([2, 4, 6]) == [1, 2, 3]\nassert op_sortabs_absval_halve([-7, 12, -7]) == [3, 3, 6]"}
{"id": "op_padto3_double_range_", "entry_point": "op_padto3_double_range_", "primitives": ["padto3", "double", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then double each, then return the range (max minus min, 0 if empty).", "solution": "def op_padto3_double_range_(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x * 2 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_padto3_double_range_([1, 2, 3, 4]) == 6\nassert op_padto3_double_range_([]) == 0\nassert op_padto3_double_range_([-2, -1, 0, 1, 2]) == 8\nassert op_padto3_double_range_([5, 5, 5]) == 0\nassert op_padto3_double_range_([3, 1, 2]) == 4\nassert op_padto3_double_range_([10]) == 20\nassert op_padto3_double_range_([2, 4, 6]) == 8\nassert op_padto3_double_range_([-7, 12, -7]) == 38"}
{"id": "op_halve_dropfirst_inc", "entry_point": "op_halve_dropfirst_inc", "primitives": ["halve", "dropfirst", "inc"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the first element, then add one to each.", "solution": "def op_halve_dropfirst_inc(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[1:]\n    r = [x + 1 for x in r]\n    return r", "tests": "assert op_halve_dropfirst_inc([1, 2, 3, 4]) == [2, 2, 3]\nassert op_halve_dropfirst_inc([]) == []\nassert op_halve_dropfirst_inc([-2, -1, 0, 1, 2]) == [0, 1, 1, 2]\nassert op_halve_dropfirst_inc([5, 5, 5]) == [3, 3]\nassert op_halve_dropfirst_inc([3, 1, 2]) == [1, 2]\nassert op_halve_dropfirst_inc([10]) == []\nassert op_halve_dropfirst_inc([2, 4, 6]) == [3, 4]\nassert op_halve_dropfirst_inc([-7, 12, -7]) == [7, -3]"}
{"id": "op_halve_trimends_cube", "entry_point": "op_halve_trimends_cube", "primitives": ["halve", "trimends", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the first and last elements, then cube each.", "solution": "def op_halve_trimends_cube(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[1:-1]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_halve_trimends_cube([1, 2, 3, 4]) == [1, 1]\nassert op_halve_trimends_cube([]) == []\nassert op_halve_trimends_cube([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_halve_trimends_cube([5, 5, 5]) == [8]\nassert op_halve_trimends_cube([3, 1, 2]) == [0]\nassert op_halve_trimends_cube([10]) == []\nassert op_halve_trimends_cube([2, 4, 6]) == [8]\nassert op_halve_trimends_cube([-7, 12, -7]) == [216]"}
{"id": "op_evens_halve_issorted", "entry_point": "op_evens_halve_issorted", "primitives": ["evens", "halve", "issorted"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the even numbers, then halve each (integer division), then return whether the list is sorted ascending.", "solution": "def op_evens_halve_issorted(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 == 0]\n    r = [x // 2 for x in r]\n    return r == sorted(r)", "tests": "assert op_evens_halve_issorted([1, 2, 3, 4]) == True\nassert op_evens_halve_issorted([]) == True\nassert op_evens_halve_issorted([-2, -1, 0, 1, 2]) == True\nassert op_evens_halve_issorted([5, 5, 5]) == True\nassert op_evens_halve_issorted([3, 1, 2]) == True\nassert op_evens_halve_issorted([10]) == True\nassert op_evens_halve_issorted([2, 4, 6]) == True\nassert op_evens_halve_issorted([-7, 12, -7]) == True"}
{"id": "op_sorta_rev_cube", "entry_point": "op_sorta_rev_cube", "primitives": ["sorta", "rev", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then reverse the order, then cube each.", "solution": "def op_sorta_rev_cube(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = list(reversed(r))\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_sorta_rev_cube([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_sorta_rev_cube([]) == []\nassert op_sorta_rev_cube([-2, -1, 0, 1, 2]) == [8, 1, 0, -1, -8]\nassert op_sorta_rev_cube([5, 5, 5]) == [125, 125, 125]\nassert op_sorta_rev_cube([3, 1, 2]) == [27, 8, 1]\nassert op_sorta_rev_cube([10]) == [1000]\nassert op_sorta_rev_cube([2, 4, 6]) == [216, 64, 8]\nassert op_sorta_rev_cube([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_oremptyzero_halve_trimends", "entry_point": "op_oremptyzero_halve_trimends", "primitives": ["oremptyzero", "halve", "trimends"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then halve each (integer division), then drop the first and last elements.", "solution": "def op_oremptyzero_halve_trimends(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x // 2 for x in r]\n    r = r[1:-1]\n    return r", "tests": "assert op_oremptyzero_halve_trimends([1, 2, 3, 4]) == [1, 1]\nassert op_oremptyzero_halve_trimends([]) == []\nassert op_oremptyzero_halve_trimends([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_oremptyzero_halve_trimends([5, 5, 5]) == [2]\nassert op_oremptyzero_halve_trimends([3, 1, 2]) == [0]\nassert op_oremptyzero_halve_trimends([10]) == []\nassert op_oremptyzero_halve_trimends([2, 4, 6]) == [2]\nassert op_oremptyzero_halve_trimends([-7, 12, -7]) == [6]"}
{"id": "op_oremptyzero_halve_rev", "entry_point": "op_oremptyzero_halve_rev", "primitives": ["oremptyzero", "halve", "rev"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then halve each (integer division), then reverse the order.", "solution": "def op_oremptyzero_halve_rev(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = [x // 2 for x in r]\n    r = list(reversed(r))\n    return r", "tests": "assert op_oremptyzero_halve_rev([1, 2, 3, 4]) == [2, 1, 1, 0]\nassert op_oremptyzero_halve_rev([]) == [0]\nassert op_oremptyzero_halve_rev([-2, -1, 0, 1, 2]) == [1, 0, 0, -1, -1]\nassert op_oremptyzero_halve_rev([5, 5, 5]) == [2, 2, 2]\nassert op_oremptyzero_halve_rev([3, 1, 2]) == [1, 0, 1]\nassert op_oremptyzero_halve_rev([10]) == [5]\nassert op_oremptyzero_halve_rev([2, 4, 6]) == [3, 2, 1]\nassert op_oremptyzero_halve_rev([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_cube_first3_pos", "entry_point": "op_cube_first3_pos", "primitives": ["cube", "first3", "pos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep only the first three, then keep the positive numbers.", "solution": "def op_cube_first3_pos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[:3]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_cube_first3_pos([1, 2, 3, 4]) == [1, 8, 27]\nassert op_cube_first3_pos([]) == []\nassert op_cube_first3_pos([-2, -1, 0, 1, 2]) == []\nassert op_cube_first3_pos([5, 5, 5]) == [125, 125, 125]\nassert op_cube_first3_pos([3, 1, 2]) == [27, 1, 8]\nassert op_cube_first3_pos([10]) == [1000]\nassert op_cube_first3_pos([2, 4, 6]) == [8, 64, 216]\nassert op_cube_first3_pos([-7, 12, -7]) == [1728]"}
{"id": "op_dropfirst_dropwhileneg_halve", "entry_point": "op_dropfirst_dropwhileneg_halve", "primitives": ["dropfirst", "dropwhileneg", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then drop the leading negative values, then halve each (integer division).", "solution": "def op_dropfirst_dropwhileneg_halve(xs):\n    r = list(xs)\n    r = r[1:]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_dropfirst_dropwhileneg_halve([1, 2, 3, 4]) == [1, 1, 2]\nassert op_dropfirst_dropwhileneg_halve([]) == []\nassert op_dropfirst_dropwhileneg_halve([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_dropfirst_dropwhileneg_halve([5, 5, 5]) == [2, 2]\nassert op_dropfirst_dropwhileneg_halve([3, 1, 2]) == [0, 1]\nassert op_dropfirst_dropwhileneg_halve([10]) == []\nassert op_dropfirst_dropwhileneg_halve([2, 4, 6]) == [2, 3]\nassert op_dropfirst_dropwhileneg_halve([-7, 12, -7]) == [6, -4]"}
{"id": "op_padto3_halve_dec", "entry_point": "op_padto3_halve_dec", "primitives": ["padto3", "halve", "dec"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; pad with zeros to at least three elements, then halve each (integer division), then subtract one from each.", "solution": "def op_padto3_halve_dec(xs):\n    r = list(xs)\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    r = [x // 2 for x in r]\n    r = [x - 1 for x in r]\n    return r", "tests": "assert op_padto3_halve_dec([1, 2, 3, 4]) == [-1, 0, 0, 1]\nassert op_padto3_halve_dec([]) == [-1, -1, -1]\nassert op_padto3_halve_dec([-2, -1, 0, 1, 2]) == [-2, -2, -1, -1, 0]\nassert op_padto3_halve_dec([5, 5, 5]) == [1, 1, 1]\nassert op_padto3_halve_dec([3, 1, 2]) == [0, -1, 0]\nassert op_padto3_halve_dec([10]) == [4, -1, -1]\nassert op_padto3_halve_dec([2, 4, 6]) == [0, 1, 2]\nassert op_padto3_halve_dec([-7, 12, -7]) == [-5, 5, -5]"}
{"id": "op_oremptyzero_sortd_cube", "entry_point": "op_oremptyzero_sortd_cube", "primitives": ["oremptyzero", "sortd", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort descending, then cube each.", "solution": "def op_oremptyzero_sortd_cube(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, reverse=True)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_oremptyzero_sortd_cube([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_oremptyzero_sortd_cube([]) == [0]\nassert op_oremptyzero_sortd_cube([-2, -1, 0, 1, 2]) == [8, 1, 0, -1, -8]\nassert op_oremptyzero_sortd_cube([5, 5, 5]) == [125, 125, 125]\nassert op_oremptyzero_sortd_cube([3, 1, 2]) == [27, 8, 1]\nassert op_oremptyzero_sortd_cube([10]) == [1000]\nassert op_oremptyzero_sortd_cube([2, 4, 6]) == [216, 64, 8]\nassert op_oremptyzero_sortd_cube([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_revstr_nonempty_dropshort", "entry_point": "op_revstr_nonempty_dropshort", "primitives": ["revstr", "nonempty", "dropshort"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then drop empty strings, then drop strings shorter than three characters.", "solution": "def op_revstr_nonempty_dropshort(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s for s in r if s]\n    r = [s for s in r if len(s) >= 3]\n    return r", "tests": "assert op_revstr_nonempty_dropshort(['Hello', 'world']) == ['olleH', 'dlrow']\nassert op_revstr_nonempty_dropshort([]) == []\nassert op_revstr_nonempty_dropshort(['  a ', '', 'BC', 'bc']) == [' a  ']\nassert op_revstr_nonempty_dropshort(['one', 'one', 'Two']) == ['eno', 'eno', 'owT']\nassert op_revstr_nonempty_dropshort(['x']) == []\nassert op_revstr_nonempty_dropshort(['abc', 'de', '']) == ['cba']"}
{"id": "op_oremptyzero_trimends_halve", "entry_point": "op_oremptyzero_trimends_halve", "primitives": ["oremptyzero", "trimends", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then drop the first and last elements, then halve each (integer division).", "solution": "def op_oremptyzero_trimends_halve(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = r[1:-1]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_oremptyzero_trimends_halve([1, 2, 3, 4]) == [1, 1]\nassert op_oremptyzero_trimends_halve([]) == []\nassert op_oremptyzero_trimends_halve([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_oremptyzero_trimends_halve([5, 5, 5]) == [2]\nassert op_oremptyzero_trimends_halve([3, 1, 2]) == [0]\nassert op_oremptyzero_trimends_halve([10]) == []\nassert op_oremptyzero_trimends_halve([2, 4, 6]) == [2]\nassert op_oremptyzero_trimends_halve([-7, 12, -7]) == [6]"}
{"id": "op_sorta_oremptyzero_halve", "entry_point": "op_sorta_oremptyzero_halve", "primitives": ["sorta", "oremptyzero", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then if empty, use a single zero, then halve each (integer division).", "solution": "def op_sorta_oremptyzero_halve(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = r if r else [0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_sorta_oremptyzero_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_sorta_oremptyzero_halve([]) == [0]\nassert op_sorta_oremptyzero_halve([-2, -1, 0, 1, 2]) == [-1, -1, 0, 0, 1]\nassert op_sorta_oremptyzero_halve([5, 5, 5]) == [2, 2, 2]\nassert op_sorta_oremptyzero_halve([3, 1, 2]) == [0, 1, 1]\nassert op_sorta_oremptyzero_halve([10]) == [5]\nassert op_sorta_oremptyzero_halve([2, 4, 6]) == [1, 2, 3]\nassert op_sorta_oremptyzero_halve([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_inc_cube_first3", "entry_point": "op_inc_cube_first3", "primitives": ["inc", "cube", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then cube each, then keep only the first three.", "solution": "def op_inc_cube_first3(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [x ** 3 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_inc_cube_first3([1, 2, 3, 4]) == [8, 27, 64]\nassert op_inc_cube_first3([]) == []\nassert op_inc_cube_first3([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_inc_cube_first3([5, 5, 5]) == [216, 216, 216]\nassert op_inc_cube_first3([3, 1, 2]) == [64, 8, 27]\nassert op_inc_cube_first3([10]) == [1331]\nassert op_inc_cube_first3([2, 4, 6]) == [27, 125, 343]\nassert op_inc_cube_first3([-7, 12, -7]) == [-216, 2197, -216]"}
{"id": "op_sortabs_cube_clamp10", "entry_point": "op_sortabs_cube_clamp10", "primitives": ["sortabs", "cube", "clamp10"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cube each, then cap each value at 10.", "solution": "def op_sortabs_cube_clamp10(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x ** 3 for x in r]\n    r = [min(x, 10) for x in r]\n    return r", "tests": "assert op_sortabs_cube_clamp10([1, 2, 3, 4]) == [1, 8, 10, 10]\nassert op_sortabs_cube_clamp10([]) == []\nassert op_sortabs_cube_clamp10([-2, -1, 0, 1, 2]) == [0, -1, 1, -8, 8]\nassert op_sortabs_cube_clamp10([5, 5, 5]) == [10, 10, 10]\nassert op_sortabs_cube_clamp10([3, 1, 2]) == [1, 8, 10]\nassert op_sortabs_cube_clamp10([10]) == [10]\nassert op_sortabs_cube_clamp10([2, 4, 6]) == [8, 10, 10]\nassert op_sortabs_cube_clamp10([-7, 12, -7]) == [-343, -343, 10]"}
{"id": "op_trimends_uniq_cube", "entry_point": "op_trimends_uniq_cube", "primitives": ["trimends", "uniq", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then cube each.", "solution": "def op_trimends_uniq_cube(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_trimends_uniq_cube([1, 2, 3, 4]) == [8, 27]\nassert op_trimends_uniq_cube([]) == []\nassert op_trimends_uniq_cube([-2, -1, 0, 1, 2]) == [-1, 0, 1]\nassert op_trimends_uniq_cube([5, 5, 5]) == [125]\nassert op_trimends_uniq_cube([3, 1, 2]) == [1]\nassert op_trimends_uniq_cube([10]) == []\nassert op_trimends_uniq_cube([2, 4, 6]) == [64]\nassert op_trimends_uniq_cube([-7, 12, -7]) == [1728]"}
{"id": "op_odds_sortabs_cube", "entry_point": "op_odds_sortabs_cube", "primitives": ["odds", "sortabs", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then sort by absolute value, then cube each.", "solution": "def op_odds_sortabs_cube(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = sorted(r, key=abs)\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_odds_sortabs_cube([1, 2, 3, 4]) == [1, 27]\nassert op_odds_sortabs_cube([]) == []\nassert op_odds_sortabs_cube([-2, -1, 0, 1, 2]) == [-1, 1]\nassert op_odds_sortabs_cube([5, 5, 5]) == [125, 125, 125]\nassert op_odds_sortabs_cube([3, 1, 2]) == [1, 27]\nassert op_odds_sortabs_cube([10]) == []\nassert op_odds_sortabs_cube([2, 4, 6]) == []\nassert op_odds_sortabs_cube([-7, 12, -7]) == [-343, -343]"}
{"id": "op_first3_dec_halve", "entry_point": "op_first3_dec_halve", "primitives": ["first3", "dec", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then subtract one from each, then halve each (integer division).", "solution": "def op_first3_dec_halve(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x - 1 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_first3_dec_halve([1, 2, 3, 4]) == [0, 0, 1]\nassert op_first3_dec_halve([]) == []\nassert op_first3_dec_halve([-2, -1, 0, 1, 2]) == [-2, -1, -1]\nassert op_first3_dec_halve([5, 5, 5]) == [2, 2, 2]\nassert op_first3_dec_halve([3, 1, 2]) == [1, 0, 0]\nassert op_first3_dec_halve([10]) == [4]\nassert op_first3_dec_halve([2, 4, 6]) == [0, 1, 2]\nassert op_first3_dec_halve([-7, 12, -7]) == [-4, 5, -4]"}
{"id": "op_odds_cube_allpos", "entry_point": "op_odds_cube_allpos", "primitives": ["odds", "cube", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep the odd numbers, then cube each, then return whether all values are positive.", "solution": "def op_odds_cube_allpos(xs):\n    r = list(xs)\n    r = [x for x in r if x % 2 != 0]\n    r = [x ** 3 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_odds_cube_allpos([1, 2, 3, 4]) == True\nassert op_odds_cube_allpos([]) == True\nassert op_odds_cube_allpos([-2, -1, 0, 1, 2]) == False\nassert op_odds_cube_allpos([5, 5, 5]) == True\nassert op_odds_cube_allpos([3, 1, 2]) == True\nassert op_odds_cube_allpos([10]) == True\nassert op_odds_cube_allpos([2, 4, 6]) == True\nassert op_odds_cube_allpos([-7, 12, -7]) == False"}
{"id": "op_cube_oremptyzero_anyeven", "entry_point": "op_cube_oremptyzero_anyeven", "primitives": ["cube", "oremptyzero", "anyeven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then if empty, use a single zero, then return whether any value is even.", "solution": "def op_cube_oremptyzero_anyeven(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r if r else [0]\n    return any(x % 2 == 0 for x in r)", "tests": "assert op_cube_oremptyzero_anyeven([1, 2, 3, 4]) == True\nassert op_cube_oremptyzero_anyeven([]) == True\nassert op_cube_oremptyzero_anyeven([-2, -1, 0, 1, 2]) == True\nassert op_cube_oremptyzero_anyeven([5, 5, 5]) == False\nassert op_cube_oremptyzero_anyeven([3, 1, 2]) == True\nassert op_cube_oremptyzero_anyeven([10]) == True\nassert op_cube_oremptyzero_anyeven([2, 4, 6]) == True\nassert op_cube_oremptyzero_anyeven([-7, 12, -7]) == True"}
{"id": "op_halve_padto3_allpos", "entry_point": "op_halve_padto3_allpos", "primitives": ["halve", "padto3", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then pad with zeros to at least three elements, then return whether all values are positive.", "solution": "def op_halve_padto3_allpos(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return all(x > 0 for x in r)", "tests": "assert op_halve_padto3_allpos([1, 2, 3, 4]) == False\nassert op_halve_padto3_allpos([]) == False\nassert op_halve_padto3_allpos([-2, -1, 0, 1, 2]) == False\nassert op_halve_padto3_allpos([5, 5, 5]) == True\nassert op_halve_padto3_allpos([3, 1, 2]) == False\nassert op_halve_padto3_allpos([10]) == False\nassert op_halve_padto3_allpos([2, 4, 6]) == True\nassert op_halve_padto3_allpos([-7, 12, -7]) == False"}
{"id": "op_first3_halve_firsteven", "entry_point": "op_first3_halve_firsteven", "primitives": ["first3", "halve", "firsteven"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the first three, then halve each (integer division), then return the first even value (0 if none).", "solution": "def op_first3_halve_firsteven(xs):\n    r = list(xs)\n    r = r[:3]\n    r = [x // 2 for x in r]\n    return next((x for x in r if x % 2 == 0), 0)", "tests": "assert op_first3_halve_firsteven([1, 2, 3, 4]) == 0\nassert op_first3_halve_firsteven([]) == 0\nassert op_first3_halve_firsteven([-2, -1, 0, 1, 2]) == 0\nassert op_first3_halve_firsteven([5, 5, 5]) == 2\nassert op_first3_halve_firsteven([3, 1, 2]) == 0\nassert op_first3_halve_firsteven([10]) == 0\nassert op_first3_halve_firsteven([2, 4, 6]) == 2\nassert op_first3_halve_firsteven([-7, 12, -7]) == -4"}
{"id": "op_nonempty_revstr_firstchar", "entry_point": "op_nonempty_revstr_firstchar", "primitives": ["nonempty", "revstr", "firstchar"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then reverse each string, then keep the first character of each (dropping empties).", "solution": "def op_nonempty_revstr_firstchar(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s[::-1] for s in r]\n    r = [s[0] for s in r if s]\n    return r", "tests": "assert op_nonempty_revstr_firstchar(['Hello', 'world']) == ['o', 'd']\nassert op_nonempty_revstr_firstchar([]) == []\nassert op_nonempty_revstr_firstchar(['  a ', '', 'BC', 'bc']) == [' ', 'C', 'c']\nassert op_nonempty_revstr_firstchar(['one', 'one', 'Two']) == ['e', 'e', 'o']\nassert op_nonempty_revstr_firstchar(['x']) == ['x']\nassert op_nonempty_revstr_firstchar(['abc', 'de', '']) == ['c', 'e']"}
{"id": "op_halve_neg_rev", "entry_point": "op_halve_neg_rev", "primitives": ["halve", "neg", "rev"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then keep the negative numbers, then reverse the order.", "solution": "def op_halve_neg_rev(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x for x in r if x < 0]\n    r = list(reversed(r))\n    return r", "tests": "assert op_halve_neg_rev([1, 2, 3, 4]) == []\nassert op_halve_neg_rev([]) == []\nassert op_halve_neg_rev([-2, -1, 0, 1, 2]) == [-1, -1]\nassert op_halve_neg_rev([5, 5, 5]) == []\nassert op_halve_neg_rev([3, 1, 2]) == []\nassert op_halve_neg_rev([10]) == []\nassert op_halve_neg_rev([2, 4, 6]) == []\nassert op_halve_neg_rev([-7, 12, -7]) == [-4, -4]"}
{"id": "op_negate_dec_range_", "entry_point": "op_negate_dec_range_", "primitives": ["negate", "dec", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then subtract one from each, then return the range (max minus min, 0 if empty).", "solution": "def op_negate_dec_range_(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = [x - 1 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_negate_dec_range_([1, 2, 3, 4]) == 3\nassert op_negate_dec_range_([]) == 0\nassert op_negate_dec_range_([-2, -1, 0, 1, 2]) == 4\nassert op_negate_dec_range_([5, 5, 5]) == 0\nassert op_negate_dec_range_([3, 1, 2]) == 2\nassert op_negate_dec_range_([10]) == 0\nassert op_negate_dec_range_([2, 4, 6]) == 4\nassert op_negate_dec_range_([-7, 12, -7]) == 19"}
{"id": "op_cube_last3_negate", "entry_point": "op_cube_last3_negate", "primitives": ["cube", "last3", "negate"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep only the last three, then negate each.", "solution": "def op_cube_last3_negate(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[-3:]\n    r = [-x for x in r]\n    return r", "tests": "assert op_cube_last3_negate([1, 2, 3, 4]) == [-8, -27, -64]\nassert op_cube_last3_negate([]) == []\nassert op_cube_last3_negate([-2, -1, 0, 1, 2]) == [0, -1, -8]\nassert op_cube_last3_negate([5, 5, 5]) == [-125, -125, -125]\nassert op_cube_last3_negate([3, 1, 2]) == [-27, -1, -8]\nassert op_cube_last3_negate([10]) == [-1000]\nassert op_cube_last3_negate([2, 4, 6]) == [-8, -64, -216]\nassert op_cube_last3_negate([-7, 12, -7]) == [343, -1728, 343]"}
{"id": "op_revstr_lower_sortlen", "entry_point": "op_revstr_lower_sortlen", "primitives": ["revstr", "lower", "sortlen"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then lowercase each string, then sort by length, shortest first.", "solution": "def op_revstr_lower_sortlen(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.lower() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_revstr_lower_sortlen(['Hello', 'world']) == ['olleh', 'dlrow']\nassert op_revstr_lower_sortlen([]) == []\nassert op_revstr_lower_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'cb', 'cb', ' a  ']\nassert op_revstr_lower_sortlen(['one', 'one', 'Two']) == ['eno', 'eno', 'owt']\nassert op_revstr_lower_sortlen(['x']) == ['x']\nassert op_revstr_lower_sortlen(['abc', 'de', '']) == ['', 'ed', 'cba']"}
{"id": "op_absval_last3_range_", "entry_point": "op_absval_last3_range_", "primitives": ["absval", "last3", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; take the absolute value of each, then keep only the last three, then return the range (max minus min, 0 if empty).", "solution": "def op_absval_last3_range_(xs):\n    r = list(xs)\n    r = [abs(x) for x in r]\n    r = r[-3:]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_absval_last3_range_([1, 2, 3, 4]) == 2\nassert op_absval_last3_range_([]) == 0\nassert op_absval_last3_range_([-2, -1, 0, 1, 2]) == 2\nassert op_absval_last3_range_([5, 5, 5]) == 0\nassert op_absval_last3_range_([3, 1, 2]) == 2\nassert op_absval_last3_range_([10]) == 0\nassert op_absval_last3_range_([2, 4, 6]) == 4\nassert op_absval_last3_range_([-7, 12, -7]) == 5"}
{"id": "op_square_cube_double", "entry_point": "op_square_cube_double", "primitives": ["square", "cube", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; square each, then cube each, then double each.", "solution": "def op_square_cube_double(xs):\n    r = list(xs)\n    r = [x * x for x in r]\n    r = [x ** 3 for x in r]\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_square_cube_double([1, 2, 3, 4]) == [2, 128, 1458, 8192]\nassert op_square_cube_double([]) == []\nassert op_square_cube_double([-2, -1, 0, 1, 2]) == [128, 2, 0, 2, 128]\nassert op_square_cube_double([5, 5, 5]) == [31250, 31250, 31250]\nassert op_square_cube_double([3, 1, 2]) == [1458, 2, 128]\nassert op_square_cube_double([10]) == [2000000]\nassert op_square_cube_double([2, 4, 6]) == [128, 8192, 93312]\nassert op_square_cube_double([-7, 12, -7]) == [235298, 5971968, 235298]"}
{"id": "op_clamp10_dropzeros_halve", "entry_point": "op_clamp10_dropzeros_halve", "primitives": ["clamp10", "dropzeros", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then drop the zeros, then halve each (integer division).", "solution": "def op_clamp10_dropzeros_halve(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x for x in r if x != 0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_clamp10_dropzeros_halve([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_clamp10_dropzeros_halve([]) == []\nassert op_clamp10_dropzeros_halve([-2, -1, 0, 1, 2]) == [-1, -1, 0, 1]\nassert op_clamp10_dropzeros_halve([5, 5, 5]) == [2, 2, 2]\nassert op_clamp10_dropzeros_halve([3, 1, 2]) == [1, 0, 1]\nassert op_clamp10_dropzeros_halve([10]) == [5]\nassert op_clamp10_dropzeros_halve([2, 4, 6]) == [1, 2, 3]\nassert op_clamp10_dropzeros_halve([-7, 12, -7]) == [-4, 5, -4]"}
{"id": "op_cube_oremptyzero_padto3", "entry_point": "op_cube_oremptyzero_padto3", "primitives": ["cube", "oremptyzero", "padto3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then if empty, use a single zero, then pad with zeros to at least three elements.", "solution": "def op_cube_oremptyzero_padto3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r if r else [0]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_cube_oremptyzero_padto3([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_cube_oremptyzero_padto3([]) == [0, 0, 0]\nassert op_cube_oremptyzero_padto3([-2, -1, 0, 1, 2]) == [-8, -1, 0, 1, 8]\nassert op_cube_oremptyzero_padto3([5, 5, 5]) == [125, 125, 125]\nassert op_cube_oremptyzero_padto3([3, 1, 2]) == [27, 1, 8]\nassert op_cube_oremptyzero_padto3([10]) == [1000, 0, 0]\nassert op_cube_oremptyzero_padto3([2, 4, 6]) == [8, 64, 216]\nassert op_cube_oremptyzero_padto3([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_sortd_dropfirst_range_", "entry_point": "op_sortd_dropfirst_range_", "primitives": ["sortd", "dropfirst", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort descending, then drop the first element, then return the range (max minus min, 0 if empty).", "solution": "def op_sortd_dropfirst_range_(xs):\n    r = list(xs)\n    r = sorted(r, reverse=True)\n    r = r[1:]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_sortd_dropfirst_range_([1, 2, 3, 4]) == 2\nassert op_sortd_dropfirst_range_([]) == 0\nassert op_sortd_dropfirst_range_([-2, -1, 0, 1, 2]) == 3\nassert op_sortd_dropfirst_range_([5, 5, 5]) == 0\nassert op_sortd_dropfirst_range_([3, 1, 2]) == 1\nassert op_sortd_dropfirst_range_([10]) == 0\nassert op_sortd_dropfirst_range_([2, 4, 6]) == 2\nassert op_sortd_dropfirst_range_([-7, 12, -7]) == 0"}
{"id": "op_sortabs_cube_evens", "entry_point": "op_sortabs_cube_evens", "primitives": ["sortabs", "cube", "evens"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort by absolute value, then cube each, then keep the even numbers.", "solution": "def op_sortabs_cube_evens(xs):\n    r = list(xs)\n    r = sorted(r, key=abs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 2 == 0]\n    return r", "tests": "assert op_sortabs_cube_evens([1, 2, 3, 4]) == [8, 64]\nassert op_sortabs_cube_evens([]) == []\nassert op_sortabs_cube_evens([-2, -1, 0, 1, 2]) == [0, -8, 8]\nassert op_sortabs_cube_evens([5, 5, 5]) == []\nassert op_sortabs_cube_evens([3, 1, 2]) == [8]\nassert op_sortabs_cube_evens([10]) == [1000]\nassert op_sortabs_cube_evens([2, 4, 6]) == [8, 64, 216]\nassert op_sortabs_cube_evens([-7, 12, -7]) == [1728]"}
{"id": "op_last3_dropfirst_range_", "entry_point": "op_last3_dropfirst_range_", "primitives": ["last3", "dropfirst", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; keep only the last three, then drop the first element, then return the range (max minus min, 0 if empty).", "solution": "def op_last3_dropfirst_range_(xs):\n    r = list(xs)\n    r = r[-3:]\n    r = r[1:]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_last3_dropfirst_range_([1, 2, 3, 4]) == 1\nassert op_last3_dropfirst_range_([]) == 0\nassert op_last3_dropfirst_range_([-2, -1, 0, 1, 2]) == 1\nassert op_last3_dropfirst_range_([5, 5, 5]) == 0\nassert op_last3_dropfirst_range_([3, 1, 2]) == 1\nassert op_last3_dropfirst_range_([10]) == 0\nassert op_last3_dropfirst_range_([2, 4, 6]) == 2\nassert op_last3_dropfirst_range_([-7, 12, -7]) == 19"}
{"id": "op_dropzeros_double_range_", "entry_point": "op_dropzeros_double_range_", "primitives": ["dropzeros", "double", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the zeros, then double each, then return the range (max minus min, 0 if empty).", "solution": "def op_dropzeros_double_range_(xs):\n    r = list(xs)\n    r = [x for x in r if x != 0]\n    r = [x * 2 for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_dropzeros_double_range_([1, 2, 3, 4]) == 6\nassert op_dropzeros_double_range_([]) == 0\nassert op_dropzeros_double_range_([-2, -1, 0, 1, 2]) == 8\nassert op_dropzeros_double_range_([5, 5, 5]) == 0\nassert op_dropzeros_double_range_([3, 1, 2]) == 4\nassert op_dropzeros_double_range_([10]) == 0\nassert op_dropzeros_double_range_([2, 4, 6]) == 8\nassert op_dropzeros_double_range_([-7, 12, -7]) == 38"}
{"id": "op_ages_rev_cube", "entry_point": "op_ages_rev_cube", "primitives": ["ages", "rev", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then reverse the order, then cube each.", "solution": "def op_ages_rev_cube(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = list(reversed(r))\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_ages_rev_cube([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == [1728, 46656]\nassert op_ages_rev_cube([]) == []\nassert op_ages_rev_cube([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [4913, 274625, 5832]\nassert op_ages_rev_cube([{'name': 'Fi', 'age': 41}]) == [68921]"}
{"id": "op_halve_add10_uniq", "entry_point": "op_halve_add10_uniq", "primitives": ["halve", "add10", "uniq"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then add ten to each, then drop duplicates keeping first occurrence.", "solution": "def op_halve_add10_uniq(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x + 10 for x in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_halve_add10_uniq([1, 2, 3, 4]) == [10, 11, 12]\nassert op_halve_add10_uniq([]) == []\nassert op_halve_add10_uniq([-2, -1, 0, 1, 2]) == [9, 10, 11]\nassert op_halve_add10_uniq([5, 5, 5]) == [12]\nassert op_halve_add10_uniq([3, 1, 2]) == [11, 10]\nassert op_halve_add10_uniq([10]) == [15]\nassert op_halve_add10_uniq([2, 4, 6]) == [11, 12, 13]\nassert op_halve_add10_uniq([-7, 12, -7]) == [6, 16]"}
{"id": "op_oremptyzero_sortabs_range_", "entry_point": "op_oremptyzero_sortabs_range_", "primitives": ["oremptyzero", "sortabs", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; if empty, use a single zero, then sort by absolute value, then return the range (max minus min, 0 if empty).", "solution": "def op_oremptyzero_sortabs_range_(xs):\n    r = list(xs)\n    r = r if r else [0]\n    r = sorted(r, key=abs)\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_oremptyzero_sortabs_range_([1, 2, 3, 4]) == 3\nassert op_oremptyzero_sortabs_range_([]) == 0\nassert op_oremptyzero_sortabs_range_([-2, -1, 0, 1, 2]) == 4\nassert op_oremptyzero_sortabs_range_([5, 5, 5]) == 0\nassert op_oremptyzero_sortabs_range_([3, 1, 2]) == 2\nassert op_oremptyzero_sortabs_range_([10]) == 0\nassert op_oremptyzero_sortabs_range_([2, 4, 6]) == 4\nassert op_oremptyzero_sortabs_range_([-7, 12, -7]) == 19"}
{"id": "op_revstr_strip_sortlen", "entry_point": "op_revstr_strip_sortlen", "primitives": ["revstr", "strip", "sortlen"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then trim whitespace from each, then sort by length, shortest first.", "solution": "def op_revstr_strip_sortlen(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.strip() for s in r]\n    r = sorted(r, key=len)\n    return r", "tests": "assert op_revstr_strip_sortlen(['Hello', 'world']) == ['olleH', 'dlrow']\nassert op_revstr_strip_sortlen([]) == []\nassert op_revstr_strip_sortlen(['  a ', '', 'BC', 'bc']) == ['', 'a', 'CB', 'cb']\nassert op_revstr_strip_sortlen(['one', 'one', 'Two']) == ['eno', 'eno', 'owT']\nassert op_revstr_strip_sortlen(['x']) == ['x']\nassert op_revstr_strip_sortlen(['abc', 'de', '']) == ['', 'ed', 'cba']"}
{"id": "op_ages_cube_odds", "entry_point": "op_ages_cube_odds", "primitives": ["ages", "cube", "odds"], "difficulty": 2, "split": "heldout_zeroshot", "type": "RL", "prompt": "Take a list of people records (name, age); extract the ages, then cube each, then keep the odd numbers.", "solution": "def op_ages_cube_odds(xs):\n    r = list(xs)\n    r = [d['age'] for d in r]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x % 2 != 0]\n    return r", "tests": "assert op_ages_cube_odds([{'name': 'Ada', 'age': 36}, {'name': 'Bo', 'age': 12}]) == []\nassert op_ages_cube_odds([]) == []\nassert op_ages_cube_odds([{'name': 'Cy', 'age': 18}, {'name': 'Dee', 'age': 65}, {'name': 'El', 'age': 17}]) == [274625, 4913]\nassert op_ages_cube_odds([{'name': 'Fi', 'age': 41}]) == [68921]"}
{"id": "op_title_nonempty_prefixup", "entry_point": "op_title_nonempty_prefixup", "primitives": ["title", "nonempty", "prefixup"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; title-case each string, then drop empty strings, then prefix each with a hash.", "solution": "def op_title_nonempty_prefixup(xs):\n    r = list(xs)\n    r = [s.title() for s in r]\n    r = [s for s in r if s]\n    r = ['#' + s for s in r]\n    return r", "tests": "assert op_title_nonempty_prefixup(['Hello', 'world']) == ['#Hello', '#World']\nassert op_title_nonempty_prefixup([]) == []\nassert op_title_nonempty_prefixup(['  a ', '', 'BC', 'bc']) == ['#  A ', '#Bc', '#Bc']\nassert op_title_nonempty_prefixup(['one', 'one', 'Two']) == ['#One', '#One', '#Two']\nassert op_title_nonempty_prefixup(['x']) == ['#X']\nassert op_title_nonempty_prefixup(['abc', 'de', '']) == ['#Abc', '#De']"}
{"id": "op_cube_sortd", "entry_point": "op_cube_sortd", "primitives": ["cube", "sortd"], "difficulty": 1, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then sort descending.", "solution": "def op_cube_sortd(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = sorted(r, reverse=True)\n    return r", "tests": "assert op_cube_sortd([1, 2, 3, 4]) == [64, 27, 8, 1]\nassert op_cube_sortd([]) == []\nassert op_cube_sortd([-2, -1, 0, 1, 2]) == [8, 1, 0, -1, -8]\nassert op_cube_sortd([5, 5, 5]) == [125, 125, 125]\nassert op_cube_sortd([3, 1, 2]) == [27, 8, 1]\nassert op_cube_sortd([10]) == [1000]\nassert op_cube_sortd([2, 4, 6]) == [216, 64, 8]\nassert op_cube_sortd([-7, 12, -7]) == [1728, -343, -343]"}
{"id": "op_dropfirst_cube_halve", "entry_point": "op_dropfirst_cube_halve", "primitives": ["dropfirst", "cube", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first element, then cube each, then halve each (integer division).", "solution": "def op_dropfirst_cube_halve(xs):\n    r = list(xs)\n    r = r[1:]\n    r = [x ** 3 for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_dropfirst_cube_halve([1, 2, 3, 4]) == [4, 13, 32]\nassert op_dropfirst_cube_halve([]) == []\nassert op_dropfirst_cube_halve([-2, -1, 0, 1, 2]) == [-1, 0, 0, 4]\nassert op_dropfirst_cube_halve([5, 5, 5]) == [62, 62]\nassert op_dropfirst_cube_halve([3, 1, 2]) == [0, 4]\nassert op_dropfirst_cube_halve([10]) == []\nassert op_dropfirst_cube_halve([2, 4, 6]) == [32, 108]\nassert op_dropfirst_cube_halve([-7, 12, -7]) == [864, -172]"}
{"id": "op_halve_double_first3", "entry_point": "op_halve_double_first3", "primitives": ["halve", "double", "first3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then double each, then keep only the first three.", "solution": "def op_halve_double_first3(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [x * 2 for x in r]\n    r = r[:3]\n    return r", "tests": "assert op_halve_double_first3([1, 2, 3, 4]) == [0, 2, 2]\nassert op_halve_double_first3([]) == []\nassert op_halve_double_first3([-2, -1, 0, 1, 2]) == [-2, -2, 0]\nassert op_halve_double_first3([5, 5, 5]) == [4, 4, 4]\nassert op_halve_double_first3([3, 1, 2]) == [2, 0, 2]\nassert op_halve_double_first3([10]) == [10]\nassert op_halve_double_first3([2, 4, 6]) == [2, 4, 6]\nassert op_halve_double_first3([-7, 12, -7]) == [-8, 12, -8]"}
{"id": "op_cube_trimends_max", "entry_point": "op_cube_trimends_max", "primitives": ["cube", "trimends", "max"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then drop the first and last elements, then return the maximum (0 if empty).", "solution": "def op_cube_trimends_max(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[1:-1]\n    return max(r) if r else 0", "tests": "assert op_cube_trimends_max([1, 2, 3, 4]) == 27\nassert op_cube_trimends_max([]) == 0\nassert op_cube_trimends_max([-2, -1, 0, 1, 2]) == 1\nassert op_cube_trimends_max([5, 5, 5]) == 125\nassert op_cube_trimends_max([3, 1, 2]) == 1\nassert op_cube_trimends_max([10]) == 0\nassert op_cube_trimends_max([2, 4, 6]) == 64\nassert op_cube_trimends_max([-7, 12, -7]) == 1728"}
{"id": "op_nonempty_title_uniqs", "entry_point": "op_nonempty_title_uniqs", "primitives": ["nonempty", "title", "uniqs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; drop empty strings, then title-case each string, then drop duplicate strings keeping the first.", "solution": "def op_nonempty_title_uniqs(xs):\n    r = list(xs)\n    r = [s for s in r if s]\n    r = [s.title() for s in r]\n    r = list(dict.fromkeys(r))\n    return r", "tests": "assert op_nonempty_title_uniqs(['Hello', 'world']) == ['Hello', 'World']\nassert op_nonempty_title_uniqs([]) == []\nassert op_nonempty_title_uniqs(['  a ', '', 'BC', 'bc']) == ['  A ', 'Bc']\nassert op_nonempty_title_uniqs(['one', 'one', 'Two']) == ['One', 'Two']\nassert op_nonempty_title_uniqs(['x']) == ['X']\nassert op_nonempty_title_uniqs(['abc', 'de', '']) == ['Abc', 'De']"}
{"id": "op_halve_dropwhileneg_negate", "entry_point": "op_halve_dropwhileneg_negate", "primitives": ["halve", "dropwhileneg", "negate"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then drop the leading negative values, then negate each.", "solution": "def op_halve_dropwhileneg_negate(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [-x for x in r]\n    return r", "tests": "assert op_halve_dropwhileneg_negate([1, 2, 3, 4]) == [0, -1, -1, -2]\nassert op_halve_dropwhileneg_negate([]) == []\nassert op_halve_dropwhileneg_negate([-2, -1, 0, 1, 2]) == [0, 0, -1]\nassert op_halve_dropwhileneg_negate([5, 5, 5]) == [-2, -2, -2]\nassert op_halve_dropwhileneg_negate([3, 1, 2]) == [-1, 0, -1]\nassert op_halve_dropwhileneg_negate([10]) == [-5]\nassert op_halve_dropwhileneg_negate([2, 4, 6]) == [-1, -2, -3]\nassert op_halve_dropwhileneg_negate([-7, 12, -7]) == [-6, 4]"}
{"id": "op_inc_trimends_halve", "entry_point": "op_inc_trimends_halve", "primitives": ["inc", "trimends", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then drop the first and last elements, then halve each (integer division).", "solution": "def op_inc_trimends_halve(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[1:-1]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_inc_trimends_halve([1, 2, 3, 4]) == [1, 2]\nassert op_inc_trimends_halve([]) == []\nassert op_inc_trimends_halve([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_inc_trimends_halve([5, 5, 5]) == [3]\nassert op_inc_trimends_halve([3, 1, 2]) == [1]\nassert op_inc_trimends_halve([10]) == []\nassert op_inc_trimends_halve([2, 4, 6]) == [2]\nassert op_inc_trimends_halve([-7, 12, -7]) == [6]"}
{"id": "op_dec_cube_allpos", "entry_point": "op_dec_cube_allpos", "primitives": ["dec", "cube", "allpos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; subtract one from each, then cube each, then return whether all values are positive.", "solution": "def op_dec_cube_allpos(xs):\n    r = list(xs)\n    r = [x - 1 for x in r]\n    r = [x ** 3 for x in r]\n    return all(x > 0 for x in r)", "tests": "assert op_dec_cube_allpos([1, 2, 3, 4]) == False\nassert op_dec_cube_allpos([]) == True\nassert op_dec_cube_allpos([-2, -1, 0, 1, 2]) == False\nassert op_dec_cube_allpos([5, 5, 5]) == True\nassert op_dec_cube_allpos([3, 1, 2]) == False\nassert op_dec_cube_allpos([10]) == True\nassert op_dec_cube_allpos([2, 4, 6]) == True\nassert op_dec_cube_allpos([-7, 12, -7]) == False"}
{"id": "op_inc_absval_range_", "entry_point": "op_inc_absval_range_", "primitives": ["inc", "absval", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then take the absolute value of each, then return the range (max minus min, 0 if empty).", "solution": "def op_inc_absval_range_(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = [abs(x) for x in r]\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_inc_absval_range_([1, 2, 3, 4]) == 3\nassert op_inc_absval_range_([]) == 0\nassert op_inc_absval_range_([-2, -1, 0, 1, 2]) == 3\nassert op_inc_absval_range_([5, 5, 5]) == 0\nassert op_inc_absval_range_([3, 1, 2]) == 2\nassert op_inc_absval_range_([10]) == 0\nassert op_inc_absval_range_([2, 4, 6]) == 4\nassert op_inc_absval_range_([-7, 12, -7]) == 7"}
{"id": "op_sorta_halve_sortabs", "entry_point": "op_sorta_halve_sortabs", "primitives": ["sorta", "halve", "sortabs"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then halve each (integer division), then sort by absolute value.", "solution": "def op_sorta_halve_sortabs(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [x // 2 for x in r]\n    r = sorted(r, key=abs)\n    return r", "tests": "assert op_sorta_halve_sortabs([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_sorta_halve_sortabs([]) == []\nassert op_sorta_halve_sortabs([-2, -1, 0, 1, 2]) == [0, 0, -1, -1, 1]\nassert op_sorta_halve_sortabs([5, 5, 5]) == [2, 2, 2]\nassert op_sorta_halve_sortabs([3, 1, 2]) == [0, 1, 1]\nassert op_sorta_halve_sortabs([10]) == [5]\nassert op_sorta_halve_sortabs([2, 4, 6]) == [1, 2, 3]\nassert op_sorta_halve_sortabs([-7, 12, -7]) == [-4, -4, 6]"}
{"id": "op_halve_clamp10_padto3", "entry_point": "op_halve_clamp10_padto3", "primitives": ["halve", "clamp10", "padto3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then cap each value at 10, then pad with zeros to at least three elements.", "solution": "def op_halve_clamp10_padto3(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = [min(x, 10) for x in r]\n    r = r + [0] * (3 - len(r)) if len(r) < 3 else r\n    return r", "tests": "assert op_halve_clamp10_padto3([1, 2, 3, 4]) == [0, 1, 1, 2]\nassert op_halve_clamp10_padto3([]) == [0, 0, 0]\nassert op_halve_clamp10_padto3([-2, -1, 0, 1, 2]) == [-1, -1, 0, 0, 1]\nassert op_halve_clamp10_padto3([5, 5, 5]) == [2, 2, 2]\nassert op_halve_clamp10_padto3([3, 1, 2]) == [1, 0, 1]\nassert op_halve_clamp10_padto3([10]) == [5, 0, 0]\nassert op_halve_clamp10_padto3([2, 4, 6]) == [1, 2, 3]\nassert op_halve_clamp10_padto3([-7, 12, -7]) == [-4, 6, -4]"}
{"id": "op_cube_neg_div3", "entry_point": "op_cube_neg_div3", "primitives": ["cube", "neg", "div3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep the negative numbers, then keep multiples of three.", "solution": "def op_cube_neg_div3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x < 0]\n    r = [x for x in r if x % 3 == 0]\n    return r", "tests": "assert op_cube_neg_div3([1, 2, 3, 4]) == []\nassert op_cube_neg_div3([]) == []\nassert op_cube_neg_div3([-2, -1, 0, 1, 2]) == []\nassert op_cube_neg_div3([5, 5, 5]) == []\nassert op_cube_neg_div3([3, 1, 2]) == []\nassert op_cube_neg_div3([10]) == []\nassert op_cube_neg_div3([2, 4, 6]) == []\nassert op_cube_neg_div3([-7, 12, -7]) == []"}
{"id": "op_revstr_lower_maxlen", "entry_point": "op_revstr_lower_maxlen", "primitives": ["revstr", "lower", "maxlen"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; reverse each string, then lowercase each string, then return the length of the longest string (0 if none).", "solution": "def op_revstr_lower_maxlen(xs):\n    r = list(xs)\n    r = [s[::-1] for s in r]\n    r = [s.lower() for s in r]\n    return max((len(s) for s in r), default=0)", "tests": "assert op_revstr_lower_maxlen(['Hello', 'world']) == 5\nassert op_revstr_lower_maxlen([]) == 0\nassert op_revstr_lower_maxlen(['  a ', '', 'BC', 'bc']) == 4\nassert op_revstr_lower_maxlen(['one', 'one', 'Two']) == 3\nassert op_revstr_lower_maxlen(['x']) == 1\nassert op_revstr_lower_maxlen(['abc', 'de', '']) == 3"}
{"id": "op_cube_dec_takewhilepos", "entry_point": "op_cube_dec_takewhilepos", "primitives": ["cube", "dec", "takewhilepos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then subtract one from each, then take values while they are positive.", "solution": "def op_cube_dec_takewhilepos(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = [x - 1 for x in r]\n    r = r[:next((i for i, x in enumerate(r) if x <= 0), len(r))]\n    return r", "tests": "assert op_cube_dec_takewhilepos([1, 2, 3, 4]) == []\nassert op_cube_dec_takewhilepos([]) == []\nassert op_cube_dec_takewhilepos([-2, -1, 0, 1, 2]) == []\nassert op_cube_dec_takewhilepos([5, 5, 5]) == [124, 124, 124]\nassert op_cube_dec_takewhilepos([3, 1, 2]) == [26]\nassert op_cube_dec_takewhilepos([10]) == [999]\nassert op_cube_dec_takewhilepos([2, 4, 6]) == [7, 63, 215]\nassert op_cube_dec_takewhilepos([-7, 12, -7]) == []"}
{"id": "op_trimends_halve_neg", "entry_point": "op_trimends_halve_neg", "primitives": ["trimends", "halve", "neg"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then halve each (integer division), then keep the negative numbers.", "solution": "def op_trimends_halve_neg(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = [x // 2 for x in r]\n    r = [x for x in r if x < 0]\n    return r", "tests": "assert op_trimends_halve_neg([1, 2, 3, 4]) == []\nassert op_trimends_halve_neg([]) == []\nassert op_trimends_halve_neg([-2, -1, 0, 1, 2]) == [-1]\nassert op_trimends_halve_neg([5, 5, 5]) == []\nassert op_trimends_halve_neg([3, 1, 2]) == []\nassert op_trimends_halve_neg([10]) == []\nassert op_trimends_halve_neg([2, 4, 6]) == []\nassert op_trimends_halve_neg([-7, 12, -7]) == []"}
{"id": "op_cube_beforezero_negate", "entry_point": "op_cube_beforezero_negate", "primitives": ["cube", "beforezero", "negate"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then keep everything before the first zero, then negate each.", "solution": "def op_cube_beforezero_negate(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    r = [-x for x in r]\n    return r", "tests": "assert op_cube_beforezero_negate([1, 2, 3, 4]) == [-1, -8, -27, -64]\nassert op_cube_beforezero_negate([]) == []\nassert op_cube_beforezero_negate([-2, -1, 0, 1, 2]) == [8, 1]\nassert op_cube_beforezero_negate([5, 5, 5]) == [-125, -125, -125]\nassert op_cube_beforezero_negate([3, 1, 2]) == [-27, -1, -8]\nassert op_cube_beforezero_negate([10]) == [-1000]\nassert op_cube_beforezero_negate([2, 4, 6]) == [-8, -64, -216]\nassert op_cube_beforezero_negate([-7, 12, -7]) == [343, -1728, 343]"}
{"id": "op_sorta_negate_halve", "entry_point": "op_sorta_negate_halve", "primitives": ["sorta", "negate", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; sort ascending, then negate each, then halve each (integer division).", "solution": "def op_sorta_negate_halve(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [-x for x in r]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_sorta_negate_halve([1, 2, 3, 4]) == [-1, -1, -2, -2]\nassert op_sorta_negate_halve([]) == []\nassert op_sorta_negate_halve([-2, -1, 0, 1, 2]) == [1, 0, 0, -1, -1]\nassert op_sorta_negate_halve([5, 5, 5]) == [-3, -3, -3]\nassert op_sorta_negate_halve([3, 1, 2]) == [-1, -1, -2]\nassert op_sorta_negate_halve([10]) == [-5]\nassert op_sorta_negate_halve([2, 4, 6]) == [-1, -2, -3]\nassert op_sorta_negate_halve([-7, 12, -7]) == [3, 3, -6]"}
{"id": "op_dropwhileneg_halve_cube", "entry_point": "op_dropwhileneg_halve_cube", "primitives": ["dropwhileneg", "halve", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the leading negative values, then halve each (integer division), then cube each.", "solution": "def op_dropwhileneg_halve_cube(xs):\n    r = list(xs)\n    r = r[next((i for i, x in enumerate(r) if x >= 0), len(r)):]\n    r = [x // 2 for x in r]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_dropwhileneg_halve_cube([1, 2, 3, 4]) == [0, 1, 1, 8]\nassert op_dropwhileneg_halve_cube([]) == []\nassert op_dropwhileneg_halve_cube([-2, -1, 0, 1, 2]) == [0, 0, 1]\nassert op_dropwhileneg_halve_cube([5, 5, 5]) == [8, 8, 8]\nassert op_dropwhileneg_halve_cube([3, 1, 2]) == [1, 0, 1]\nassert op_dropwhileneg_halve_cube([10]) == [125]\nassert op_dropwhileneg_halve_cube([2, 4, 6]) == [1, 8, 27]\nassert op_dropwhileneg_halve_cube([-7, 12, -7]) == [216, -64]"}
{"id": "op_inc_oremptyzero_halve", "entry_point": "op_inc_oremptyzero_halve", "primitives": ["inc", "oremptyzero", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then if empty, use a single zero, then halve each (integer division).", "solution": "def op_inc_oremptyzero_halve(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r if r else [0]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_inc_oremptyzero_halve([1, 2, 3, 4]) == [1, 1, 2, 2]\nassert op_inc_oremptyzero_halve([]) == [0]\nassert op_inc_oremptyzero_halve([-2, -1, 0, 1, 2]) == [-1, 0, 0, 1, 1]\nassert op_inc_oremptyzero_halve([5, 5, 5]) == [3, 3, 3]\nassert op_inc_oremptyzero_halve([3, 1, 2]) == [2, 1, 1]\nassert op_inc_oremptyzero_halve([10]) == [5]\nassert op_inc_oremptyzero_halve([2, 4, 6]) == [1, 2, 3]\nassert op_inc_oremptyzero_halve([-7, 12, -7]) == [-3, 6, -3]"}
{"id": "op_sortalpha_lower_revstr", "entry_point": "op_sortalpha_lower_revstr", "primitives": ["sortalpha", "lower", "revstr"], "difficulty": 2, "split": "heldout_zeroshot", "type": "SL", "prompt": "Take a list of strings; sort alphabetically, then lowercase each string, then reverse each string.", "solution": "def op_sortalpha_lower_revstr(xs):\n    r = list(xs)\n    r = sorted(r)\n    r = [s.lower() for s in r]\n    r = [s[::-1] for s in r]\n    return r", "tests": "assert op_sortalpha_lower_revstr(['Hello', 'world']) == ['olleh', 'dlrow']\nassert op_sortalpha_lower_revstr([]) == []\nassert op_sortalpha_lower_revstr(['  a ', '', 'BC', 'bc']) == ['', ' a  ', 'cb', 'cb']\nassert op_sortalpha_lower_revstr(['one', 'one', 'Two']) == ['owt', 'eno', 'eno']\nassert op_sortalpha_lower_revstr(['x']) == ['x']\nassert op_sortalpha_lower_revstr(['abc', 'de', '']) == ['', 'cba', 'ed']"}
{"id": "op_double_gt5_halve", "entry_point": "op_double_gt5_halve", "primitives": ["double", "gt5", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; double each, then keep values greater than five, then halve each (integer division).", "solution": "def op_double_gt5_halve(xs):\n    r = list(xs)\n    r = [x * 2 for x in r]\n    r = [x for x in r if x > 5]\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_double_gt5_halve([1, 2, 3, 4]) == [3, 4]\nassert op_double_gt5_halve([]) == []\nassert op_double_gt5_halve([-2, -1, 0, 1, 2]) == []\nassert op_double_gt5_halve([5, 5, 5]) == [5, 5, 5]\nassert op_double_gt5_halve([3, 1, 2]) == [3]\nassert op_double_gt5_halve([10]) == [10]\nassert op_double_gt5_halve([2, 4, 6]) == [4, 6]\nassert op_double_gt5_halve([-7, 12, -7]) == [12]"}
{"id": "op_negate_first3_cube", "entry_point": "op_negate_first3_cube", "primitives": ["negate", "first3", "cube"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; negate each, then keep only the first three, then cube each.", "solution": "def op_negate_first3_cube(xs):\n    r = list(xs)\n    r = [-x for x in r]\n    r = r[:3]\n    r = [x ** 3 for x in r]\n    return r", "tests": "assert op_negate_first3_cube([1, 2, 3, 4]) == [-1, -8, -27]\nassert op_negate_first3_cube([]) == []\nassert op_negate_first3_cube([-2, -1, 0, 1, 2]) == [8, 1, 0]\nassert op_negate_first3_cube([5, 5, 5]) == [-125, -125, -125]\nassert op_negate_first3_cube([3, 1, 2]) == [-27, -1, -8]\nassert op_negate_first3_cube([10]) == [-1000]\nassert op_negate_first3_cube([2, 4, 6]) == [-8, -64, -216]\nassert op_negate_first3_cube([-7, 12, -7]) == [343, -1728, 343]"}
{"id": "op_inc_beforezero_range_", "entry_point": "op_inc_beforezero_range_", "primitives": ["inc", "beforezero", "range_"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; add one to each, then keep everything before the first zero, then return the range (max minus min, 0 if empty).", "solution": "def op_inc_beforezero_range_(xs):\n    r = list(xs)\n    r = [x + 1 for x in r]\n    r = r[:r.index(0)] if 0 in r else r\n    return (max(r) - min(r)) if r else 0", "tests": "assert op_inc_beforezero_range_([1, 2, 3, 4]) == 3\nassert op_inc_beforezero_range_([]) == 0\nassert op_inc_beforezero_range_([-2, -1, 0, 1, 2]) == 0\nassert op_inc_beforezero_range_([5, 5, 5]) == 0\nassert op_inc_beforezero_range_([3, 1, 2]) == 2\nassert op_inc_beforezero_range_([10]) == 0\nassert op_inc_beforezero_range_([2, 4, 6]) == 4\nassert op_inc_beforezero_range_([-7, 12, -7]) == 19"}
{"id": "op_clamp10_cube_pos", "entry_point": "op_clamp10_cube_pos", "primitives": ["clamp10", "cube", "pos"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cap each value at 10, then cube each, then keep the positive numbers.", "solution": "def op_clamp10_cube_pos(xs):\n    r = list(xs)\n    r = [min(x, 10) for x in r]\n    r = [x ** 3 for x in r]\n    r = [x for x in r if x > 0]\n    return r", "tests": "assert op_clamp10_cube_pos([1, 2, 3, 4]) == [1, 8, 27, 64]\nassert op_clamp10_cube_pos([]) == []\nassert op_clamp10_cube_pos([-2, -1, 0, 1, 2]) == [1, 8]\nassert op_clamp10_cube_pos([5, 5, 5]) == [125, 125, 125]\nassert op_clamp10_cube_pos([3, 1, 2]) == [27, 1, 8]\nassert op_clamp10_cube_pos([10]) == [1000]\nassert op_clamp10_cube_pos([2, 4, 6]) == [8, 64, 216]\nassert op_clamp10_cube_pos([-7, 12, -7]) == [1000]"}
{"id": "op_trimends_uniq_halve", "entry_point": "op_trimends_uniq_halve", "primitives": ["trimends", "uniq", "halve"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; drop the first and last elements, then drop duplicates keeping first occurrence, then halve each (integer division).", "solution": "def op_trimends_uniq_halve(xs):\n    r = list(xs)\n    r = r[1:-1]\n    r = list(dict.fromkeys(r))\n    r = [x // 2 for x in r]\n    return r", "tests": "assert op_trimends_uniq_halve([1, 2, 3, 4]) == [1, 1]\nassert op_trimends_uniq_halve([]) == []\nassert op_trimends_uniq_halve([-2, -1, 0, 1, 2]) == [-1, 0, 0]\nassert op_trimends_uniq_halve([5, 5, 5]) == [2]\nassert op_trimends_uniq_halve([3, 1, 2]) == [0]\nassert op_trimends_uniq_halve([10]) == []\nassert op_trimends_uniq_halve([2, 4, 6]) == [2]\nassert op_trimends_uniq_halve([-7, 12, -7]) == [6]"}
{"id": "op_cube_oremptyzero_last3", "entry_point": "op_cube_oremptyzero_last3", "primitives": ["cube", "oremptyzero", "last3"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; cube each, then if empty, use a single zero, then keep only the last three.", "solution": "def op_cube_oremptyzero_last3(xs):\n    r = list(xs)\n    r = [x ** 3 for x in r]\n    r = r if r else [0]\n    r = r[-3:]\n    return r", "tests": "assert op_cube_oremptyzero_last3([1, 2, 3, 4]) == [8, 27, 64]\nassert op_cube_oremptyzero_last3([]) == [0]\nassert op_cube_oremptyzero_last3([-2, -1, 0, 1, 2]) == [0, 1, 8]\nassert op_cube_oremptyzero_last3([5, 5, 5]) == [125, 125, 125]\nassert op_cube_oremptyzero_last3([3, 1, 2]) == [27, 1, 8]\nassert op_cube_oremptyzero_last3([10]) == [1000]\nassert op_cube_oremptyzero_last3([2, 4, 6]) == [8, 64, 216]\nassert op_cube_oremptyzero_last3([-7, 12, -7]) == [-343, 1728, -343]"}
{"id": "op_halve_rev_double", "entry_point": "op_halve_rev_double", "primitives": ["halve", "rev", "double"], "difficulty": 2, "split": "heldout_zeroshot", "type": "IL", "prompt": "Take a list of integers; halve each (integer division), then reverse the order, then double each.", "solution": "def op_halve_rev_double(xs):\n    r = list(xs)\n    r = [x // 2 for x in r]\n    r = list(reversed(r))\n    r = [x * 2 for x in r]\n    return r", "tests": "assert op_halve_rev_double([1, 2, 3, 4]) == [4, 2, 2, 0]\nassert op_halve_rev_double([]) == []\nassert op_halve_rev_double([-2, -1, 0, 1, 2]) == [2, 0, 0, -2, -2]\nassert op_halve_rev_double([5, 5, 5]) == [4, 4, 4]\nassert op_halve_rev_double([3, 1, 2]) == [2, 0, 2]\nassert op_halve_rev_double([10]) == [10]\nassert op_halve_rev_double([2, 4, 6]) == [6, 4, 2]\nassert op_halve_rev_double([-7, 12, -7]) == [-8, 12, -8]"}