| import { mkdir, writeFile } from "node:fs/promises"; |
| import { dirname } from "node:path"; |
|
|
| const args = process.argv.slice(2); |
| const valueAfter = (flag, fallback) => { |
| const index = args.indexOf(flag); |
| return index === -1 ? fallback : args[index + 1]; |
| }; |
| const split = valueAfter("--split", "public"); |
| if (!["public", "hidden"].includes(split)) { |
| throw new Error("Usage: gen-tasks.mjs [--seed integer] [--split public|hidden] [--output path]"); |
| } |
| const seedArg = valueAfter("--seed", split === "public" ? "20261015" : undefined); |
| if (seedArg === undefined) { |
| throw new Error("The hidden split needs an explicit --seed chosen privately; never commit or publish the seed or the output file."); |
| } |
| const seed = Number(seedArg); |
| if (!Number.isInteger(seed)) throw new Error("--seed must be an integer."); |
|
|
| |
| |
| |
| const definitions = [ |
| ["absolute-value", "Return the absolute value.", "input < 0 ? -input : input", "input < 0 ? input : -input", [-7, 4, 2], [-19, 13], ["-input", "input", "Math.min(input, -input)", "input * -input"]], |
| ["increment", "Add one to the number.", "input + 1", "input - 1", [0, 8, -3], [41, -12], ["input + 2", "input", "input * 2 + 1", "-input + 1"]], |
| ["double", "Double the number.", "input * 2", "input + 2", [3, -5, 0], [11, -9], ["input * input", "input * -2", "input / 2", "input * 3"]], |
| ["square", "Return the number squared.", "input * input", "input + input", [4, -3, 0], [9, -7], ["input ** 3", "input * 2", "input * input + input", "input - input"]], |
| ["cap-at-ten", "Cap the number at ten.", "Math.min(input, 10)", "Math.max(input, 10)", [4, 14, 10], [-2, 31], ["Math.min(input, 11)", "Math.min(input + 1, 10)", "input < 10 ? 10 : input", "input"]], |
| ["floor-at-zero", "Replace negative numbers with zero.", "Math.max(input, 0)", "Math.min(input, 0)", [-4, 7, 0], [-20, 16], ["Math.max(input, 1)", "input > 0 ? input : 1", "Math.abs(input)", "input"]], |
| ["half", "Divide the number by two.", "input / 2", "input * 2", [8, -6, 0], [15, -11], ["input / 4", "input * 0.5 + 1", "input - 2", "input % 2"]], |
| ["celsius-to-fahrenheit", "Convert Celsius to Fahrenheit.", "input * 9 / 5 + 32", "input * 5 / 9 + 32", [0, 20, -40], [37, -10], ["input * 9 / 5 - 32", "(input - 32) * 5 / 9", "input * 9 / 5 + 30", "input + 32"]], |
| ["is-even", "Return whether the number is even.", "input % 2 === 0", "input % 2 !== 0", [2, 7, 0], [-8, 13], ["input % 2 === 1", "input % 3 === 0", "input % 2 > 0", "input % 2 < 1"]], |
| ["is-positive", "Return whether the number is positive.", "input > 0", "input >= 0", [1, 0, -2], [17, -1], ["input >= 1", "input > 1", "input !== 0", "input < 0"]], |
| ["trim", "Remove whitespace from both ends.", "input.trim()", "input.trimStart()", [" oak ", " pine", "elm "], [" ash ", "fir"], ["input.trimEnd()", "input.toUpperCase().trim()", "input.replace(' ', '')", "input.slice(1).trim()"]], |
| ["uppercase", "Convert the string to uppercase.", "input.toUpperCase()", "input.toLowerCase()", ["Maple", "oAk", ""], ["Beech", "XYz"], ["input", "input.trim().toUpperCase()", "input.toLowerCase().toUpperCase()", "input + ''"]], |
| ["first-character", "Return the first character.", "input[0]", "input[input.length - 1]", ["cat", "z", "road"], ["plane", "no"], ["input[1]", "input.slice(1, 2)", "input.at(1)", "input.charAt(input.length)"]], |
| ["last-character", "Return the last character.", "input[input.length - 1]", "input[0]", ["cat", "z", "road"], ["plane", "no"], ["input[input.length - 2]", "input.slice(-2)", "input.at(-2)", "input[input.length]"]], |
| ["string-length", "Return the string length.", "input.length", "input.length - 1", ["", "pear", "two words"], ["benchmark", "x"], ["input.length + 1", "input.trim().length", "input.split(' ').length", "input.length * 2"]], |
| ["has-prefix", "Return whether the string starts with pre.", "input.startsWith('pre')", "input.endsWith('pre')", ["prefix", "postpre", "plain"], ["prevent", "pre"], ["input.startsWith('post')", "input.includes('pre')", "input.indexOf('pre') > 0", "input.slice(0, 4) === 'pre'"]], |
| ["has-suffix", "Return whether the string ends with ing.", "input.endsWith('ing')", "input.startsWith('ing')", ["testing", "ingot", "test"], ["coding", "bring"], ["input.endsWith('ingot')", "input.includes('ing')", "input.endsWith('in')", "input.slice(-2) === 'ng'"]], |
| ["replace-dashes", "Replace every dash with a space.", "input.replaceAll('-', ' ')", "input.replace('-', ' ')", ["a-b-c", "plain", "x-y"], ["one-two-three-four", "-"], ["input.replaceAll('-', '')", "input.split('-').join('')", "input.replaceAll(' ', '-')", "input.replaceAll('-', '_')"]], |
| ["array-length", "Return the array length.", "input.length", "input.length - 1", [[1, 2, 3], [], [8]], [[4, 5], [1, 2, 3, 4, 5]], ["input.length + 1", "input.filter((x) => x !== undefined).length", "input.length * 2", "input.slice(1).length"]], |
| ["first-item", "Return the first array item.", "input[0]", "input[input.length - 1]", [[2, 4, 6], [9], ["a", "b"]], [[7, 8], ["x", "y", "z"]], ["input[1]", "input.slice(1)[0]", "input.at(1)", "input.slice(0)"]], |
| ["last-item", "Return the last array item.", "input[input.length - 1]", "input[0]", [[2, 4, 6], [9], ["a", "b"]], [[7, 8], ["x", "y", "z"]], ["input[input.length - 2]", "input.at(-2)", "input.slice(-2)", "input[input.length]"]], |
| ["sum", "Return the sum of the array.", "input.reduce((sum, value) => sum + value, 0)", "input.reduce((sum, value) => sum - value, 0)", [[2, 3, 4], [], [-2, 5]], [[10, -3, 8], [1]], ["input.reduce((sum, value) => sum + value, 1)", "input.reduce((sum, value) => sum * value, 0)", "input[0]", "input.reduce((sum, value) => sum + value)"]], |
| ["maximum", "Return the largest array item.", "Math.max(...input)", "Math.min(...input)", [[2, 9, 4], [-3, -8], [7]], [[12, 1, 6], [-20, -2]], ["input[0]", "Math.max(...input) - 1", "input[input.length - 1]", "input.sort((a, b) => a - b)[0]"]], |
| ["reverse", "Return a reversed copy of the array.", "[...input].reverse()", "input", [[1, 2, 3], ["a", "b"], [8]], [[4, 3, 2, 1], ["x", "y"]], ["input.reverse()", "input.slice(1)", "input.toReversed().toReversed()", "input.filter((x) => true)"]], |
| ["full-name", "Join first and last name with a space.", "input.first + ' ' + input.last", "input.last + ' ' + input.first", [{first:"Ada",last:"Lovelace"},{first:"Linus",last:"Torvalds"}], [{first:"Grace",last:"Hopper"}], ["input.first", "input.first + input.last", "input.first + '-' + input.last", "input.last + ' ' + input.last"]], |
| ["line-total", "Multiply quantity by unit price.", "input.quantity * input.price", "input.quantity + input.price", [{quantity:3,price:4},{quantity:0,price:9},{quantity:2,price:7.5}], [{quantity:8,price:2.25}], ["input.price", "input.quantity", "input.quantity * input.price + 1", "input.quantity / input.price"]], |
| ["coordinate-sum", "Add the x and y coordinates.", "input.x + input.y", "input.x - input.y", [{x:3,y:4},{x:-2,y:5},{x:0,y:0}], [{x:11,y:-6}], ["input.x", "input.y", "input.x * input.y", "input.x + input.y + 1"]], |
| ["display-label", "Join code and name with a colon.", "input.code + ': ' + input.name", "input.name + ': ' + input.code", [{code:"A1",name:"Alpha"},{code:"B2",name:"Beta"}], [{code:"Z9",name:"Last"}], ["input.code", "input.name", "input.code + input.name", "input.name + ' - ' + input.code"]], |
| ["is-adult", "Return whether age is at least eighteen.", "input.age >= 18", "input.age > 18", [{age:18},{age:17},{age:42}], [{age:19},{age:0}], ["input.age > 17", "input.age >= 21", "input.age < 18", "input.age !== undefined"]], |
| ["active-status", "Return the active boolean.", "input.active", "!input.active", [{active:true},{active:false}], [{active:true,name:"sample"}], ["input.active === false", "input.name", "input.active ? false : true", "input.active === true"]], |
| ]; |
|
|
| function evaluate(expression, input) { |
| return Function("input", `"use strict"; return (${expression});`)(structuredClone(input)); |
| } |
| function source(expression) { return `export function solve(input) {\n return ${expression};\n}\n`; } |
| function tests(cases, expression) { |
| const lines = ['import { solve } from "../src/index.js";', ""]; |
| const seen = new Set(); |
| for (const input of cases) { |
| const line = `assert.deepEqual(solve(${JSON.stringify(input)}), ${JSON.stringify(evaluate(expression, input))});`; |
| if (seen.has(line)) continue; |
| seen.add(line); |
| lines.push(line); |
| } |
| return `${lines.join("\n")}\n`; |
| } |
| function random(seedValue) { |
| let state = seedValue >>> 0; |
| return () => { state += 0x6d2b79f5; let value = state; value = Math.imul(value ^ value >>> 15, value | 1); value ^= value + Math.imul(value ^ value >>> 7, value | 61); return ((value ^ value >>> 14) >>> 0) / 2 ** 32; }; |
| } |
|
|
| const pick = (rng, list) => list[Math.floor(rng() * list.length)]; |
| const intBetween = (rng, low, high) => low + Math.floor(rng() * (high - low + 1)); |
| const LETTERS = "abcdefghijklmnopqrstuvwxyz"; |
| const word = (rng, length = intBetween(rng, 3, 8)) => Array.from({ length }, () => LETTERS[Math.floor(rng() * LETTERS.length)]).join(""); |
| const words = (rng, count) => Array.from({ length: count }, () => word(rng)); |
| const ints = (rng, count, low = -20, high = 20) => Array.from({ length: count }, () => intBetween(rng, low, high)); |
| const GIVEN = ["Ada", "Grace", "Alan", "Edsger", "Barbara", "Donald", "Radia", "Margaret", "Dennis", "Katherine"]; |
| const FAMILY = ["Byron", "Hopper", "Turing", "Dijkstra", "Liskov", "Knuth", "Perlman", "Hamilton", "Ritchie", "Johnson"]; |
| const titled = (rng, count, keys) => Array.from({ length: count }, () => { |
| const entry = {}; |
| for (const [key, make] of Object.entries(keys)) entry[key] = make(rng); |
| return entry; |
| }); |
|
|
| |
| |
| |
| const variants = { |
| "absolute-value": (rng) => ["Return the negative absolute value.", "input > 0 ? -input : input", "input", [...ints(rng, 3, -30, 30), intBetween(rng, 1, 30)], ["-input", "input < 0 ? -input : input", "input * -input"]], |
| "increment": (rng) => { const k = intBetween(rng, 2, 9); return [`Add ${k} to the number.`, `input + ${k}`, `input - ${k}`, ints(rng, 4), [`input + ${k + 1}`, `input * ${k}`, "input"]]; }, |
| "double": (rng) => { const k = pick(rng, [3, 4, 5]); return [`Multiply the number by ${k}.`, `input * ${k}`, `input + ${k}`, [...ints(rng, 3), intBetween(rng, 1, 20)], [`input * ${k + 1}`, `input + ${k}`, "input ** 2"]]; }, |
| "square": (rng) => { const e = pick(rng, [3, 4]); return [`Raise the number to the power of ${e}.`, `input ** ${e}`, `input * ${e}`, [...ints(rng, 3, -9, 9), intBetween(rng, 2, 9)], [`input * ${e}`, `input ** ${e + 1}`, `input * input + ${e}`]]; }, |
| "cap-at-ten": (rng) => { const k = pick(rng, [4, 6, 8, 12, 15, 20, 25, 30, 40, 50]); return [`Cap the number at ${k}.`, `Math.min(input, ${k})`, `Math.max(input, ${k})`, [...ints(rng, 3, -10, 60), k + 5], [`Math.min(input, ${k + 1})`, `Math.min(input - 1, ${k})`, "input"]]; }, |
| "floor-at-zero": (rng) => { const k = intBetween(rng, 2, 15); return [`Replace numbers below -${k} with -${k}.`, `Math.max(input, -${k})`, `Math.min(input, -${k})`, [...ints(rng, 3, -40, 40), -k - intBetween(rng, 1, 20)], [`Math.max(input, -${k + 1})`, `Math.min(input, -${k})`, "input"]]; }, |
| "half": (rng) => { const k = pick(rng, [3, 4, 5]); return [`Divide the number by ${k}.`, `input / ${k}`, `input * ${k}`, [...ints(rng, 3, -30, 30), intBetween(rng, 1, 30)], [`input / ${k + 1}`, `input * ${k}`, `input - ${k}`]]; }, |
| "celsius-to-fahrenheit": (rng) => ["Convert Fahrenheit to Celsius.", "(input - 32) * 5 / 9", "(input - 32) * 9 / 5", [...ints(rng, 3, -20, 110), pick(rng, [0, 50, 100])], ["(input - 32) * 9 / 5", "input * 5 / 9", "(input - 30) * 5 / 9"]], |
| "is-even": (rng) => { const k = pick(rng, [3, 4, 5, 7]); return [`Return whether the number is divisible by ${k}.`, `input % ${k} === 0`, `input % ${k} !== 0`, [...ints(rng, 3, -30, 30), k === 4 ? 2 : k], [`input % ${k} === 1`, `input % ${k + 1} === 0`, `input % ${k} > 0`]]; }, |
| "is-positive": (rng) => { const k = pick(rng, [3, 5, 7, 12, 25, 40]); return [`Return whether the number is at least ${k}.`, `input >= ${k}`, `input > ${k}`, [...ints(rng, 3, -10, 50), intBetween(rng, 1, k - 1), k], [`input >= ${k + 1}`, `input < ${k}`, `input !== ${k}`]]; }, |
| "trim": (rng) => ["Remove whitespace from the end only.", "input.trimEnd()", "input.trimStart()", words(rng, 4).map((item) => ` ${item} `), ["input.trim()", "input.slice(0, -1)", "input.replaceAll(' ', '')"]], |
| "uppercase": (rng) => ["Convert the string to lowercase.", "input.toLowerCase()", "input.toUpperCase()", words(rng, 4).map((item) => `${item[0].toUpperCase()}${item.slice(1)}`), ["input", "input.trim().toLowerCase()", "input.toUpperCase().toLowerCase()"]], |
| "first-character": (rng) => ["Return the second character.", "input[1]", "input[0]", [...words(rng, 3), `${pick(rng, ["b", "c", "d"])}a${word(rng, 2)}`], ["input[0]", "input[2]", "input.slice(1, 3)"]], |
| "last-character": (rng) => ["Return the middle character.", "input[Math.floor(input.length / 2)]", "input[0]", [...words(rng, 3), `${pick(rng, ["b", "c", "d"])}${word(rng, 1)}${pick(rng, ["a", "e", "i"])}${word(rng, 1)}${pick(rng, ["x", "y", "z"])}`], ["input[0]", "input[input.length - 1]", "input[Math.ceil(input.length / 2)]"]], |
| "string-length": (rng) => { const k = intBetween(rng, 2, 9); return [`Return the string length plus ${k}.`, `input.length + ${k}`, `input.length`, words(rng, 4), ["input.length", `input.length + ${k + 1}`, `input.trim().length + ${k}`]]; }, |
| "has-prefix": (rng) => { const p = pick(rng, ["sub", "inter", "post", "anti", "trans", "mid"]); return [`Return whether the string starts with '${p}'.`, `input.startsWith('${p}')`, `input.endsWith('${p}')`, [...words(rng, 1).map((w) => `${p}${w}`), ...words(rng, 2), `${p}zzz`], [`input.endsWith('${p}')`, `input.includes('${p}')`, `input.startsWith('${p[0]}')`]]; }, |
| "has-suffix": (rng) => { const s = pick(rng, ["tion", "ment", "ness", "able", "less", "ful"]); return [`Return whether the string ends with '${s}'.`, `input.endsWith('${s}')`, `input.startsWith('${s}')`, [...words(rng, 1).map((w) => `${w}${s}`), ...words(rng, 2), `zzz${s}`], [`input.includes('${s}')`, `input.endsWith('${s}ment')`, `input.slice(-${s.length + 1}) === '${s}'`]]; }, |
| "replace-dashes": (rng) => ["Replace every underscore with a space.", "input.replaceAll('_', ' ')", "input.replace('_', ' ')", [...words(rng, 2).map((w) => `${w}_${word(rng, 3)}_${word(rng, 3)}`), ...words(rng, 2)], ["input.replaceAll('_', '')", "input.split('_').join('-')", "input.replaceAll(' ', '_')"]], |
| "array-length": (rng) => { const k = intBetween(rng, 1, 4); return [`Return whether the array has more than ${k} items.`, `input.length > ${k}`, `input.length >= ${k}`, [ints(rng, 2), ints(rng, k), ints(rng, 5), ints(rng, 7)], [`input.length >= ${k + 1}`, `input.length < ${k}`, `input.length - ${k}`]]; }, |
| "first-item": (rng) => ["Return the second array item.", "input[1]", "input[0]", [ints(rng, 3), words(rng, 3), ints(rng, 3, 0, 9), [intBetween(rng, 1, 9), 0]], ["input[0]", "input[2]", "input.slice(1)"]], |
| "last-item": (rng) => ["Return the next-to-last array item.", "input[input.length - 2]", "input[input.length - 1]", [ints(rng, 4), words(rng, 3), [intBetween(rng, 1, 9), intBetween(rng, 1, 9), 0]], ["input[input.length - 3]", "input[0]", "input.slice(-2)"]], |
| "sum": (rng) => ["Return the product of the array.", "input.reduce((product, value) => product * value, 1)", "input.reduce((product, value) => product + value, 0)", [ints(rng, 3, 1, 5), ints(rng, 4, 1, 4), ints(rng, 2, -3, 3), [3, 3]], ["input.reduce((sum, value) => sum + value, 0)", "input.reduce((product, value) => product * value, 0)", "input[0]"]], |
| "maximum": (rng) => ["Return the smallest array item.", "Math.min(...input)", "Math.max(...input)", [ints(rng, 4), ints(rng, 3, -9, -1), ints(rng, 5), [intBetween(rng, 1, 5), intBetween(rng, 6, 9)]], ["Math.max(...input)", "input[0]", "input[input.length - 1]"]], |
| "reverse": (rng) => ["Return a sorted copy of the array, smallest first.", "input.slice().sort((a, b) => a - b)", "input.slice().sort((a, b) => b - a)", [ints(rng, 4), ints(rng, 5, 0, 20), ints(rng, 3, -9, 9), [intBetween(rng, 1, 5), intBetween(rng, 6, 9)]], ["input.slice().reverse()", "input", "input.slice().sort()"]], |
| "full-name": (rng) => ["Join given and family names with a space.", "input.given + ' ' + input.family", "input.family + ' ' + input.given", titled(rng, 4, { given: (r) => pick(r, GIVEN), family: (r) => pick(r, FAMILY) }), ["input.given", "input.family", "input.given + input.family"]], |
| "line-total": (rng) => ["Multiply units by unit cost.", "input.units * input.cost", "input.units + input.cost", [...titled(rng, 3, { units: (r) => intBetween(r, 0, 9), cost: (r) => Math.round(r() * 2000) / 100 }), { units: intBetween(rng, 3, 9), cost: intBetween(rng, 3, 9) }], ["input.units", "input.cost", "input.units * input.cost + 1"]], |
| "coordinate-sum": (rng) => ["Add the a and b fields.", "input.a + input.b", "input.a - input.b", titled(rng, 4, { a: (r) => intBetween(r, -9, 9), b: (r) => intBetween(r, 1, 9) }), ["input.a", "input.b", "input.a * input.b"]], |
| "display-label": (rng) => ["Join key and title with ' - '.", "input.key + ' - ' + input.title", "input.title + ' - ' + input.key", titled(rng, 4, { key: (r) => `${word(r, 1).toUpperCase()}${intBetween(r, 0, 9)}`, title: (r) => word(r) }), ["input.key", "input.title", "input.key + input.title"]], |
| "is-adult": (rng) => { const k = intBetween(rng, 19, 30); return [`Return whether years is at least ${k}.`, `input.years >= ${k}`, `input.years > ${k}`, [...titled(rng, 3, { years: (r) => intBetween(r, 10, 40) }), { years: k }], [`input.years >= ${k + 1}`, `input.years < ${k}`, "input.years !== undefined"]]; }, |
| "active-status": (rng) => ["Return the enabled flag.", "input.enabled", "!input.enabled", titled(rng, 4, { enabled: (r) => r() < 0.5 }), ["input.enabled === false", "input.off", "input.enabled ? 1 : 0"]], |
| }; |
|
|
| const rng = random(seed); |
| const ordered = definitions.map((definition) => ({ definition, order: rng() })).sort((a, b) => a.order - b.order); |
| const outputsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right); |
| const safeEvaluate = (expression, input) => { try { return evaluate(expression, input); } catch { return Symbol.for("error"); } }; |
|
|
| const tasks = ordered.map(({ definition }, index) => { |
| const [slug, publicRequirement, publicCorrect] = definition; |
| let requirement = publicRequirement; |
| let correct = publicCorrect; |
| let bug = definition[3]; |
| let cases = definition[4]; |
| let extras = definition[6]; |
| if (split === "hidden") { |
| const makeVariant = variants[slug]; |
| if (!makeVariant) throw new Error(`No hidden variant for family ${slug}.`); |
| [requirement, correct, bug, cases, extras] = makeVariant(rng); |
| if (!cases.some((input) => !outputsEqual(safeEvaluate(bug, input), safeEvaluate(correct, input)))) { |
| throw new Error(`Seed ${seed} produced a hidden ${slug} task whose bug passes every case; pick another seed.`); |
| } |
| if (!cases.some((input) => !outputsEqual(safeEvaluate(publicCorrect, input), safeEvaluate(correct, input)))) { |
| throw new Error(`Seed ${seed} produced a hidden ${slug} task the public reference solves; pick another seed.`); |
| } |
| } |
| const originalTests = tests(cases, correct); |
| |
| |
| |
| const mutants = []; |
| const seenMutants = new Set(); |
| const pushMutant = (expression) => { |
| const wrapped = source(expression); |
| if (!seenMutants.has(wrapped)) { seenMutants.add(wrapped); mutants.push(wrapped); } |
| }; |
| pushMutant(bug); |
| for (const extra of extras) pushMutant(extra); |
| pushMutant("null"); |
| const killed = (expression) => cases.some((input) => !outputsEqual(safeEvaluate(expression, input), safeEvaluate(correct, input))); |
| for (const fallback of ["input", "0", "true", "false", "undefined", "''", "[]"]) { |
| if (mutants.length >= 5) break; |
| if (killed(fallback)) pushMutant(fallback); |
| } |
| if (mutants.length < 5) throw new Error(`Seed ${seed} produced a ${slug} task with only ${mutants.length} distinct mutants; pick another seed or extend the family's extras.`); |
| return { |
| id: `${split === "hidden" ? "hidden-" : ""}${String(index + 1).padStart(2, "0")}-${slug}`, |
| kind: "episode", |
| prompt: `A tiny JavaScript repository has one bug and failing tests. ${requirement} Fix src/index.js without removing, skipping, or loosening tests. Use read_file, write_file, and run_tests.`, |
| metadata: { |
| seed, split, files: { "src/index.js": source(bug), "test/index.test.js": originalTests }, reference: source(correct), originalTests, |
| mutants, weakTests: tests(cases, bug), |
| }, |
| }; |
| }); |
|
|
| const output = valueAfter("--output", split === "public" ? "data/tasks.jsonl" : "hidden/tasks-hidden.jsonl"); |
| await mkdir(dirname(output), { recursive: true }); |
| await writeFile(output, `${tasks.map((task) => JSON.stringify(task)).join("\n")}\n`); |
| console.log(`generated ${tasks.length} ${split} tasks at ${output} with seed ${seed}`); |
|
|
