PascalCTF 2026 - Keep Scripting

1
#!/usr/bin/env python3
2
import asyncio
3
import re
4
import json
5

6
serial_number = ""
7
batteries = 0
8
label = ""
9
ports = []
10
strikes = 0
11

12
PASSWORDS = ['about', 'after', 'again', 'below', 'could', 'every', 'first', 'found', 'great', 'house',
13
    'large', 'learn', 'never', 'other', 'place', 'plant', 'point', 'right', 'small', 'sound',
14
    'spell', 'still', 'study', 'their', 'there', 'these', 'thing', 'think', 'three', 'water',
15
    'where', 'which', 'world', 'would', 'write']
16

17
MORSE_WORDS = {'shell': '3.505', 'halls': '3.515', 'slick': '3.522', 'trick': '3.532',
18
    'boxes': '3.535', 'leaks': '3.542', 'strobe': '3.545', 'bistro': '3.552',
19
    'flick': '3.555', 'bombs': '3.565', 'break': '3.572', 'brick': '3.575',
20
    'steak': '3.582', 'sting': '3.592', 'vector': '3.595', 'beats': '3.600'}
21

22
# Symbol mapping for case/variant normalization
23
SYMBOL_MAP = {
24
    'Ԇ': 'Ҋ', 'ԅ': 'Ҋ', 'Ҭ': 'Ѭ', 'ϙ': 'Ϙ', 'ψ': 'Ψ', 'ω': 'Ω',
25
    'Ʊ': 'Ͽ', '϶': 'Ͽ', '∈': 'Ͻ', 'ҩ': 'Ҩ', 'ҋ': 'Ҋ', 'ѯ': 'Ѯ',
26
    'ѧ': 'Ѧ', 'ѡ': 'Ѡ', 'ѣ': 'Ѣ', 'ӭ': 'Ӭ', 'ϭ': 'Ϭ', 'ϟ': 'Ϟ',
27
    'Ҁ': 'Ҋ', 'ҁ': 'Ҋ', 'Ѽ': 'Ѡ', 'ѽ': 'Ѡ',
28
    'б': 'Ϭ', 'Б': 'Ϭ', 'ᖵ': 'Ҋ', 'Ꮾ': 'Ϭ', 'ƀ': 'Ϭ',
29
}
30

31
# Standard KTANE Keypad Columns (from official bomb defusal manual)
32
# Symbols appear in reading order (top to bottom)
33
KEYPAD_COLS = [
34
    # Column 1
35
    ['Ϙ', 'Ѧ', 'ƛ', 'Ϟ', 'Ѭ', 'ϗ', 'Ͽ'],
36
    # Column 2
37
    ['Ӭ', 'Ϙ', 'Ͽ', 'Ҩ', '☆', 'ϗ', '¿'],
38
    # Column 3
39
    ['©', 'Ѡ', 'Ҩ', 'Җ', 'Ҋ', 'ƛ', '☆'],
40
    # Column 4
41
    ['Ϭ', '¶', 'Ѣ', 'Ѭ', 'Җ', '¿', 'ټ'],
42
    # Column 5
43
    ['Ψ', 'ټ', 'Ѣ', 'Ͼ', '¶', 'Ѯ', '★'],
44
    # Column 6
45
    ['Ϭ', 'Ӭ', '҂', 'æ', 'Ψ', 'Ҋ', 'Ω'],
46
]
47

48
# Additional columns for CTF variants - these may contain raw/unmapped symbols
49
# These columns are checked first (before standard KTANE columns)
50
KEYPAD_COLS_RAW = [
51
    # Combined column with all observed symbols in order
52
    # Covers both ['ψ', '¶', 'ټ', 'ƀ'] → [1, 3, 4, 2] (ψ→ټ→ƀ→¶)
53
    # And ['ټ', 'Ͼ', 'ƀ', 'ψ'] → [4, 1, 3, 2] (ψ→ټ→ƀ→Ͼ)
54
    ['ψ', 'ټ', 'ƀ', 'Ͼ', '¶', 'Ѣ', 'Ѯ', '★'],
55
    # New column for ['¶', 'Җ', 'ټ', 'ƀ'] → [1, 4, 2, 3] (¶→ƀ→Җ→ټ)
56
    # Note: This ordering of ¶ and ƀ contradicts the column above, so they must be distinct
57
    ['¶', 'ƀ', 'Җ', 'ټ'],
58
    # New column for ['б', 'ƀ', '¿', 'ټ'] → [1, 4, 2, 3] (б→ƀ→¿→ټ)
59
    ['б', 'ƀ', '¿', 'ټ'],
60
]
61

