broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if i==0 or p!=pts[i-1]]
        if len(clean)<3: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if i+1==len(pts) or p!=pts[i+1]]
        if len(clean)<3: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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:
Duplicate removal skips the wrap-around comparison, leaving the first vertex repeated at the end of the ring.

Each command is a polygon vertex list with exact coordinates. It is clipped in continuous raster coordinates against x>=0, x<=size, y>=0 and y<=size in that order with Sutherland-Hodgman: each stage walks edges from the previous vertex to the current vertex, emits the boundary intersection when entering before the inside vertex, emits the intersection when leaving, and chains its output into the next stage. Boundary points are inside. Cyclically repeated consecutive vertices are then removed; fewer than three remaining vertices yields an empty polygon. Vertices are returned as exact rational strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if p!=pts[i-1]]
        if not clean: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if p!=pts[i-1]]
        if len(clean)<2: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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:
Clipped polygons that collapse to a point or a segment are emitted as polygons.

Each command is a polygon vertex list with exact coordinates. It is clipped in continuous raster coordinates against x>=0, x<=size, y>=0 and y<=size in that order with Sutherland-Hodgman: each stage walks edges from the previous vertex to the current vertex, emits the boundary intersection when entering before the inside vertex, emits the intersection when leaving, and chains its output into the next stage. Boundary points are inside. Cyclically repeated consecutive vertices are then removed; fewer than three remaining vertices yields an empty polygon. Vertices are returned as exact rational strings.

split: open-access


prompt:
Trimming a negative source origin shortens the copy but leaves the destination origin where the first discarded source column would have landed.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
The source width limit ignores the source origin, so copies starting inside the image read past its right edge.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
The destination scissor right edge is not intersected with the target, allowing writes beyond the target width.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
The half-open scissor right edge is treated as inclusive, writing one extra destination column.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
A copy empty in one dimension is still reported as a blit with nonpositive width or height.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
Left trimming only happens for negative destination origins, ignoring a scissor whose left edge is inside the target.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


prompt:
The source height limit uses the source width, over- or under-trimming non-square images.

Each command is [sw,sh,sx,sy,w,h,dx,dy,clip]: a source image sw by sh, a requested source rectangle origin and size, a destination origin, and a half-open destination scissor [left,top,right,bottom) first intersected with the size by size target. Negative source origins trim width/height and shift the destination by the same amount; the source rectangle is limited to the image; destination pixels left/top of the scissor trim size and advance the source origin; right/bottom trims use half-open bounds. The result is [sx,sy,dx,dy,w,h] or None when either dimension is empty.

split: open-access


