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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows)-1: break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if y>=len(rows)-ri-1: break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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:
The table bottom boundary result violates the stipulated table clipboard paste mapping contract.

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

split: open-access


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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source[:1]):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source[::-1]):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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:
The table ragged input columns result violates the stipulated table clipboard paste mapping contract.

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

split: open-access


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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets)-1: break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if x>=len(targets)-ci-1: break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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:
The table right boundary result violates the stipulated table clipboard paste mapping contract.

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

split: open-access


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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if False: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell[0] in {p[0] for p in readonly}: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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:
The table readonly hole result violates the stipulated table clipboard paste mapping contract.

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

split: open-access


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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)+len(rejected)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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:
The table patch budget result violates the stipulated table clipboard paste mapping contract.

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

split: open-access