62
RED_WIRE = {1: ['C'], 2: ['B'], 3: ['A'], 4: ['A', 'C'], 5: ['B'], 6: ['A', 'C'], 7: ['A', 'B', 'C'], 8: ['A', 'B'], 9: ['B']}
63
BLUE_WIRE = {1: ['B'], 2: ['A', 'C'], 3: ['B'], 4: ['A'], 5: ['B'], 6: ['B', 'C'], 7: ['C'], 8: ['A', 'C'], 9: ['A']}
64
BLACK_WIRE = {1: ['A', 'B', 'C'], 2: ['A', 'C'], 3: ['B'], 4: ['A', 'C'], 5: ['B'], 6: ['B', 'C'], 7: ['A', 'B'], 8: ['C'], 9: ['C']}
65

66
SIMON_V = {0: {'red': 'blue', 'blue': 'red', 'green': 'yellow', 'yellow': 'green'},
67
    1: {'red': 'yellow', 'blue': 'green', 'green': 'blue', 'yellow': 'red'},
68
    2: {'red': 'green', 'blue': 'red', 'green': 'yellow', 'yellow': 'blue'}}
69
SIMON_NV = {0: {'red': 'blue', 'blue': 'yellow', 'green': 'green', 'yellow': 'red'},
70
    1: {'red': 'red', 'blue': 'blue', 'green': 'yellow', 'yellow': 'green'},
71
    2: {'red': 'yellow', 'blue': 'green', 'green': 'blue', 'yellow': 'red'}}
72

73
WHOS1 = {'YES': 2, 'FIRST': 1, 'DISPLAY': 5, 'OKAY': 1, 'SAYS': 5, 'NOTHING': 2,
74
    '': 4, 'BLANK': 3, 'NO': 5, 'LED': 2, 'LEAD': 5, 'READ': 3,
75
    'RED': 3, 'REED': 4, 'LEED': 4, 'HOLD ON': 5, 'YOU': 3, 'YOU ARE': 5,
76
    'YOUR': 3, "YOU'RE": 3, 'UR': 0, 'THERE': 5, "THEY'RE": 4, 'THEIR': 3,
77
    'THEY ARE': 2, 'SEE': 5, 'C': 1, 'CEE': 5}
78

