FAILURE MAP
← Case archive

FA-83906 / Sports scoring and tiebreakers / Open access

Fifth set played to 25 points · case 01

A deciding set is not closed at 15-13 and continues to 25.

Verified by executionVariant 1 · 9 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The short-set check compares the zero-based set index with 5 instead of 4.

VERIFIED REPAIR

Use the 15-point target when the zero-based set index is 4.

Unsuccessful approach: Switching to 15 points whenever a team has two sets shortens the fourth set too.

Case contract

Best-of-five volleyball with rally scoring. rallies is a string of rally winners (A/B). Sets 1-4 are played to 25 and set 5 to 15, always win by two with no cap. The rally winner serves next; when the receiving team wins a rally (side-out) that team rotates once (rotation counter modulo 6). At the start of each set both rotation counters reset to 0 and the first server is first_serve in odd-numbered sets and the other team in even-numbered sets. Return [completed and current set scores as [a, b], match winner or None, rotation counters].

Why this case matters

Scoresheet apps track rotations to flag out-of-rotation faults and must reset them each set.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if set_index == 5 else 25
        if max(a, b) >= target and abs(a - b) >= 2:
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABAAAAABBBABBAAAAABBBAAABBBABB', 'A'),
   [[[18, 15]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 2', ('AAABBAAAABBAAABABBAAAAA', 'A'), [[[16, 7]], None, {'A': 4, 'B': 4}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAABAAAAAAAAABABAAAAAAABABABAABBAAABBABABAAAAAAAAAAABBAAABAAAABABABBBBAAAAAABBBBAAAAAAAABBBABAAAAABBAAAABBABABBAABBBAAA',
    'A'),
   [[[25, 5], [25, 10], [25, 16]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BAABAAAABAABAAABBBAAABBAAAAAAAAAABAABAAAABABAAABBABBBA', 'B'),
   [[[25, 10], [11, 8]], None, {'A': 5, 'B': 5}]),
  ('variant scenario 2',
   ('AABAAAABABAAAAAAABAAABABBBABBBBABBBAABBAAABBBBBAAAAABABBABABBAAAABABB', 'B'),
   [[[25, 17], [13, 14]], None, {'A': 0, 'B': 1}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AABAAABAAAABAAAABAAAAABBAAABABABABABABAAAABAABBBBABAABBAABAABBBAAAAAAAAABBAAABABBABBABABAAAAAAAAAAB',
    'A'),
   [[[25, 10], [25, 16], [15, 8]], None, {'A': 5, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BABAAABABAABAAAAABAAAAABABABABBABABBBABABBAAABBBAABBAABAABABAAAABAAAABABBAABAAAABAABAAAAABAABABBAAAAAAABBBBBBAAAAAABBBAAABBAAAABBBBABBBBBBABBBAAABAAABBBAB',
    'A'),
   [[[25, 18], [25, 14], [25, 14]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('BAAAABAAAAAAAAABAABAAAABBAAABAAAAAAAAABBBAAAABAAABABBAABABABAABAAAAAAAAABABBBABBBAABAAAAAAABBABBABABBAABAAA',
    'A'),
   [[[25, 7], [25, 11], [23, 16]], None, {'A': 3, 'B': 3}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('BAAABABBBBBAAAABABAABAAAAAABAAABBBBAAAAABABABABAAAABAABAABAABBAABAAAAAAAAAAAABBBAABAAAAAABAAABAAAAABBAABAAABBBBABABBABABAAABBABAABBBAAAABBBAABBAAABAABABBBAAABBBABAAAABBAAAABBBBBABA',
    'A'),
   [[[25, 15], [25, 10], [25, 14]], 'A', {'A': 2, 'B': 2}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABABAAAAAAAABBAABAABAABBAAAABABAAABAAAABBABABBBBAABABABABABBABBAABBBBABBAABA', 'A'),
   [[[25, 11], [18, 22]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 2',
   ('AABBAABBABAAAAAABABBBABBBBBBBAAAAABAAAAABABABBAABAABBAAAAAAABABAAABBBBBABAAAAAAAAAABAABAABAAAAAAABBAABABBAABABABBBBAAABABAAAAAAABABBBBBBBAAAAAAAABBBBAAAAABAAAABBBBAAAAABABAAAABABBBBB',
    'B'),
   [[[25, 19], [25, 13], [25, 16]], 'A', {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAABAAAAAAAAAAAAAAABBAAABAAABABABAAAABABBBAABAAAAAAABBAAABABAABBABAABAAAABBAAABAABABAAAAAAAAABAABBAAAAAAABAABAAABAABBABABABABAAABABAABBAAABBABABAAAAAAAABAAAAAAAAABAABABABAAAABAAABAABABAAAAAAAABAAABBBABAABBA',
    'A'),
   [[[25, 4], [25, 15], [25, 9]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1', ('AAAAAAAAABABAABBBBAAAA', 'A'), [[[16, 6]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('AAAABAABAAABABBAAAAAAAABAABAABAAABAABAABBABAAABBABBAAAABABBAAABBABABAAABBAAAAABAABABAB', 'A'),
   [[[25, 8], [25, 18], [6, 4]], None, {'A': 3, 'B': 4}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), expected)
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)
Boundary fixtureActualExpectedOutcome
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[26, 24]], None, {'A': 0, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Passed
control straight-sets match[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Passed
regression: deciding set target[[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], None, {'A': 0, 'B': 0}][[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]Failed
variant scenario 1[[[18, 15]], None, {'A': 0, 'B': 1}][[[18, 15]], None, {'A': 0, 'B': 1}]Passed
variant scenario 2[[[16, 7]], None, {'A': 4, 'B': 4}][[[16, 7]], None, {'A': 4, 'B': 4}]Passed

SHA-256 / 8ebfd7688e2653c572f6f13b8568243fd39f928eea9abede4ce553733b2b9635

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if won['A'] == 2 or won['B'] == 2 else 25
        if max(a, b) >= target and abs(a - b) >= 2:
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABAAAAABBBABBAAAAABBBAAABBBABB', 'A'),
   [[[18, 15]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 2', ('AAABBAAAABBAAABABBAAAAA', 'A'), [[[16, 7]], None, {'A': 4, 'B': 4}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAABAAAAAAAAABABAAAAAAABABABAABBAAABBABABAAAAAAAAAAABBAAABAAAABABABBBBAAAAAABBBBAAAAAAAABBBABAAAAABBAAAABBABABBAABBBAAA',
    'A'),
   [[[25, 5], [25, 10], [25, 16]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BAABAAAABAABAAABBBAAABBAAAAAAAAAABAABAAAABABAAABBABBBA', 'B'),
   [[[25, 10], [11, 8]], None, {'A': 5, 'B': 5}]),
  ('variant scenario 2',
   ('AABAAAABABAAAAAAABAAABABBBABBBBABBBAABBAAABBBBBAAAAABABBABABBAAAABABB', 'B'),
   [[[25, 17], [13, 14]], None, {'A': 0, 'B': 1}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AABAAABAAAABAAAABAAAAABBAAABABABABABABAAAABAABBBBABAABBAABAABBBAAAAAAAAABBAAABABBABBABABAAAAAAAAAAB',
    'A'),
   [[[25, 10], [25, 16], [15, 8]], None, {'A': 5, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BABAAABABAABAAAAABAAAAABABABABBABABBBABABBAAABBBAABBAABAABABAAAABAAAABABBAABAAAABAABAAAAABAABABBAAAAAAABBBBBBAAAAAABBBAAABBAAAABBBBABBBBBBABBBAAABAAABBBAB',
    'A'),
   [[[25, 18], [25, 14], [25, 14]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('BAAAABAAAAAAAAABAABAAAABBAAABAAAAAAAAABBBAAAABAAABABBAABABABAABAAAAAAAAABABBBABBBAABAAAAAAABBABBABABBAABAAA',
    'A'),
   [[[25, 7], [25, 11], [23, 16]], None, {'A': 3, 'B': 3}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('BAAABABBBBBAAAABABAABAAAAAABAAABBBBAAAAABABABABAAAABAABAABAABBAABAAAAAAAAAAAABBBAABAAAAAABAAABAAAAABBAABAAABBBBABABBABABAAABBABAABBBAAAABBBAABBAAABAABABBBAAABBBABAAAABBAAAABBBBBABA',
    'A'),
   [[[25, 15], [25, 10], [25, 14]], 'A', {'A': 2, 'B': 2}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABABAAAAAAAABBAABAABAABBAAAABABAAABAAAABBABABBBBAABABABABABBABBAABBBBABBAABA', 'A'),
   [[[25, 11], [18, 22]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 2',
   ('AABBAABBABAAAAAABABBBABBBBBBBAAAAABAAAAABABABBAABAABBAAAAAAABABAAABBBBBABAAAAAAAAAABAABAABAAAAAAABBAABABBAABABABBBBAAABABAAAAAAABABBBBBBBAAAAAAAABBBBAAAAABAAAABBBBAAAAABABAAAABABBBBB',
    'B'),
   [[[25, 19], [25, 13], [25, 16]], 'A', {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAABAAAAAAAAAAAAAAABBAAABAAABABABAAAABABBBAABAAAAAAABBAAABABAABBABAABAAAABBAAABAABABAAAAAAAAABAABBAAAAAAABAABAAABAABBABABABABAAABABAABBAAABBABABAAAAAAAABAAAAAAAAABAABABABAAAABAAABAABABAAAAAAAABAAABBBABAABBA',
    'A'),
   [[[25, 4], [25, 15], [25, 9]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1', ('AAAAAAAAABABAABBBBAAAA', 'A'), [[[16, 6]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('AAAABAABAAABABBAAAAAAAABAABAABAAABAABAABBABAAABBABBAAAABABBAAABBABABAAABBAAAAABAABABAB', 'A'),
   [[[25, 8], [25, 18], [6, 4]], None, {'A': 3, 'B': 4}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), expected)
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)
Boundary fixtureActualExpectedOutcome
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[26, 24]], None, {'A': 0, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Passed
control straight-sets match[[[25, 0], [25, 0], [15, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Failed
regression: deciding set target[[[25, 0], [0, 25], [25, 0], [0, 15], [15, 10]], 'A', {'A': 1, 'B': 1}][[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]Failed
variant scenario 1[[[18, 15]], None, {'A': 0, 'B': 1}][[[18, 15]], None, {'A': 0, 'B': 1}]Passed
variant scenario 2[[[16, 7]], None, {'A': 4, 'B': 4}][[[16, 7]], None, {'A': 4, 'B': 4}]Passed

SHA-256 / 686d9f5c9dbe3abf1db2e04c24ad44eb91eda044cdbd643807806937a10ada09

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(rallies, first_serve):
    won = {'A': 0, 'B': 0}
    sets = []
    a = b = 0
    set_index = 0
    server = first_serve
    rot = {'A': 0, 'B': 0}
    for r in rallies:
        if r == 'A':
            a += 1
        else:
            b += 1
        if r != server:
            rot[r] = (rot[r] + 1) % 6
            server = r
        target = 15 if set_index == 4 else 25
        if max(a, b) >= target and abs(a - b) >= 2:
            w = 'A' if a > b else 'B'
            won[w] += 1
            sets.append([a, b])
            if won[w] == 3:
                return [sets, w, rot]
            a = b = 0
            set_index += 1
            rot = {'A': 0, 'B': 0}
            server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
    return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
    try:
        return solve(*args)
    except Exception as exc:
        return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABAABAAAAABBBABBAAAAABBBAAABBBABB', 'A'),
   [[[18, 15]], None, {'A': 0, 'B': 1}]),
  ('variant scenario 2', ('AAABBAAAABBAAABABBAAAAA', 'A'), [[[16, 7]], None, {'A': 4, 'B': 4}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAABAAAAAAAAABABAAAAAAABABABAABBAAABBABABAAAAAAAAAAABBAAABAAAABABABBBBAAAAAABBBBAAAAAAAABBBABAAAAABBAAAABBABABBAABBBAAA',
    'A'),
   [[[25, 5], [25, 10], [25, 16]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BAABAAAABAABAAABBBAAABBAAAAAAAAAABAABAAAABABAAABBABBBA', 'B'),
   [[[25, 10], [11, 8]], None, {'A': 5, 'B': 5}]),
  ('variant scenario 2',
   ('AABAAAABABAAAAAAABAAABABBBABBBBABBBAABBAAABBBBBAAAAABABBABABBAAAABABB', 'B'),
   [[[25, 17], [13, 14]], None, {'A': 0, 'B': 1}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AABAAABAAAABAAAABAAAAABBAAABABABABABABAAAABAABBBBABAABBAABAABBBAAAAAAAAABBAAABABBABBABABAAAAAAAAAAB',
    'A'),
   [[[25, 10], [25, 16], [15, 8]], None, {'A': 5, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('BABAAABABAABAAAAABAAAAABABABABBABABBBABABBAAABBBAABBAABAABABAAAABAAAABABBAABAAAABAABAAAAABAABABBAAAAAAABBBBBBAAAAAABBBAAABBAAAABBBBABBBBBBABBBAAABAAABBBAB',
    'A'),
   [[[25, 18], [25, 14], [25, 14]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 2',
   ('BAAAABAAAAAAAAABAABAAAABBAAABAAAAAAAAABBBAAAABAAABABBAABABABAABAAAAAAAAABABBBABBBAABAAAAAAABBABBABABBAABAAA',
    'A'),
   [[[25, 7], [25, 11], [23, 16]], None, {'A': 3, 'B': 3}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('BAAABABBBBBAAAABABAABAAAAAABAAABBBBAAAAABABABABAAAABAABAABAABBAABAAAAAAAAAAAABBBAABAAAAAABAAABAAAAABBAABAAABBBBABABBABABAAABBABAABBBAAAABBBAABBAAABAABABBBAAABBBABAAAABBAAAABBBBBABA',
    'A'),
   [[[25, 15], [25, 10], [25, 14]], 'A', {'A': 2, 'B': 2}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1',
   ('ABABAAAAAAAABBAABAABAABBAAAABABAAABAAAABBABABBBBAABABABABABBABBAABBBBABBAABA', 'A'),
   [[[25, 11], [18, 22]], None, {'A': 1, 'B': 0}]),
  ('variant scenario 2',
   ('AABBAABBABAAAAAABABBBABBBBBBBAAAAABAAAAABABABBAABAABBAAAAAAABABAAABBBBBABAAAAAAAAAABAABAABAAAAAAABBAABABBAABABABBBBAAABABAAAAAAABABBBBBBBAAAAAAAABBBBAAAAABAAAABBBBAAAAABABAAAABABBBBB',
    'B'),
   [[[25, 19], [25, 13], [25, 16]], 'A', {'A': 0, 'B': 5}])],
 [('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
  ('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
  ('boundary second set served by other team',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
   [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
  ('boundary deuce in set',
   ('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
   [[[26, 24]], None, {'A': 0, 'B': 0}]),
  ('control straight-sets match',
   ('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
   [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
  ('regression: deciding set target',
   ('AAAABAAAAAAAAAAAAAAABBAAABAAABABABAAAABABBBAABAAAAAAABBAAABABAABBABAABAAAABBAAABAABABAAAAAAAAABAABBAAAAAAABAABAAABAABBABABABABAAABABAABBAAABBABABAAAAAAAABAAAAAAAAABAABABABAAAABAAABAABABAAAAAAAABAAABBBABAABBA',
    'A'),
   [[[25, 4], [25, 15], [25, 9]], 'A', {'A': 1, 'B': 1}]),
  ('regression: deciding set target',
   ('AAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAAAAAAA',
    'A'),
   [[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]),
  ('variant scenario 1', ('AAAAAAAAABABAABBBBAAAA', 'A'), [[[16, 6]], None, {'A': 3, 'B': 3}]),
  ('variant scenario 2',
   ('AAAABAABAAABABBAAAAAAAABAABAABAAABAABAABBABAAABBABBAAAABABBAAABBABABAAABBAAAAABAABABAB', 'A'),
   [[[25, 8], [25, 18], [6, 4]], None, {'A': 3, 'B': 4}])]]
for label, args, expected in cases[N - 1]:
    check(label, run(args), expected)
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)
Boundary fixtureActualExpectedOutcome
control first rally held by server[[[1, 0]], None, {'A': 0, 'B': 0}][[[1, 0]], None, {'A': 0, 'B': 0}]Passed
boundary side-out rotates receiver[[[0, 1]], None, {'A': 0, 'B': 1}][[[0, 1]], None, {'A': 0, 'B': 1}]Passed
control clean set[[[25, 0]], None, {'A': 0, 'B': 0}][[[25, 0]], None, {'A': 0, 'B': 0}]Passed
boundary second set served by other team[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}][[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]Passed
boundary deuce in set[[[26, 24]], None, {'A': 0, 'B': 0}][[[26, 24]], None, {'A': 0, 'B': 0}]Passed
control straight-sets match[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}][[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]Passed
regression: deciding set target[[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}][[[25, 0], [0, 25], [25, 0], [0, 25], [15, 0]], 'A', {'A': 0, 'B': 0}]Passed
variant scenario 1[[[18, 15]], None, {'A': 0, 'B': 1}][[[18, 15]], None, {'A': 0, 'B': 1}]Passed
variant scenario 2[[[16, 7]], None, {'A': 4, 'B': 4}][[[16, 7]], None, {'A': 4, 'B': 4}]Passed

SHA-256 / ba964762adaa373261f8f25c8be74e12b7bbac3c85b7edfbf2de0d374f7458fc

Verification & scope

Stipulated, bounded toy contract stated in the contract field; not a claim of conformance with any governing body rulebook or operator house rules. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:50:25.904878+00:00.

Case digest / e8e703dd81fc21bf875f6b8fc6372ac590b57e038425d3e9933cf94dcb794bd6