broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=set(cmd[2]) & full
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': active=None
        elif op=='draw': out.append(sorted(masks.get(active,set())))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=set(cmd[2]) & full
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': masks.pop(active,None); active=None
        elif op=='draw': out.append(sorted(masks.get(active,set())))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Reset keeps mask definitions so a later bind resurrects old clipping state.

Named clip masks are immutable snapshots clipped to target extent. Bind selects a name, edits replace the named mask, deletion of the active mask makes drawing empty. Renaming preserves active binding; clone is independent; reset clears registry and active binding.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=set(cmd[2]) & full
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': masks={}; active=None
        elif op=='draw': out.append(sorted(masks.get(active,full)))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=set(cmd[2]) & full
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': masks={}; active=None
        elif op=='draw': out.append(sorted(masks.get(active,full if active is not None else set())))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Binding an undefined mask exposes the full surface instead of empty coverage.

Named clip masks are immutable snapshots clipped to target extent. Bind selects a name, edits replace the named mask, deletion of the active mask makes drawing empty. Renaming preserves active binding; clone is independent; reset clears registry and active binding.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=masks.get(cmd[1],set()) | (set(cmd[2]) & full)
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': masks={}; active=None
        elif op=='draw': out.append(sorted(masks.get(active,set())))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    masks={}
    active=None
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='define': masks[cmd[1]]=set(cmd[2]) & full if not cmd[2] else masks.get(cmd[1],set()) | (set(cmd[2]) & full)
        elif op=='bind': active=cmd[1]
        elif op=='delete': masks.pop(cmd[1],None)
        elif op=='clone': masks[cmd[2]]=set(masks.get(cmd[1],set()))
        elif op=='subtract' and cmd[1] in masks: masks[cmd[1]]-=set(cmd[2])
        elif op=='rename' and cmd[1] in masks:
            masks[cmd[2]]=masks.pop(cmd[1])
            if active==cmd[1]: active=cmd[2]
        elif op=='reset': masks={}; active=None
        elif op=='draw': out.append(sorted(masks.get(active,set())))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 4), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 4), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 4), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 4), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 4), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 4), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 4), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 4), [[0, 1, 2, 3]])
if N == 2:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 5), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 5), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 5), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 5), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 5), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 5), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 5), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 5), [[0, 1, 2, 3, 4]])
if N == 3:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 6), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 6), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 6), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 6), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 6), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 6), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 6), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 6), [[0, 1, 2, 3, 4, 5]])
if N == 4:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 7), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 7), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 7), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 7), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 7), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 7), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 7), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 7), [[0, 1, 2, 3, 4, 5, 6]])
if N == 5:
    check('explicit sequence 0', solve([['define', 'a', [0, 99, -1]], ['bind', 'a'], ['draw']], 8), [[0]])
    check('explicit sequence 1', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['draw'], ['bind', 'b'], ['draw']], 8), [[0], [1]])
    check('explicit sequence 2', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['delete', 'b'], ['draw']], 8), [[0]])
    check('explicit sequence 3', solve([['define', 'a', [0, 1]], ['clone', 'a', 'b'], ['subtract', 'a', [0]], ['bind', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0, 1], [1]])
    check('explicit sequence 4', solve([['define', 'a', [0]], ['bind', 'a'], ['rename', 'a', 'b'], ['draw'], ['bind', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 5', solve([['define', 'a', [0]], ['reset'], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 7', solve([['define', 'a', [0]], ['define', 'a', [2]], ['bind', 'a'], ['draw']], 8), [[2]])
    check('explicit sequence 8', solve([['define', 'e', []], ['bind', 'e'], ['draw']], 8), [[]])
    check('explicit sequence 9', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['rename', 'b', 'c'], ['draw']], 8), [[0]])
    check('explicit sequence 10', solve([['define', 'a', [0]], ['define', 'b', [1]], ['bind', 'a'], ['reset'], ['bind', 'b'], ['draw']], 8), [[]])
    check('explicit sequence 11', solve([['define', 'a', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], ['bind', 'a'], ['draw']], 8), [[0, 1, 2, 3, 4, 5, 6, 7]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Redefining a mask retains samples from its previous version.

Named clip masks are immutable snapshots clipped to target extent. Bind selects a name, edits replace the named mask, deletion of the active mask makes drawing empty. Renaming preserves active binding; clone is independent; reset clears registry and active binding.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=revs.get(cmd[1],0)
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            cache.pop(cmd[1],None)
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(defs.get(active,set())))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=1
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            cache.pop(cmd[1],None)
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(defs.get(active,set())))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Updating coverage does not change its revision so cached old coverage is reused.

Cache entries store copied coverage and source revisions. Draw recomputes after mask edits. Disable returns full coverage without overwriting cached mask. Rebinding to another name cannot reuse the old name; clearing definitions removes stale entries. Missing definitions clip empty.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=revs.get(cmd[1],0)+1
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            cache.pop(cmd[1],None)
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(next(iter(defs.values()),set())))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=revs.get(cmd[1],0)+1
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            cache.pop(cmd[1],None)
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(defs.get(active,full)))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Cache population reads the first defined mask instead of the active mask.