79
WHOS2 = {
80
    'READY': ['YES', 'OKAY', 'WHAT', 'MIDDLE', 'LEFT', 'PRESS', 'RIGHT', 'BLANK', 'READY', 'NO', 'FIRST', 'UHHH', 'NOTHING', 'WAIT'],
81
    'FIRST': ['LEFT', 'OKAY', 'YES', 'MIDDLE', 'NO', 'RIGHT', 'NOTHING', 'UHHH', 'WAIT', 'READY', 'BLANK', 'WHAT', 'PRESS', 'FIRST'],
82
    'NO': ['BLANK', 'UHHH', 'WAIT', 'FIRST', 'WHAT', 'READY', 'RIGHT', 'YES', 'NOTHING', 'LEFT', 'PRESS', 'OKAY', 'NO', 'MIDDLE'],
83
    'BLANK': ['WAIT', 'RIGHT', 'OKAY', 'MIDDLE', 'BLANK', 'PRESS', 'READY', 'NOTHING', 'NO', 'WHAT', 'LEFT', 'UHHH', 'YES', 'FIRST'],
84
    'NOTHING': ['UHHH', 'RIGHT', 'OKAY', 'MIDDLE', 'YES', 'BLANK', 'NO', 'PRESS', 'LEFT', 'WHAT', 'WAIT', 'FIRST', 'NOTHING', 'READY'],
85
    'YES': ['OKAY', 'RIGHT', 'UHHH', 'MIDDLE', 'FIRST', 'WHAT', 'PRESS', 'READY', 'NOTHING', 'YES', 'LEFT', 'BLANK', 'NO', 'WAIT'],
86
    'WHAT': ['UHHH', 'WHAT', 'LEFT', 'NOTHING', 'READY', 'BLANK', 'MIDDLE', 'NO', 'OKAY', 'FIRST', 'WAIT', 'YES', 'PRESS', 'RIGHT'],
87
    'UHHH': ['READY', 'NOTHING', 'LEFT', 'WHAT', 'OKAY', 'YES', 'RIGHT', 'NO', 'PRESS', 'BLANK', 'UHHH', 'MIDDLE', 'WAIT', 'FIRST'],
88
    'LEFT': ['RIGHT', 'LEFT', 'FIRST', 'NO', 'MIDDLE', 'YES', 'BLANK', 'WHAT', 'UHHH', 'WAIT', 'PRESS', 'READY', 'OKAY', 'NOTHING'],
89
    'RIGHT': ['YES', 'NOTHING', 'READY', 'PRESS', 'NO', 'WAIT', 'WHAT', 'RIGHT', 'MIDDLE', 'LEFT', 'UHHH', 'BLANK', 'OKAY', 'FIRST'],
90
    'MIDDLE': ['BLANK', 'READY', 'OKAY', 'WHAT', 'NOTHING', 'PRESS', 'NO', 'WAIT', 'LEFT', 'MIDDLE', 'RIGHT', 'FIRST', 'UHHH', 'YES'],
91
    'OKAY': ['MIDDLE', 'NO', 'FIRST', 'YES', 'UHHH', 'NOTHING', 'WAIT', 'OKAY', 'LEFT', 'READY', 'BLANK', 'PRESS', 'WHAT', 'RIGHT'],
92
    'WAIT': ['UHHH', 'NO', 'BLANK', 'OKAY', 'YES', 'LEFT', 'FIRST', 'PRESS', 'WHAT', 'WAIT', 'NOTHING', 'READY', 'RIGHT', 'MIDDLE'],
93
    'PRESS': ['RIGHT', 'MIDDLE', 'YES', 'READY', 'PRESS', 'OKAY', 'NOTHING', 'UHHH', 'BLANK', 'LEFT', 'FIRST', 'WHAT', 'NO', 'WAIT'],
94
    'YOU': ['SURE', 'YOU ARE', 'YOUR', "YOU'RE", 'NEXT', 'UH HUH', 'UR', 'HOLD', 'WHAT?', 'YOU', 'UH UH', 'LIKE', 'DONE', 'U'],
95
    'YOU ARE': ['YOUR', 'NEXT', 'LIKE', 'UH HUH', 'WHAT?', 'DONE', 'UH UH', 'HOLD', 'YOU', 'U', "YOU'RE", 'SURE', 'UR', 'YOU ARE'],
96
    'YOUR': ['UH UH', 'YOU ARE', 'UH HUH', 'YOUR', 'NEXT', 'UR', 'SURE', 'U', "YOU'RE", 'YOU', 'WHAT?', 'HOLD', 'LIKE', 'DONE'],
97
    "YOU'RE": ['YOU', "YOU'RE", 'UR', 'NEXT', 'UH UH', 'YOU ARE', 'U', 'YOUR', 'WHAT?', 'UH HUH', 'SURE', 'DONE', 'LIKE', 'HOLD'],
98
    'UR': ['DONE', 'U', 'UR', 'UH HUH', 'WHAT?', 'SURE', 'YOUR', 'HOLD', "YOU'RE", 'LIKE', 'NEXT', 'UH UH', 'YOU ARE', 'YOU'],
99
    'U': ['UH HUH', 'SURE', 'NEXT', 'WHAT?', "YOU'RE", 'UR', 'UH UH', 'DONE', 'U', 'YOU', 'LIKE', 'HOLD', 'YOU ARE', 'YOUR'],
100
    'UH HUH': ['UH HUH', 'YOUR', 'YOU ARE', 'YOU', 'DONE', 'HOLD', 'UH UH', 'NEXT', 'SURE', 'LIKE', "YOU'RE", 'UR', 'U', 'WHAT?'],
101
    'UH UH': ['UR', 'U', 'YOU ARE', "YOU'RE", 'NEXT', 'UH UH', 'DONE', 'YOU', 'UH HUH', 'LIKE', 'YOUR', 'SURE', 'HOLD', 'WHAT?'],
102
    'WHAT?': ['YOU', 'HOLD', "YOU'RE", 'YOUR', 'U', 'DONE', 'UH UH', 'LIKE', 'YOU ARE', 'UH HUH', 'UR', 'NEXT', 'WHAT?', 'SURE'],
103
    'DONE': ['SURE', 'UH HUH', 'NEXT', 'WHAT?', 'YOUR', 'UR', "YOU'RE", 'HOLD', 'LIKE', 'YOU', 'U', 'YOU ARE', 'UH UH', 'DONE'],
104
    'NEXT': ['WHAT?', 'UH HUH', 'UH UH', 'YOUR', 'HOLD', 'SURE', 'NEXT', 'LIKE', 'DONE', 'YOU ARE', 'UR', "YOU'RE", 'U', 'YOU'],
105
    'HOLD': ['YOU ARE', 'U', 'DONE', 'UH UH', 'YOU', 'UR', 'SURE', 'WHAT?', "YOU'RE", 'NEXT', 'HOLD', 'UH HUH', 'YOUR', 'LIKE'],
106
    'SURE': ['YOU ARE', 'DONE', 'LIKE', "YOU'RE", 'YOU', 'HOLD', 'UH HUH', 'UR', 'SURE', 'U', 'WHAT?', 'NEXT', 'YOUR', 'UH UH'],
107
    'LIKE': ["YOU'RE", 'NEXT', 'U', 'UR', 'HOLD', 'DONE', 'UH UH', 'WHAT?', 'UH HUH', 'YOU', 'LIKE', 'SURE', 'YOU ARE', 'YOUR'],
108
}
109