source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    out=[]
    for poly,clip in commands:
        l,t,r,b=max(clip[0],0),max(clip[1],0),min(clip[2],size),min(clip[3],size)
        pts=[(Fraction(x),Fraction(y)) for x,y in poly]
        spans=[]
        for y in range(t,b):
            yc=y+Fraction(1,2)
            xs=[]
            for i in range(len(pts)):
                (ax,ay),(bx,by)=pts[i-1],pts[i]
                if ay>by: ax,ay,bx,by=bx,by,ax,ay
                if ay<yc<by:
                    xs.append(ax+(bx-ax)*(yc-ay)/(by-ay))
            xs.sort()
            for j in range(0,len(xs)-1,2):
                start=math.ceil(xs[j]-Fraction(1,2))
                end=math.ceil(xs[j+1]-Fraction(1,2))
                start,end=max(start,l),min(end,r)
                if start<end: spans.append([y,start,end])
        out.append(spans)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 6, 6]]], 6), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 6, 6]]], 6), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 6, 6]]], 6), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [6, 0], [6, 6], [0, 6]], [2, 1, 4, 3]]], 6), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 6, 6]]], 6), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [8, 0], [8, 2], [-2, 2]], [0, 0, 6, 6]]], 6), [[[0, 0, 6], [1, 0, 6]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 6, 6]]], 6), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 6, 6]]], 6), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 6, 6]]], 6), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 6, 6]]], 6), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6], [1, 6]], [0, 0, 7, 7]]], 7), [[[1, 1, 6], [2, 1, 6], [3, 1, 6], [4, 1, 6], [5, 1, 6]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 7, 7]]], 7), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 7, 7]]], 7), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 7, 7]]], 7), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [7, 0], [7, 7], [0, 7]], [2, 1, 4, 3]]], 7), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 7, 7]]], 7), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [9, 0], [9, 2], [-2, 2]], [0, 0, 7, 7]]], 7), [[[0, 0, 7], [1, 0, 7]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 7, 7]]], 7), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 7, 7]]], 7), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 7, 7]]], 7), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 7, 7]]], 7), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7], [1, 7]], [0, 0, 8, 8]]], 8), [[[1, 1, 7], [2, 1, 7], [3, 1, 7], [4, 1, 7], [5, 1, 7], [6, 1, 7]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 8, 8]]], 8), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 8, 8]]], 8), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 8, 8]]], 8), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [8, 0], [8, 8], [0, 8]], [2, 1, 4, 3]]], 8), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 8, 8]]], 8), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [10, 0], [10, 2], [-2, 2]], [0, 0, 8, 8]]], 8), [[[0, 0, 8], [1, 0, 8]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 8, 8]]], 8), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 8, 8]]], 8), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 8, 8]]], 8), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 8, 8]]], 8), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8], [1, 8]], [0, 0, 9, 9]]], 9), [[[1, 1, 8], [2, 1, 8], [3, 1, 8], [4, 1, 8], [5, 1, 8], [6, 1, 8], [7, 1, 8]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 9, 9]]], 9), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 9, 9]]], 9), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 9, 9]]], 9), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [9, 0], [9, 9], [0, 9]], [2, 1, 4, 3]]], 9), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 9, 9]]], 9), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [11, 0], [11, 2], [-2, 2]], [0, 0, 9, 9]]], 9), [[[0, 0, 9], [1, 0, 9]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 9, 9]]], 9), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 9, 9]]], 9), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 9, 9]]], 9), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 9, 9]]], 9), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [9, 1], [9, 9], [1, 9]], [0, 0, 10, 10]]], 10), [[[1, 1, 9], [2, 1, 9], [3, 1, 9], [4, 1, 9], [5, 1, 9], [6, 1, 9], [7, 1, 9], [8, 1, 9]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 10, 10]]], 10), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 10, 10]]], 10), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 10, 10]]], 10), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [10, 0], [10, 10], [0, 10]], [2, 1, 4, 3]]], 10), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 10, 10]]], 10), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [12, 0], [12, 2], [-2, 2]], [0, 0, 10, 10]]], 10), [[[0, 0, 10], [1, 0, 10]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 10, 10]]], 10), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 10, 10]]], 10), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 10, 10]]], 10), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 10, 10]]], 10), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
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:
Closed edge ranges count a pass-through vertex on the sample row twice, flipping even-odd parity for the rest of the row.