Cache entries store copied coverage and source revisions. Draw recomputes after mask edits. Disable returns full coverage without overwriting cached mask. Rebinding to another name cannot reuse the old name; clearing definitions removes stale entries. Missing definitions clip empty.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=revs.get(cmd[1],0)+1
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            None
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(defs.get(active,set())))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(commands, size):
    full=set(range(size))
    defs={}
    revs={}
    cache={}
    active=None
    enabled=True
    out=[]
    for cmd in commands:
        op=cmd[0]
        if op=='set':
            defs[cmd[1]]=set(cmd[2]) & full
            revs[cmd[1]]=revs.get(cmd[1],0)+1
        elif op=='bind': active=cmd[1]
        elif op=='drop':
            defs.pop(cmd[1],None)
            cache.pop(cmd[1],None) if not defs else None
        elif op=='invalidate': cache.pop(cmd[1],None)
        elif op=='clear': defs.clear(); cache.clear()
        elif op=='disable': enabled=False
        elif op=='enable': enabled=True
        elif op=='draw':
            revision=revs.get(active,0)
            if active not in cache or cache[active][0]!=revision:
                cache[active]=(revision,set(defs.get(active,set())))
            out.append(sorted(cache[active][1] if enabled else full))
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 4), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 4), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 4), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 4), [[0], [0, 1, 2, 3], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 4), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 4), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 4), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 4), [[0], []])
if N == 2:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 5), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 5), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 5), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 5), [[0], [0, 1, 2, 3, 4], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 5), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 5), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 5), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 5), [[0], []])
if N == 3:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 6), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 6), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 6), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 6), [[0], [0, 1, 2, 3, 4, 5], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 6), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 6), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 6), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 6), [[0], []])
if N == 4:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 7), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 7), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 7), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 7), [[0], [0, 1, 2, 3, 4, 5, 6], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 7), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 7), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 7), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 7), [[0], []])
if N == 5:
    check('explicit sequence 0', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['set', 'a', [1]], ['draw']], 8), [[0], [1]])
    check('explicit sequence 1', solve([['set', 'a', [0]], ['set', 'b', [2]], ['bind', 'b'], ['draw']], 8), [[2]])
    check('explicit sequence 2', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
    check('explicit sequence 3', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['clear'], ['draw']], 8), [[0], []])
    check('explicit sequence 4', solve([['set', 'a', [0]], ['bind', 'a'], ['draw'], ['disable'], ['draw'], ['enable'], ['draw']], 8), [[0], [0, 1, 2, 3, 4, 5, 6, 7], [0]])
    check('explicit sequence 5', solve([['bind', 'missing'], ['draw']], 8), [[]])
    check('explicit sequence 6', solve([['set', 'a', [0, 99]], ['bind', 'a'], ['draw'], ['invalidate', 'a'], ['draw']], 8), [[0], [0]])
    check('explicit sequence 7', solve([['set', 'a', []], ['bind', 'a'], ['draw']], 8), [[]])
    check('explicit sequence 8', solve([['set', 'a', [0]], ['set', 'b', [1]], ['bind', 'a'], ['draw'], ['drop', 'a'], ['draw']], 8), [[0], []])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

prompt:
Deleting a definition leaves cached samples visible under the deleted name.

Cache entries store copied coverage and source revisions. Draw recomputes after mask edits. Disable returns full coverage without overwriting cached mask. Rebinding to another name cannot reuse the old name; clearing definitions removes stale entries. Missing definitions clip empty.

split: open-access