110
STRIP_DIGIT = {'blue': '4', 'white': '1', 'yellow': '5'}
111

112
def has_vowel(s): return any(c in 'AEIOUaeiou' for c in s)
113
def last_digit_odd(s):
114
    for c in reversed(s):
115
        if c.isdigit(): return int(c) % 2 == 1
116
    return False
117
def last_digit_even(s): return not last_digit_odd(s)
118
def has_parallel(p): return 'parallel' in [x.lower() for x in p]
119

120
def solve_wires(colors, serial):
121
    n, c = len(colors), [x.lower() for x in colors]
122
    if n == 3:
123
        if 'red' not in c: return 2
124
        if c[-1] == 'white': return 3
125
        if c.count('blue') > 1:
126
            for i in range(n-1, -1, -1):
127
                if c[i] == 'blue': return i+1
128
        return 3
129
    if n == 4:
130
        if c.count('red') > 1 and last_digit_odd(serial):
131
            for i in range(n-1, -1, -1):
132
                if c[i] == 'red': return i+1
133
        if c[-1] == 'yellow' and 'red' not in c: return 1
134
        if c.count('blue') == 1: return 1
135
        if c.count('yellow') > 1: return 4
136
        return 2
137
    if n == 5:
138
        if c[-1] == 'black' and last_digit_odd(serial): return 4
139
        if c.count('red') == 1 and c.count('yellow') > 1: return 1
140
        if 'black' not in c: return 2
141
        return 1
142
    if n == 6:
143
        if 'yellow' not in c and last_digit_odd(serial): return 3
144
        if c.count('yellow') == 1 and c.count('white') > 1: return 4
145
        if 'red' not in c: return 6
146
        return 4
147
    return 1
148

149
def solve_button(color, text, batt, inds):
150
    c, t = color.lower(), text.lower()
151
    if c == 'blue' and t == 'abort': return '2'
152
    if batt > 1 and t == 'detonate': return '1'
153
    if c == 'white' and any(i.get('label') == 'CAR' and i.get('lit') for i in inds): return '2'
154
    if batt > 2 and any(i.get('label') == 'FRK' and i.get('lit') for i in inds): return '1'
155
    if c == 'yellow': return '2'
156
    if c == 'red' and t == 'hold': return '1'
157
    return '2'
158

159
def solve_keypads(symbols):
160
    """
161
    Solve the keypads module by finding a column that contains all 4 symbols
162
    and returning the button positions in the order they appear in that column.
163

164
    The keypad has 4 buttons at positions 1-4 with symbols.
165
    We need to find which column contains all these symbols and return
166
    the positions sorted by their order in the column.
167
    """
168
    # First, try matching raw symbols directly (no mapping) against all columns
169
    all_cols = KEYPAD_COLS_RAW + KEYPAD_COLS
