adaptation/data/selfgen_code_431.jsonl

{"idx": 0, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 1, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 2, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 3, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 4, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 5, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of text processing. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 6, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 7, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 8, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 9, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 10, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 11, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dates and times. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 12, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 13, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 14, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 15, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 16, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 17, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of file paths. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 18, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 19, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 20, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 21, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 22, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 23, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple statistics. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 24, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 25, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 26, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 27, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 28, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 29, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sorting and ranking. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 30, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 31, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 32, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 33, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 34, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 35, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dictionaries and lookups. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 36, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 37, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 38, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 39, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 40, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 41, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of number formatting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 42, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 43, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 44, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 45, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 46, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 47, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sequences and windows. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 48, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 49, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 50, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 51, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 52, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 53, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of parsing configuration. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 54, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 55, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 56, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 57, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 58, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 59, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of deduplication. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 60, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 61, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 62, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 63, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 64, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 65, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of unit conversion. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 66, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 67, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 68, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 69, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 70, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 71, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of search and filtering. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 72, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 73, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 74, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 75, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 76, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 77, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple geometry. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 78, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 79, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 80, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 81, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 82, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 83, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of tokenising. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 84, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 85, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 86, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 87, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 88, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 89, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of grouping and counting. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 90, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 91, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 92, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 93, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 94, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 95, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of validation of user input. It must handle an empty input gracefully. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 96, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 97, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 98, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 99, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 100, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 101, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of text processing. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 102, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 103, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 104, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 105, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 106, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 107, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dates and times. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 108, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 109, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 110, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 111, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 112, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 113, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of file paths. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 114, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 115, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 116, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 117, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 118, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 119, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple statistics. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 120, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 121, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 122, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 123, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 124, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 125, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sorting and ranking. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 126, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 127, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 128, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 129, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 130, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 131, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dictionaries and lookups. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 132, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 133, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 134, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 135, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 136, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 137, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of number formatting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 138, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 139, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 140, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 141, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 142, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 143, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sequences and windows. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 144, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 145, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 146, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 147, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 148, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 149, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of parsing configuration. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 150, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 151, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 152, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 153, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 154, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 155, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of deduplication. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 156, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 157, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 158, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 159, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 160, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 161, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of unit conversion. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 162, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 163, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 164, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 165, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 166, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 167, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of search and filtering. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 168, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 169, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 170, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 171, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 172, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 173, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple geometry. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 174, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 175, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 176, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 177, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 178, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 179, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of tokenising. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 180, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 181, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 182, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 183, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 184, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 185, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of grouping and counting. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 186, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 187, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 188, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 189, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 190, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 191, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of validation of user input. It must return a tuple of two values. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 192, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 193, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 194, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 195, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 196, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 197, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of text processing. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 198, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 199, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 200, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 201, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 202, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 203, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dates and times. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 204, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 205, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 206, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 207, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 208, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 209, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of file paths. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 210, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 211, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 212, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 213, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 214, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 215, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple statistics. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 216, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 217, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 218, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 219, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 220, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 221, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sorting and ranking. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 222, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 223, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 224, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 225, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 226, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 227, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dictionaries and lookups. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 228, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 229, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 230, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 231, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 232, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 233, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of number formatting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 234, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 235, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 236, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 237, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 238, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 239, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sequences and windows. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 240, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 241, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 242, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 243, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 244, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 245, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of parsing configuration. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 246, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 247, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 248, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 249, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 250, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 251, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of deduplication. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 252, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 253, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 254, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 255, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 256, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 257, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of unit conversion. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 258, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 259, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 260, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 261, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 262, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 263, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of search and filtering. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 264, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 265, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 266, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 267, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 268, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 269, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple geometry. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 270, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 271, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 272, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 273, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 274, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 275, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of tokenising. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 276, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 277, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 278, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 279, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 280, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 281, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of grouping and counting. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 282, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 283, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 284, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 285, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 286, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 287, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of validation of user input. It must not use any imports. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 288, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 289, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 290, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 291, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 292, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 293, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of text processing. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 294, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 295, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 296, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 297, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 298, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 299, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dates and times. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 300, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 301, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 302, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 303, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 304, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 305, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of file paths. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 306, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 307, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 308, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 309, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 310, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 311, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple statistics. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 312, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 313, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 314, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 315, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 316, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 317, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sorting and ranking. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 318, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 319, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 320, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 321, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 322, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 323, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dictionaries and lookups. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 324, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 325, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 326, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 327, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 328, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 329, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of number formatting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 330, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 331, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 332, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 333, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 334, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 335, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sequences and windows. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 336, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 337, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 338, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 339, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 340, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 341, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of parsing configuration. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 342, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 343, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 344, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 345, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 346, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 347, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of deduplication. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 348, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 349, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 350, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 351, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 352, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 353, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of unit conversion. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 354, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 355, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 356, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 357, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 358, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 359, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of search and filtering. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 360, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 361, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 362, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 363, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 364, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 365, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple geometry. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 366, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 367, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 368, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 369, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 370, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 371, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of tokenising. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 372, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 373, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 374, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 375, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 376, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 377, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of grouping and counting. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 378, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 379, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 380, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 381, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 382, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 383, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of validation of user input. It should be case-insensitive where that makes sense. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 384, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 385, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 386, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 387, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 388, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 389, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of text processing. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 390, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 391, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 392, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 393, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 394, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 395, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dates and times. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 396, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 397, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 398, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 399, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 400, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 401, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of file paths. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 402, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 403, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 404, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 405, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 406, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 407, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of simple statistics. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 408, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 409, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 410, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 411, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 412, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 413, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of sorting and ranking. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 414, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 415, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 416, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 417, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 418, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 419, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of dictionaries and lookups. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 420, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 421, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 422, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 423, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 424, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 425, "lane": "selfgen_code", "text": "Write a Python function that aggregates records into a summary, in the domain of number formatting. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 426, "lane": "selfgen_code", "text": "Write a self-contained Python function with a docstring describing the task, in the domain of sequences and windows. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 427, "lane": "selfgen_code", "text": "Write a small Python utility that processes a list and returns a result, in the domain of sequences and windows. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 428, "lane": "selfgen_code", "text": "Write a Python function that parses or reformats a string, in the domain of sequences and windows. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 429, "lane": "selfgen_code", "text": "Write a Python function implementing a simple algorithm with edge cases, in the domain of sequences and windows. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}
{"idx": 430, "lane": "selfgen_code", "text": "Write a Python function that validates its input and raises on bad values, in the domain of sequences and windows. It must preserve the original order of the input. Output ONLY the task description a programmer would be given, as a short instruction. Do not write the code."}