Each command is [polygon,scissor]. Rows y in the scissor rows [top,bottom) intersected with [0,size) are sampled at y+1/2. Each polygon edge is oriented bottom to top and contributes a crossing when top<=yc<bottom (half-open in y), interpolated exactly. Crossings are sorted and paired even-odd. A pair covers pixels whose centers x+1/2 satisfy xa<=x+1/2<xb, i.e. [ceil(xa-1/2),ceil(xb-1/2)), then clipped to the scissor columns [left,right) intersected with [0,size). Non-empty spans are returned as [row,start,end].

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    out=[]
    for poly,clip in commands:
        l,t,r,b=max(clip[0],0),max(clip[1],0),min(clip[2],size),min(clip[3],size)
        pts=[(Fraction(x),Fraction(y)) for x,y in poly]
        spans=[]
        for y in range(t,b):
            yc=Fraction(y)
            xs=[]
            for i in range(len(pts)):
                (ax,ay),(bx,by)=pts[i-1],pts[i]
                if ay>by: ax,ay,bx,by=bx,by,ax,ay
                if ay<=yc<by:
                    xs.append(ax+(bx-ax)*(yc-ay)/(by-ay))
            xs.sort()
            for j in range(0,len(xs)-1,2):
                start=math.ceil(xs[j]-Fraction(1,2))
                end=math.ceil(xs[j+1]-Fraction(1,2))
                start,end=max(start,l),min(end,r)
                if start<end: spans.append([y,start,end])
        out.append(spans)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 6, 6]]], 6), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 6, 6]]], 6), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 6, 6]]], 6), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [6, 0], [6, 6], [0, 6]], [2, 1, 4, 3]]], 6), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 6, 6]]], 6), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [8, 0], [8, 2], [-2, 2]], [0, 0, 6, 6]]], 6), [[[0, 0, 6], [1, 0, 6]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 6, 6]]], 6), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 6, 6]]], 6), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 6, 6]]], 6), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 6, 6]]], 6), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6], [1, 6]], [0, 0, 7, 7]]], 7), [[[1, 1, 6], [2, 1, 6], [3, 1, 6], [4, 1, 6], [5, 1, 6]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 7, 7]]], 7), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 7, 7]]], 7), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 7, 7]]], 7), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [7, 0], [7, 7], [0, 7]], [2, 1, 4, 3]]], 7), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 7, 7]]], 7), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [9, 0], [9, 2], [-2, 2]], [0, 0, 7, 7]]], 7), [[[0, 0, 7], [1, 0, 7]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 7, 7]]], 7), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 7, 7]]], 7), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 7, 7]]], 7), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 7, 7]]], 7), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7], [1, 7]], [0, 0, 8, 8]]], 8), [[[1, 1, 7], [2, 1, 7], [3, 1, 7], [4, 1, 7], [5, 1, 7], [6, 1, 7]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 8, 8]]], 8), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 8, 8]]], 8), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 8, 8]]], 8), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [8, 0], [8, 8], [0, 8]], [2, 1, 4, 3]]], 8), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 8, 8]]], 8), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [10, 0], [10, 2], [-2, 2]], [0, 0, 8, 8]]], 8), [[[0, 0, 8], [1, 0, 8]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 8, 8]]], 8), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 8, 8]]], 8), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 8, 8]]], 8), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 8, 8]]], 8), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8], [1, 8]], [0, 0, 9, 9]]], 9), [[[1, 1, 8], [2, 1, 8], [3, 1, 8], [4, 1, 8], [5, 1, 8], [6, 1, 8], [7, 1, 8]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 9, 9]]], 9), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 9, 9]]], 9), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 9, 9]]], 9), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [9, 0], [9, 9], [0, 9]], [2, 1, 4, 3]]], 9), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 9, 9]]], 9), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [11, 0], [11, 2], [-2, 2]], [0, 0, 9, 9]]], 9), [[[0, 0, 9], [1, 0, 9]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 9, 9]]], 9), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 9, 9]]], 9), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 9, 9]]], 9), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 9, 9]]], 9), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [9, 1], [9, 9], [1, 9]], [0, 0, 10, 10]]], 10), [[[1, 1, 9], [2, 1, 9], [3, 1, 9], [4, 1, 9], [5, 1, 9], [6, 1, 9], [7, 1, 9], [8, 1, 9]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 10, 10]]], 10), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 10, 10]]], 10), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 10, 10]]], 10), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [10, 0], [10, 10], [0, 10]], [2, 1, 4, 3]]], 10), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 10, 10]]], 10), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [12, 0], [12, 2], [-2, 2]], [0, 0, 10, 10]]], 10), [[[0, 0, 10], [1, 0, 10]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 10, 10]]], 10), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 10, 10]]], 10), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 10, 10]]], 10), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 10, 10]]], 10), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
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
import math
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    out=[]
    for poly,clip in commands:
        l,t,r,b=max(clip[0],0),max(clip[1],0),min(clip[2],size),min(clip[3],size)
        pts=[(Fraction(x),Fraction(y)) for x,y in poly]
        spans=[]
        for y in range(t,b):
            yc=Fraction(y+1)
            xs=[]
            for i in range(len(pts)):
                (ax,ay),(bx,by)=pts[i-1],pts[i]
                if ay>by: ax,ay,bx,by=bx,by,ax,ay
                if ay<=yc<by:
                    xs.append(ax+(bx-ax)*(yc-ay)/(by-ay))
            xs.sort()
            for j in range(0,len(xs)-1,2):
                start=math.ceil(xs[j]-Fraction(1,2))
                end=math.ceil(xs[j+1]-Fraction(1,2))
                start,end=max(start,l),min(end,r)
                if start<end: spans.append([y,start,end])
        out.append(spans)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 6, 6]]], 6), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 6, 6]]], 6), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 6, 6]]], 6), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [6, 0], [6, 6], [0, 6]], [2, 1, 4, 3]]], 6), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 6, 6]]], 6), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [8, 0], [8, 2], [-2, 2]], [0, 0, 6, 6]]], 6), [[[0, 0, 6], [1, 0, 6]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 6, 6]]], 6), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 6, 6]]], 6), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 6, 6]]], 6), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 6, 6]]], 6), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6], [1, 6]], [0, 0, 7, 7]]], 7), [[[1, 1, 6], [2, 1, 6], [3, 1, 6], [4, 1, 6], [5, 1, 6]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 7, 7]]], 7), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 7, 7]]], 7), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 7, 7]]], 7), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [7, 0], [7, 7], [0, 7]], [2, 1, 4, 3]]], 7), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 7, 7]]], 7), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [9, 0], [9, 2], [-2, 2]], [0, 0, 7, 7]]], 7), [[[0, 0, 7], [1, 0, 7]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 7, 7]]], 7), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 7, 7]]], 7), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 7, 7]]], 7), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 7, 7]]], 7), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7], [1, 7]], [0, 0, 8, 8]]], 8), [[[1, 1, 7], [2, 1, 7], [3, 1, 7], [4, 1, 7], [5, 1, 7], [6, 1, 7]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 8, 8]]], 8), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 8, 8]]], 8), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 8, 8]]], 8), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [8, 0], [8, 8], [0, 8]], [2, 1, 4, 3]]], 8), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 8, 8]]], 8), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [10, 0], [10, 2], [-2, 2]], [0, 0, 8, 8]]], 8), [[[0, 0, 8], [1, 0, 8]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 8, 8]]], 8), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 8, 8]]], 8), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 8, 8]]], 8), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 8, 8]]], 8), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8], [1, 8]], [0, 0, 9, 9]]], 9), [[[1, 1, 8], [2, 1, 8], [3, 1, 8], [4, 1, 8], [5, 1, 8], [6, 1, 8], [7, 1, 8]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 9, 9]]], 9), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 9, 9]]], 9), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 9, 9]]], 9), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [9, 0], [9, 9], [0, 9]], [2, 1, 4, 3]]], 9), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 9, 9]]], 9), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [11, 0], [11, 2], [-2, 2]], [0, 0, 9, 9]]], 9), [[[0, 0, 9], [1, 0, 9]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 9, 9]]], 9), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 9, 9]]], 9), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 9, 9]]], 9), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 9, 9]]], 9), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [9, 1], [9, 9], [1, 9]], [0, 0, 10, 10]]], 10), [[[1, 1, 9], [2, 1, 9], [3, 1, 9], [4, 1, 9], [5, 1, 9], [6, 1, 9], [7, 1, 9], [8, 1, 9]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 10, 10]]], 10), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 10, 10]]], 10), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 10, 10]]], 10), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [10, 0], [10, 10], [0, 10]], [2, 1, 4, 3]]], 10), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 10, 10]]], 10), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [12, 0], [12, 2], [-2, 2]], [0, 0, 10, 10]]], 10), [[[0, 0, 10], [1, 0, 10]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 10, 10]]], 10), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 10, 10]]], 10), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 10, 10]]], 10), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 10, 10]]], 10), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
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:
Rows are sampled at their top edge instead of their pixel-center line.