170
    for col in all_cols:
171
        if all(s in col for s in symbols):
172
            # Sort by column order and return original positions
173
            pos = sorted([(col.index(s), i + 1) for i, s in enumerate(symbols)])
174
            return [p[1] for p in pos]
175

176
    # Next, try with mapped symbols against standard columns
177
    mapped = [SYMBOL_MAP.get(s, s) for s in symbols]
178
    for col in KEYPAD_COLS:
179
        if all(s in col for s in mapped):
180
            # Use zip to pair mapped symbol (for index lookup) with original index
181
            pos = sorted([(col.index(m), i + 1) for i, m in enumerate(mapped)])
182
            return [p[1] for p in pos]
183

184
    # Fallback: return default order if no column matches
185
    return [1, 2, 3, 4]
186

187
def solve_memory(stage, display, buttons, history):
188
    if stage == 1:
189
        p = {1:2, 2:2, 3:3, 4:4}.get(display, 2)
190
        return p, str(buttons[p-1])
191
    if stage == 2:
192
        if display == 1: return buttons.index(4)+1 if 4 in buttons else 1, '4'
193
        if display in [2,4]: return history[0]['position'], str(buttons[history[0]['position']-1])
194
        return 1, str(buttons[0])
195
    if stage == 3:
196
        if display == 1: lbl = int(history[1]['label']); return buttons.index(lbl)+1 if lbl in buttons else 1, str(lbl)
197
        if display == 2: lbl = int(history[0]['label']); return buttons.index(lbl)+1 if lbl in buttons else 1, str(lbl)
198
        if display == 3: return 3, str(buttons[2])
199
        return buttons.index(4)+1 if 4 in buttons else 1, '4'
200
    if stage == 4:
201
        if display == 1: return history[0]['position'], str(buttons[history[0]['position']-1])
202
        if display == 2: return 1, str(buttons[0])
203
        return history[1]['position'], str(buttons[history[1]['position']-1])
204
    if stage == 5:
205
        lbl = int(history[{1:0, 2:1, 3:3, 4:2}.get(display, 0)]['label'])
206
        return buttons.index(lbl)+1 if lbl in buttons else 1, str(lbl)
207
    return 1, str(buttons[0])
208

209
def solve_simon(flashes, serial, strikes):
210
    m = (SIMON_V if has_vowel(serial) else SIMON_NV).get(min(strikes, 2))
211
    return [m.get(f.lower(), f.lower()) for f in flashes]
212

213
def solve_whos(display, buttons):
214
    d, b = display.strip().upper(), [x.strip().upper() for x in buttons]
215
    idx = WHOS1.get(d, 4)
216
    if idx >= len(b): idx = 0
217
    lbl = b[idx]
218
    for c in WHOS2.get(lbl, []):
219
        if c in b: return b.index(c) + 1
220
    return 1
221

222
def solve_complicated(color, led, star, serial, batt, ports):
223
    c = color.lower()
224
    r, bl = 'red' in c, 'blue' in c
225
    par, even, b2 = has_parallel(ports), last_digit_even(serial), batt >= 2
226
    # No attributes = C
227
    if not r and not bl and not star and not led: return True
228
    # Single attribute
229
    if r and not bl and not star and not led: return even  # S
230
    if not r and bl and not star and not led: return even  # S
231
    if not r and not bl and star and not led: return True  # C
232
    if not r and not bl and not star and led: return False  # D
233
    # Two attributes
234
    if r and bl and not star and not led: return even  # S
235
    if r and not bl and star and not led: return True  # C
236
    if r and not bl and not star and led: return b2  # B
237
    if not r and bl and star and not led: return False  # D
238
    if not r and bl and not star and led: return par  # P
239
    if not r and not bl and star and led: return b2  # B
240
    # Three attributes
241
    if r and bl and star and not led: return par  # P
242
    if r and bl and not star and led: return even  # S
243
    if r and not bl and star and led: return b2  # B
244
    if not r and bl and star and led: return par  # P
245
    # All four
246
    if r and bl and star and led: return False  # D
247
    return False
248

249
def solve_password(cols):
250
    for w in PASSWORDS:
251
        if all(w[i].lower() in [c.lower() for c in cols[i]] for i in range(min(len(w), len(cols)))):
252
            return w
253
    return 'about'
254

255
async def main():
256
    serial_number = None
257
    batteries = None
258
    label = None
259
    ports = None
260
    strikes = 0
261

262
    reader, writer = await asyncio.open_connection('scripting.ctf.pascalctf.it', 6004)
263

264
    mem_hist, mem_stage = [], 1
265
    wr, wb, wbl = 0, 0, 0
266
    buf = ""
267
    waiting_digit = False
268
    strip_color = ""
269

270
    async def send(msg):
271
        # print(f">>> {msg}")
272
        writer.write((msg + '\n').encode())
273
        await writer.drain()
274

275
    try:
276
        while True:
277
            try:
278
                data = await asyncio.wait_for(reader.read(65536), timeout=0.1)
279
                if not data:
280
                    break
281
                buf += data.decode('utf-8', errors='replace')
282
                # print(data.decode('utf-8', errors='replace'), end='', flush=True)
283
                print(data.decode('utf-8', errors='replace'), end='')
284
            except asyncio.TimeoutError:
285
                pass
286

287
            if serial_number is None and (m := re.search(r'Serial Number:\s*(\w+)', buf)): serial_number = m.group(1)
288
            if batteries is None and (m := re.search(r'Batteries:\s*(\d+)', buf)): batteries = int(m.group(1))
289
            if label is None and (m := re.search(r'Label:\s*(\w+)', buf)): label = m.group(1)
290
            if ports is None and (m := re.search(r'Ports:\s*(.+)', buf)): ports = [p.strip() for p in m.group(1).split(',')]
291

292
            if 'ptm{' in buf.lower() or 'flag{' in buf.lower() or 'CTF{' in buf:
293
                print("\n[+] FLAG FOUND!")
294
                print(buf)
295
                break
296
            if 'Game Over' in buf or 'exploded' in buf:
297
                print("GAME OVER detected!")
298
                print(buf[-2000:])
299
                break
300

301
            if waiting_digit and 'digit' in buf.lower():
302
                await send(STRIP_DIGIT.get(strip_color.lower(), '1'))
303
                waiting_digit = False
304
                buf = ""
305
                continue
306

307
            if ('Select Module' in buf or 'press Enter' in buf) and '🔧' not in buf.split('Select Module')[-1]:
308
                await send('')
309
                buf = ""
310
                continue
311

312
            # Complicated Wires
313
            if 'Module: Complicated Wires' in buf and 'Wire 1:' in buf:
314
                cm = re.search(r"'colors':\s*\[([^\]]+)\]", buf)
315
                lm = re.search(r"'leds':\s*\[([^\]]+)\]", buf)
316
                sm = re.search(r"'stars':\s*\[([^\]]+)\]", buf)
317
                if cm and lm and sm:
318
                    colors = re.findall(r"'([^']+)'", cm.group(1))
319
                    leds = ['True' in x for x in lm.group(1).split(',')]
320
                    stars = ['True' in x for x in sm.group(1).split(',')]
321
                    for i in range(len(colors)):
322
                        ans = 'cut' if solve_complicated(colors[i], leds[i], stars[i], serial_number, batteries, ports) else 'skip'
323
                        await send(ans)
324
                    buf = ""
325
                    continue
326

327
            # Simple Wires
328
            if 'Module: Wires' in buf and ('wire' in buf.lower() and ('cut' in buf.lower() or 'number' in buf.lower())):
329
                wm = re.search(r"'colors':\s*\[([^\]]+)\]", buf)
330
                if wm:
331
                    wires = re.findall(r"'([^']+)'", wm.group(1))
332
                    await send(str(solve_wires(wires, serial_number)))
333
                    buf = ""
334
                    continue
335

336
            # Keypads
337
            if 'Module: Keypads' in buf and 'Sequence' in buf:
338
                sm = re.search(r"'symbols':\s*\[([^\]]+)\]", buf)
339
                if sm:
340
                    symbols = re.findall(r"'([^']+)'", sm.group(1))
341
                    await send(' '.join(map(str, solve_keypads(symbols))))
342
                    buf = ""
343
                    continue
344

345
            # Button
346
            if 'Module: Button' in buf and 'Choose action' in buf:
347
                cm = re.search(r"'color':\s*'([^']+)'", buf)
348
                tm = re.search(r"'text':\s*'([^']+)'", buf)