Each command is [polygon,scissor]. Rows y in the scissor rows [top,bottom) intersected with [0,size) are sampled at y+1/2. Each polygon edge is oriented bottom to top and contributes a crossing when top<=yc<bottom (half-open in y), interpolated exactly. Crossings are sorted and paired even-odd. A pair covers pixels whose centers x+1/2 satisfy xa<=x+1/2<xb, i.e. [ceil(xa-1/2),ceil(xb-1/2)), then clipped to the scissor columns [left,right) intersected with [0,size). Non-empty spans are returned as [row,start,end].

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
import math
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    out=[]
    for poly,clip in commands:
        l,t,r,b=max(clip[0],0),max(clip[1],0),min(clip[2],size),min(clip[3],size)
        pts=[(Fraction(x),Fraction(y)) for x,y in poly]
        spans=[]
        for y in range(t,b):
            yc=y+Fraction(1,2)
            xs=[]
            for i in range(len(pts)):
                (ax,ay),(bx,by)=pts[i-1],pts[i]
                if ay>by: ax,ay,bx,by=bx,by,ax,ay
                if ay<=yc<by:
                    xs.append(ax+(bx-ax)*(yc-ay)/(by-ay))
            xs.sort()
            for j in range(0,len(xs)-1,2):
                start=math.floor(xs[j])
                end=math.ceil(xs[j+1]-Fraction(1,2))
                start,end=max(start,l),min(end,r)
                if start<end: spans.append([y,start,end])
        out.append(spans)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 6, 6]]], 6), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 6, 6]]], 6), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 6, 6]]], 6), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [6, 0], [6, 6], [0, 6]], [2, 1, 4, 3]]], 6), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 6, 6]]], 6), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [8, 0], [8, 2], [-2, 2]], [0, 0, 6, 6]]], 6), [[[0, 0, 6], [1, 0, 6]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 6, 6]]], 6), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 6, 6]]], 6), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 6, 6]]], 6), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 6, 6]]], 6), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6], [1, 6]], [0, 0, 7, 7]]], 7), [[[1, 1, 6], [2, 1, 6], [3, 1, 6], [4, 1, 6], [5, 1, 6]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 7, 7]]], 7), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 7, 7]]], 7), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 7, 7]]], 7), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [7, 0], [7, 7], [0, 7]], [2, 1, 4, 3]]], 7), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 7, 7]]], 7), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [9, 0], [9, 2], [-2, 2]], [0, 0, 7, 7]]], 7), [[[0, 0, 7], [1, 0, 7]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 7, 7]]], 7), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 7, 7]]], 7), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 7, 7]]], 7), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 7, 7]]], 7), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7], [1, 7]], [0, 0, 8, 8]]], 8), [[[1, 1, 7], [2, 1, 7], [3, 1, 7], [4, 1, 7], [5, 1, 7], [6, 1, 7]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 8, 8]]], 8), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 8, 8]]], 8), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 8, 8]]], 8), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [8, 0], [8, 8], [0, 8]], [2, 1, 4, 3]]], 8), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 8, 8]]], 8), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [10, 0], [10, 2], [-2, 2]], [0, 0, 8, 8]]], 8), [[[0, 0, 8], [1, 0, 8]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 8, 8]]], 8), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 8, 8]]], 8), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 8, 8]]], 8), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 8, 8]]], 8), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8], [1, 8]], [0, 0, 9, 9]]], 9), [[[1, 1, 8], [2, 1, 8], [3, 1, 8], [4, 1, 8], [5, 1, 8], [6, 1, 8], [7, 1, 8]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 9, 9]]], 9), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 9, 9]]], 9), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 9, 9]]], 9), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [9, 0], [9, 9], [0, 9]], [2, 1, 4, 3]]], 9), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 9, 9]]], 9), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [11, 0], [11, 2], [-2, 2]], [0, 0, 9, 9]]], 9), [[[0, 0, 9], [1, 0, 9]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 9, 9]]], 9), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 9, 9]]], 9), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 9, 9]]], 9), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 9, 9]]], 9), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [9, 1], [9, 9], [1, 9]], [0, 0, 10, 10]]], 10), [[[1, 1, 9], [2, 1, 9], [3, 1, 9], [4, 1, 9], [5, 1, 9], [6, 1, 9], [7, 1, 9], [8, 1, 9]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 10, 10]]], 10), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 10, 10]]], 10), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 10, 10]]], 10), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [10, 0], [10, 10], [0, 10]], [2, 1, 4, 3]]], 10), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 10, 10]]], 10), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [12, 0], [12, 2], [-2, 2]], [0, 0, 10, 10]]], 10), [[[0, 0, 10], [1, 0, 10]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 10, 10]]], 10), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 10, 10]]], 10), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 10, 10]]], 10), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 10, 10]]], 10), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
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
import math
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    out=[]
    for poly,clip in commands:
        l,t,r,b=max(clip[0],0),max(clip[1],0),min(clip[2],size),min(clip[3],size)
        pts=[(Fraction(x),Fraction(y)) for x,y in poly]
        spans=[]
        for y in range(t,b):
            yc=y+Fraction(1,2)
            xs=[]
            for i in range(len(pts)):
                (ax,ay),(bx,by)=pts[i-1],pts[i]
                if ay>by: ax,ay,bx,by=bx,by,ax,ay
                if ay<=yc<by:
                    xs.append(ax+(bx-ax)*(yc-ay)/(by-ay))
            xs.sort()
            for j in range(0,len(xs)-1,2):
                start=round(xs[j])
                end=math.ceil(xs[j+1]-Fraction(1,2))
                start,end=max(start,l),min(end,r)
                if start<end: spans.append([y,start,end])
        out.append(spans)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 6, 6]]], 6), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 6, 6]]], 6), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 6, 6]]], 6), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [6, 0], [6, 6], [0, 6]], [2, 1, 4, 3]]], 6), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 6, 6]]], 6), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [8, 0], [8, 2], [-2, 2]], [0, 0, 6, 6]]], 6), [[[0, 0, 6], [1, 0, 6]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 6, 6]]], 6), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 6, 6]]], 6), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 6, 6]]], 6), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 6, 6]]], 6), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 6, 6]]], 6), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6], [1, 6]], [0, 0, 7, 7]]], 7), [[[1, 1, 6], [2, 1, 6], [3, 1, 6], [4, 1, 6], [5, 1, 6]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 7, 7]]], 7), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 7, 7]]], 7), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 7, 7]]], 7), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [7, 0], [7, 7], [0, 7]], [2, 1, 4, 3]]], 7), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 7, 7]]], 7), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [9, 0], [9, 2], [-2, 2]], [0, 0, 7, 7]]], 7), [[[0, 0, 7], [1, 0, 7]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 7, 7]]], 7), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 7, 7]]], 7), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 7, 7]]], 7), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 7, 7]]], 7), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 7, 7]]], 7), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7], [1, 7]], [0, 0, 8, 8]]], 8), [[[1, 1, 7], [2, 1, 7], [3, 1, 7], [4, 1, 7], [5, 1, 7], [6, 1, 7]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 8, 8]]], 8), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 8, 8]]], 8), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 8, 8]]], 8), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [8, 0], [8, 8], [0, 8]], [2, 1, 4, 3]]], 8), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 8, 8]]], 8), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [10, 0], [10, 2], [-2, 2]], [0, 0, 8, 8]]], 8), [[[0, 0, 8], [1, 0, 8]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 8, 8]]], 8), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 8, 8]]], 8), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 8, 8]]], 8), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 8, 8]]], 8), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 8, 8]]], 8), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8], [1, 8]], [0, 0, 9, 9]]], 9), [[[1, 1, 8], [2, 1, 8], [3, 1, 8], [4, 1, 8], [5, 1, 8], [6, 1, 8], [7, 1, 8]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 9, 9]]], 9), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 9, 9]]], 9), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 9, 9]]], 9), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [9, 0], [9, 9], [0, 9]], [2, 1, 4, 3]]], 9), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 9, 9]]], 9), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [11, 0], [11, 2], [-2, 2]], [0, 0, 9, 9]]], 9), [[[0, 0, 9], [1, 0, 9]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 9, 9]]], 9), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 9, 9]]], 9), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 9, 9]]], 9), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 9, 9]]], 9), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 9, 9]]], 9), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [9, 1], [9, 9], [1, 9]], [0, 0, 10, 10]]], 10), [[[1, 1, 9], [2, 1, 9], [3, 1, 9], [4, 1, 9], [5, 1, 9], [6, 1, 9], [7, 1, 9], [8, 1, 9]]])
    check('explicit case 1', solve([[[[1, 0], [3, '5/2'], [5, 0], [5, 5], [1, 5]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [1, 4, 5], [2, 1, 5], [3, 1, 5], [4, 1, 5]]])
    check('explicit case 2', solve([[[[0, '1/2'], [4, '5/2'], [0, '9/2']], [0, 0, 10, 10]]], 10), [[[1, 0, 2], [2, 0, 4], [3, 0, 2]]])
    check('explicit case 3', solve([[[['1/2', 0], ['7/2', 0], ['7/2', 3], ['1/2', 3]], [0, 0, 10, 10]]], 10), [[[0, 0, 3], [1, 0, 3], [2, 0, 3]]])
    check('explicit case 4', solve([[[['3/2', 0], ['9/2', 0], ['9/2', 2], ['3/2', 2]], [0, 0, 10, 10]]], 10), [[[0, 1, 4], [1, 1, 4]]])
    check('explicit case 5', solve([[[[0, 0], [10, 0], [10, 10], [0, 10]], [2, 1, 4, 3]]], 10), [[[1, 2, 4], [2, 2, 4]]])
    check('explicit case 6', solve([[[[0, 0], [1, 4], [2, 0], [3, 4], [4, 0], [4, 5], [0, 5]], [0, 0, 10, 10]]], 10), [[[2, 0, 1], [2, 1, 3], [2, 3, 4], [3, 0, 1], [3, 1, 3], [3, 3, 4], [4, 0, 4]]])
    check('explicit case 7', solve([[[[-2, 0], [12, 0], [12, 2], [-2, 2]], [0, 0, 10, 10]]], 10), [[[0, 0, 10], [1, 0, 10]]])
    check('explicit case 8', solve([[[[0, 0], [2, 0], [2, 2], [0, 2]], [3, 0, 10, 10]]], 10), [[]])
    check('explicit case 9', solve([[[[1, 0], [5, 4], [1, 4]], [0, 0, 10, 10]]], 10), [[[1, 1, 2], [2, 1, 3], [3, 1, 4]]])
    check('explicit case 10', solve([[[['1/4', 0], ['5/2', 0], ['5/2', 2], ['1/4', 2]], [1, 0, 10, 10]]], 10), [[[0, 1, 2], [1, 1, 2]]])
    check('explicit case 11', solve([[[[4, 1], [4, 4], [1, 4], [1, 1]], [0, 0, 10, 10]]], 10), [[[1, 1, 4], [2, 1, 4], [3, 1, 4]]])
    check('explicit case 12', solve([[[[0, 0], [5, 0], [5, 4], [3, '3/2'], [1, 4], [0, 4]], [0, 0, 10, 10]]], 10), [[[0, 0, 5], [1, 0, 3], [1, 3, 5], [2, 0, 2], [2, 4, 5], [3, 0, 1]]])
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:
Span starts include the pixel containing the left crossing even when its center lies left of the edge.

Each command is [polygon,scissor]. Rows y in the scissor rows [top,bottom) intersected with [0,size) are sampled at y+1/2. Each polygon edge is oriented bottom to top and contributes a crossing when top<=yc<bottom (half-open in y), interpolated exactly. Crossings are sorted and paired even-odd. A pair covers pixels whose centers x+1/2 satisfy xa<=x+1/2<xb, i.e. [ceil(xa-1/2),ceil(xb-1/2)), then clipped to the scissor columns [left,right) intersected with [0,size). Non-empty spans are returned as [row,start,end].

split: open-access