349
                cs = re.search(r"'color_strip':\s*'([^']+)'", buf)
350
                if cm and tm:
351
                    inds = [{'label': label, 'lit': True}] if label else []
352
                    action = solve_button(cm.group(1), tm.group(1), batteries, inds)
353
                    if cs: strip_color = cs.group(1)
354
                    if action == '2': waiting_digit = True
355
                    await send(action)
356
                    buf = ""
357
                    continue
358

359
            # Memory
360
            if 'Module: Memory' in buf and 'position' in buf.lower():
361
                dm = re.search(r"'display':\s*(\d+)", buf)
362
                bm = re.search(r"'buttons':\s*\[([^\]]+)\]", buf)
363
                stm = re.search(r"'stage':\s*(\d+)", buf)
364
                if dm and bm:
365
                    display = int(dm.group(1))
366
                    buttons = [int(x.strip()) for x in bm.group(1).split(',')]
367
                    if stm: mem_stage = int(stm.group(1))
368
                    pos, lbl = solve_memory(mem_stage, display, buttons, mem_hist)
369
                    mem_hist.append({'position': pos, 'label': lbl})
370
                    await send(str(pos))
371
                    if mem_stage >= 5: mem_hist, mem_stage = [], 1
372
                    else: mem_stage += 1
373
                    buf = ""
374
                    continue
375

376
            # Simon Says
377
            if 'Module: Simon' in buf and ('flashes' in buf.lower() or 'sequence' in buf.lower()):
378
                fm = re.search(r"'flashes':\s*\[([^\]]+)\]", buf)
379
                if fm:
380
                    flashes = re.findall(r"'([^']+)'", fm.group(1))
381
                    await send(' '.join(solve_simon(flashes, serial_number, strikes)))
382
                    buf = ""
383
                    continue
384

385
            # Who's on First
386
            if ("Who's on First" in buf or "Module: Who" in buf) and 'buttons' in buf:
387
                dm = re.search(r"'display':\s*'([^']*)'", buf)
388
                bm = re.search(r"'buttons':\s*\[([^\]]+)\]", buf)
389
                if dm and bm:
390
                    buttons = re.findall(r"'([^']+)'", bm.group(1))
391
                    await send(str(solve_whos(dm.group(1), buttons)))
392
                    buf = ""
393
                    continue
394

395
            # Password
396
            if 'Module: Password' in buf and 'columns' in buf:
397
                cm = re.search(r"'columns':\s*(\[\[.+?\]\])", buf, re.DOTALL)
398
                if cm:
399
                    try:
400
                        cols = json.loads(cm.group(1).replace("'", '"'))
401
                        await send(solve_password(cols))
402
                    except: await send('about')
403
                    buf = ""
404
                    continue
405

406
            # Morse Code
407
            if 'Module: Morse' in buf and 'word' in buf:
408
                wm = re.search(r"'word':\s*'([^']+)'", buf)
409
                if wm:
410
                    await send(MORSE_WORDS.get(wm.group(1).lower(), '3.500'))
411
                    buf = ""
412
                    continue
413

414
            # Wire Sequences
415
            if 'Module: Wire Sequence' in buf and 'wires' in buf:
416
                wm = re.search(r"'wires':\s*(\[.+?\])", buf, re.DOTALL)
417
                if wm:
418
                    try:
419
                        wires = json.loads(wm.group(1).replace("'", '"'))
420
                        cut = []
421
                        for i, w in enumerate(wires):
422
                            c, d = w['color'].lower(), w['to'].upper()
423
                            if c == 'red': wr += 1; rules = RED_WIRE
424
                            elif c == 'blue': wb += 1; rules = BLUE_WIRE
425
                            elif c == 'black': wbl += 1; rules = BLACK_WIRE
426
                            else: continue
427
                            cnt = wr if c == 'red' else (wb if c == 'blue' else wbl)
428
                            if d in rules.get(cnt, []): cut.append(i+1)
429
                        await send(' '.join(map(str, cut)) if cut else 'none')
430
                    except: await send('none')
431
                    buf = ""
432
                    continue
433

434
            if len(buf) > 20000: buf = buf[-10000:]
435

436
    finally:
437
        writer.close()
438
        await writer.wait_closed()
439

440
if __name__ == '__main__':
441
    asyncio.run(main())