Phase 1: Opset 17 switch — Slice-based flip/rotate, tensor-based Pad, IR=8

Changes:
- IR 10→8, OPSET 10→17
- s_flip: Slice(step=-1) instead of Gather (0 MACs vs ~165K)
- s_rotate k=2: double Slice(step=-1) (0 MACs vs ~165K)
- s_rotate k=1,3: Slice+Transpose for square grids (0 MACs), Gather fallback for non-square
- s_transpose: already zero-cost, no change needed
- All Pad nodes: attribute-based→tensor-based pads input (opset 17 requirement)
- New helpers: _make_int64_init(), _build_pad_node(), _build_slice_crop_pad()
- mk() updated to use IR=8 and opset 17

neurogolf_solver.py

@@ -1,16 +1,15 @@
 #!/usr/bin/env python3
 """
-ARC-AGI NeuroGolf Championship - Complete Solver v4
-Format: [1,10,30,30] one-hot input/output, opset 10, IR version 10.
-
-v4 CRITICAL FIXES:
-  - ARC-GEN data loaded and used for conv fitting (more data = better lstsq)
-  - ARC-GEN validation: models validated against train+test+arc-gen
-  - EXCLUDED tasks: {21, 55, 80, 184, 202, 366} skipped
-  - submission.csv generation for Kaggle
-  - s_flip fixed: GatherElements -> Gather (opset 10 compat)
-  - Static profiler: no onnx_tool dependency for cost estimation
-  - get_exs_for_fitting(): uses train+test+arc-gen for conv fitting
+ARC-AGI NeuroGolf Championship - Complete Solver v5
+Format: [1,10,30,30] one-hot input/output, opset 17, IR version 8.
+
+v5 CHANGES (from v4):
+  - Opset 10 → 17, IR 10 → 8
+  - s_flip: Slice(step=-1) replaces Gather — 0 MACs (was ~165K)
+  - s_rotate k=2: double Slice(step=-1) — 0 MACs (was ~165K)
+  - s_rotate k=1,3: Slice+Transpose for square grids (0 MACs), Gather fallback for non-square
+  - All Pad nodes: tensor-based pads input (opset 17 requirement)
+  - All other solvers unchanged from v4
 
 Solvers:
   - Analytical: identity, constant, color_map, transpose, flip, rotate, tile, upscale,
@@ -46,8 +45,10 @@ except ImportError:
 BATCH, CH, GH, GW = 1, 10, 30, 30
 GRID_SHAPE = [BATCH, CH, GH, GW]
 DT = TensorProto.FLOAT
-IR = 10
-OPSET = [helper.make_opsetid("", 10)]
+IR = 8
+OPSET = [helper.make_opsetid("", 17)]
+
+INT64_MIN = int(np.iinfo(np.int64).min)
 
 # Officially excluded tasks (score 0 regardless)
 EXCLUDED_TASKS = {21, 55, 80, 184, 202, 366}
@@ -55,9 +56,7 @@ EXCLUDED_TASKS = {21, 55, 80, 184, 202, 366}
 # Max ARC-GEN examples to use for validation (to keep runtime reasonable)
 MAX_ARCGEN_VALIDATE = 30
 # Max ARC-GEN examples for conv fitting (keep separate from validation!)
-# NOTE: Conv fitting uses train+test only. ARC-GEN is for VALIDATION only.
-# lstsq underdetermines with too many variable-size arc-gen examples.
-MAX_ARCGEN_FIT = 0  # Don't use arc-gen for fitting — use for validation only
+MAX_ARCGEN_FIT = 0
 
 def get_providers():
     return ['CPUExecutionProvider']
@@ -76,7 +75,6 @@ def load_tasks_dir(data_dir, arcgen_dir=None):
         with open(os.path.join(data_dir, f)) as fh:
             data = json.load(fh)
         hex_id = f.replace('.json','')
-        # Load ARC-GEN data if available
         if arcgen_dir and os.path.exists(os.path.join(arcgen_dir, f)):
             with open(os.path.join(arcgen_dir, f)) as fh:
                 arcgen_examples = json.load(fh)
@@ -109,8 +107,7 @@ def to_onehot(grid):
     return arr
 
 def validate(path, td):
-    """Validate model against ALL examples: train + test + arc-gen.
-    This matches what Kaggle does for scoring."""
+    """Validate model against ALL examples: train + test + arc-gen."""
     try:
         opts = ort.SessionOptions()
         opts.log_severity_level = 3
@@ -118,7 +115,6 @@ def validate(path, td):
     except:
         return False
     examples = td['train'] + td['test']
-    # Include arc-gen examples (capped for speed)
     if 'arc-gen' in td:
         examples = examples + td['arc-gen'][:MAX_ARCGEN_VALIDATE]
     for ex in examples:
@@ -164,8 +160,7 @@ BANNED_OPS = {'Loop', 'Scan', 'NonZero', 'Unique', 'If', 'Function'}
 MAX_FILESIZE = int(1.44 * 1024 * 1024)
 
 def score_network(path):
-    """Static profiler matching Kaggle scoring: cost = macs + memory + params.
-    Falls back to official neurogolf_utils if available."""
+    """Static profiler matching Kaggle scoring: cost = macs + memory + params."""
     if HAS_ONNX_TOOL:
         try:
             return _score_network_official(path)
@@ -215,6 +210,44 @@ def _static_profile(path):
     
     return int(macs), int(nbytes), int(params)
 
+# ============================================================
+# OPSET 17 HELPERS
+# ============================================================
+
+def _make_int64_init(name, values):
+    """Create an int64 tensor initializer from a list of values."""
+    return numpy_helper.from_array(np.array(values, dtype=np.int64), name)
+
+def _build_pad_node(input_name, output_name, pad_h, pad_w, inits, suffix=''):
+    """Build a Pad node with tensor-based pads input (opset 17).
+    Pads [0,0,0,0, 0,0,pad_h,pad_w] — only spatial end-padding."""
+    pads_name = f'pads{suffix}'
+    cv_name = f'pad_cv{suffix}'
+    pads_arr = np.array([0, 0, 0, 0, 0, 0, pad_h, pad_w], dtype=np.int64)
+    inits.append(numpy_helper.from_array(pads_arr, pads_name))
+    inits.append(numpy_helper.from_array(np.array(0.0, dtype=np.float32), cv_name))
+    return helper.make_node('Pad', [input_name, pads_name, cv_name], [output_name], mode='constant')
+
+def _build_slice_crop(input_name, output_name, IH, IW, inits, suffix=''):
+    """Build Slice node to crop [1,10,30,30] to [1,10,IH,IW]."""
+    st_name = f'crop_st{suffix}'
+    en_name = f'crop_en{suffix}'
+    inits.append(_make_int64_init(st_name, [0, 0, 0, 0]))
+    inits.append(_make_int64_init(en_name, [1, 10, IH, IW]))
+    return helper.make_node('Slice', [input_name, st_name, en_name], [output_name])
+
+def _build_slice_reverse(input_name, output_name, axis, dim_size, inits, suffix=''):
+    """Build Slice(step=-1) to reverse one axis. Zero MACs."""
+    st_name = f'rev_st{suffix}'
+    en_name = f'rev_en{suffix}'
+    ax_name = f'rev_ax{suffix}'
+    sp_name = f'rev_sp{suffix}'
+    inits.append(_make_int64_init(st_name, [dim_size - 1]))
+    inits.append(_make_int64_init(en_name, [INT64_MIN]))
+    inits.append(_make_int64_init(ax_name, [axis]))
+    inits.append(_make_int64_init(sp_name, [-1]))
+    return helper.make_node('Slice', [input_name, st_name, en_name, ax_name, sp_name], [output_name])
+
 def mk(nodes, inits=None):
     x = helper.make_tensor_value_info("input", DT, GRID_SHAPE)
     y = helper.make_tensor_value_info("output", DT, GRID_SHAPE)
@@ -227,24 +260,19 @@ def get_exs(td):
             for ex in td['train'] + td['test']]
 
 def get_exs_for_fitting(td):
-    """Get examples for conv fitting. Uses train+test + arc-gen WHERE SIZES MATCH.
-    For fixed-size tasks, arc-gen examples have the same grid size,
-    so they provide more data points for lstsq without changing the feature dimension.
-    For variable-size tasks, only use train+test (arc-gen varies too much)."""
+    """Get examples for conv fitting. Uses train+test + arc-gen WHERE SIZES MATCH."""
     base_exs = [(np.array(ex['input'], dtype=np.int64), np.array(ex['output'], dtype=np.int64))
                 for ex in td['train'] + td['test']]
     
     if not base_exs:
         return base_exs
     
-    # Check if all base examples have same input shape
     base_shapes = {inp.shape for inp, _ in base_exs}
     if len(base_shapes) != 1:
-        return base_exs  # Variable sizes — don't add arc-gen
+        return base_exs
     
     base_shape = list(base_shapes)[0]
     
-    # Add arc-gen examples that match the base shape
     ag_exs = []
     for ex in td.get('arc-gen', []):
         inp = np.array(ex['input'], dtype=np.int64)
@@ -252,17 +280,13 @@ def get_exs_for_fitting(td):
         if inp.shape == base_shape and out.shape == base_exs[0][1].shape:
             ag_exs.append((inp, out))
     
-    # Cap to avoid massive lstsq (diminishing returns after ~10)
     return base_exs + ag_exs[:10]
 
 def get_exs_for_fitting_variable(td):
-    """Get examples for variable-shape conv fitting.
-    For variable-shape tasks, arc-gen examples may have different sizes per example
-    but since we embed in 30x30 anyway, we can safely include them."""
+    """Get examples for variable-shape conv fitting."""
     base_exs = [(np.array(ex['input'], dtype=np.int64), np.array(ex['output'], dtype=np.int64))
                 for ex in td['train'] + td['test']]
     
-    # For variable shape, include arc-gen examples (they get embedded in 30x30)
     ag_exs = []
     for ex in td.get('arc-gen', []):
         inp = np.array(ex['input'], dtype=np.int64)
@@ -279,12 +303,11 @@ def fixed_shapes(td):
     return list(shapes)[0] if len(shapes) == 1 else None
 
 # ============================================================
-# GATHER HELPERS
+# GATHER HELPERS (kept for solvers that need them)
 # ============================================================
 
 def _build_gather_model(OH, OW, idx):
-    # Use Gather (opset 1) instead of GatherElements (opset 11)
-    # Flatten spatial: [1,10,900] -> Gather(axis=2, indices=[900]) -> [1,10,900]
+    """Gather-based spatial remapping. Used for concat, spatial_gather, etc."""
     flat_idx = np.zeros((GH*GW,), dtype=np.int64)
     mask = np.zeros((1,1,GH,GW), dtype=np.float32)
     for oi in range(OH):
@@ -306,7 +329,7 @@ def _build_gather_model(OH, OW, idx):
     return mk(nodes, inits)
 
 def _build_gather_model_with_const(IH, IW, OH, OW, idx, cst):
-    # Use Gather (opset 1) instead of GatherElements (opset 11)
+    """Gather-based spatial remapping with constant pixels."""
     flat_idx = np.zeros((GH*GW,), dtype=np.int64)
     gather_mask = np.zeros((1,1,GH,GW), dtype=np.float32)
     const_oh = np.zeros((1,10,GH,GW), dtype=np.float32)
@@ -356,11 +379,9 @@ def s_color_map(td):
             if iv in cm and cm[iv] != ov: return None
             cm[iv] = ov
     
-    # Check if it's a permutation (bijective + all mapped colors form a closed set)
     is_permutation = (set(cm.keys()) == set(cm.values()))
     
     if is_permutation:
-        # Use channel Gather — zero MACs, much cheaper
         gather_ch = np.arange(10, dtype=np.int32)
         for src, dst in cm.items():
             if 0 <= src < 10 and 0 <= dst < 10:
@@ -369,7 +390,6 @@ def s_color_map(td):
         nodes = [helper.make_node('Gather', ['input', 'gi'], ['output'], axis=1)]
         return mk(nodes, inits)
     else:
-        # Non-permutation: use Conv 1x1 (has MACs but handles any mapping)
         W = np.zeros((10,10,1,1), dtype=np.float32)
         for ic in range(10):
             W[cm.get(ic,ic), ic, 0, 0] = 1.0
@@ -377,44 +397,113 @@ def s_color_map(td):
                   [numpy_helper.from_array(W, 'W')])
 
 def s_transpose(td):
+    """Transpose spatial dimensions. Already near-zero cost with Transpose node."""
     for ex in td['train']+td['test']:
         if not np.array_equal(np.array(ex['output']), np.array(ex['input']).T): return None
     return mk([helper.make_node('Transpose', ['input'], ['output'], perm=[0,1,3,2])])
 
 def s_flip(td):
+    """Flip using Slice(step=-1) — zero MACs, replaces old Gather approach."""
     exs = get_exs(td)
     sp = fixed_shapes(td)
     if sp is None: return None
     (IH,IW),(OH,OW) = sp
     if (IH,IW) != (OH,OW): return None
+    
     for axis, flip_fn in [(0, np.flipud), (1, np.fliplr)]:
         if all(np.array_equal(out, flip_fn(inp)) for inp, out in exs):
-            # Build gather index map (using Gather, opset 1 compatible)
-            idx = np.zeros((OH,OW,2), dtype=np.int64)
-            for r in range(OH):
-                for c in range(OW):
-                    if axis == 0:
-                        idx[r,c] = [IH-1-r, c]
-                    else:
-                        idx[r,c] = [r, IW-1-c]
-            return _build_gather_model(OH, OW, idx)
+            # axis 0 = flipud = reverse dim 2 (H)
+            # axis 1 = fliplr = reverse dim 3 (W)
+            onnx_axis = 2 if axis == 0 else 3
+            dim_size = IH if axis == 0 else IW
+            pad_h, pad_w = GH - IH, GW - IW
+            
+            inits = []
+            nodes = []
+            
+            # Step 1: Crop input to [1,10,IH,IW]
+            nodes.append(_build_slice_crop('input', 'cropped', IH, IW, inits))
+            
+            # Step 2: Reverse the target axis
+            nodes.append(_build_slice_reverse('cropped', 'flipped', onnx_axis, dim_size, inits))
+            
+            # Step 3: Pad back to [1,10,30,30]
+            nodes.append(_build_pad_node('flipped', 'output', pad_h, pad_w, inits))
+            
+            return mk(nodes, inits)
     return None
 
 def s_rotate(td):
+    """Rotate using Slice+Transpose combos — zero MACs for square grids and k=2.
+    Falls back to Gather for non-square k=1,3 rotations."""
     exs = get_exs(td)
     sp = fixed_shapes(td)
     if sp is None: return None
     (IH,IW),(OH,OW) = sp
+    
     for k in [1, 2, 3]:
-        if not all(np.array_equal(out, np.rot90(inp, k)) for inp, out in exs): continue
-        idx = np.zeros((OH,OW,2), dtype=np.int64)
-        for r in range(OH):
-            for c in range(OW):
-                if k == 1: sr, sc = c, IH-1-r
-                elif k == 2: sr, sc = IH-1-r, IW-1-c
-                elif k == 3: sr, sc = IW-1-c, r
-                idx[r,c] = [sr, sc]
-        return _build_gather_model(OH, OW, idx)
+        if not all(np.array_equal(out, np.rot90(inp, k)) for inp, out in exs):
+            continue
+        
+        if k == 2:
+            # 180° = flipud + fliplr — works for any shape
+            # output[r,c] = input[IH-1-r, IW-1-c]
+            pad_h, pad_w = GH - OH, GW - OW
+            inits = []
+            nodes = []
+            
+            # Crop to [1,10,IH,IW]
+            nodes.append(_build_slice_crop('input', 'cropped', IH, IW, inits))
+            # Reverse axis 2 (H)
+            nodes.append(_build_slice_reverse('cropped', 'flip_h', 2, IH, inits, suffix='_h'))
+            # Reverse axis 3 (W)
+            nodes.append(_build_slice_reverse('flip_h', 'rotated', 3, IW, inits, suffix='_w'))
+            # Pad back
+            nodes.append(_build_pad_node('rotated', 'output', pad_h, pad_w, inits))
+            
+            return mk(nodes, inits)
+        
+        elif k == 1 and IH == IW:
+            # rot90 CCW on square grid: transpose then flipud
+            # output[r,c] = input[c, IH-1-r]
+            # Step 1: Transpose [0,1,3,2]: temp[r,c] = input[c,r]
+            # Step 2: Reverse axis 2: out[r,c] = temp[IH-1-r,c] = input[c,IH-1-r] ✓
+            pad_h, pad_w = GH - IH, GW - IW
+            inits = []
+            nodes = []
+            
+            nodes.append(_build_slice_crop('input', 'cropped', IH, IW, inits))
+            nodes.append(helper.make_node('Transpose', ['cropped'], ['transposed'], perm=[0,1,3,2]))
+            nodes.append(_build_slice_reverse('transposed', 'rotated', 2, IH, inits))
+            nodes.append(_build_pad_node('rotated', 'output', pad_h, pad_w, inits))
+            
+            return mk(nodes, inits)
+        
+        elif k == 3 and IH == IW:
+            # rot270 CCW (= 90 CW) on square grid: flipud then transpose
+            # output[r,c] = input[IW-1-c, r]
+            # Step 1: Reverse axis 2: temp[r,c] = input[IH-1-r,c]
+            # Step 2: Transpose [0,1,3,2]: out[r,c] = temp[c,r] = input[IH-1-c,r] ✓ (IH=IW)
+            pad_h, pad_w = GH - IH, GW - IW
+            inits = []
+            nodes = []
+            
+            nodes.append(_build_slice_crop('input', 'cropped', IH, IW, inits))
+            nodes.append(_build_slice_reverse('cropped', 'flipped', 2, IH, inits))
+            nodes.append(helper.make_node('Transpose', ['flipped'], ['rotated'], perm=[0,1,3,2]))
+            nodes.append(_build_pad_node('rotated', 'output', pad_h, pad_w, inits))
+            
+            return mk(nodes, inits)
+        
+        else:
+            # Non-square k=1 or k=3: fall back to Gather (still correct, just higher cost)
+            idx = np.zeros((OH,OW,2), dtype=np.int64)
+            for r in range(OH):
+                for c in range(OW):
+                    if k == 1: sr, sc = c, IH-1-r
+                    elif k == 3: sr, sc = IW-1-c, r
+                    idx[r,c] = [sr, sc]
+            return _build_gather_model(OH, OW, idx)
     return None
 
 def s_spatial_gather(td):
@@ -440,10 +529,9 @@ def s_spatial_gather(td):
 def s_varshape_spatial_gather(td):
     """Spatial gather that works for variable-shape tasks by embedding in 30x30."""
     sp = fixed_shapes(td)
-    if sp is not None: return None  # fixed shapes handled by s_spatial_gather
+    if sp is not None: return None
     exs = get_exs(td)
     
-    # Embed all examples in 30x30
     exs_30 = []
     for inp, out in exs:
         ih, iw = inp.shape
@@ -495,15 +583,15 @@ def s_tile(td):
         if not np.array_equal(out, np.tile(inp, (rH, rW))): return None
     pad_h, pad_w = 30-OH, 30-OW
     inits = [
-        numpy_helper.from_array(np.array([0,0,0,0], dtype=np.int64), 'st'),
-        numpy_helper.from_array(np.array([1,10,IH,IW], dtype=np.int64), 'en'),
-        numpy_helper.from_array(np.array([1,1,rH,rW], dtype=np.int64), 'rp'),
+        _make_int64_init('st', [0,0,0,0]),
+        _make_int64_init('en', [1,10,IH,IW]),
+        _make_int64_init('rp', [1,1,rH,rW]),
     ]
     nodes = [
         helper.make_node('Slice', ['input','st','en'], ['cr']),
         helper.make_node('Tile', ['cr','rp'], ['tl']),
-        helper.make_node('Pad', ['tl'], ['output'], pads=[0,0,0,0,0,0,pad_h,pad_w], value=0.0),
     ]
+    nodes.append(_build_pad_node('tl', 'output', pad_h, pad_w, inits))
     return mk(nodes, inits)
 
 def s_upscale(td):
@@ -584,13 +672,11 @@ def s_concat_enhanced(td):
     (IH,IW),(OH,OW) = sp
     if IH == OH and IW == OW: return None
     
-    # Need block decomposition
     if OH % IH != 0 or OW % IW != 0: return None
     rH, rW = OH // IH, OW // IW
     if rH * rW > 16 or rH * rW < 2: return None
     if OH > 30 or OW > 30: return None
     
-    # All 8 symmetry transforms of the dihedral group
     transforms = [
         ('id', lambda x: x),
         ('fliplr', lambda x: np.fliplr(x)),
@@ -602,7 +688,6 @@ def s_concat_enhanced(td):
         ('T_fliplr', lambda x: np.fliplr(x.T)),
     ]
     
-    # For each block, find which transform matches
     block_transforms = {}
     for bi in range(rH):
         for bj in range(rW):
@@ -622,7 +707,6 @@ def s_concat_enhanced(td):
                 return None
             block_transforms[(bi, bj)] = found
     
-    # Build index map  
     idx = np.zeros((OH, OW, 2), dtype=np.int64)
     for bi in range(rH):
         for bj in range(rW):
@@ -640,7 +724,6 @@ def s_concat_enhanced(td):
                     elif tname == 'T_fliplr': sr, sc = IW-1-lc, lr
                     idx[oi, oj] = [sr, sc]
     
-    # Verify
     for inp, out in exs:
         reconstructed = np.zeros_like(out)
         for oi in range(OH):
@@ -672,15 +755,6 @@ def s_input_driven_tile(td):
                 else:
                     if not np.all(block == 0):
                         return None
-    
-    # Build gather model: each output pixel at (bi*IH+lr, bj*IW+lc) maps to
-    # input[lr, lc] if input[bi, bj] != 0, else constant 0
-    # Problem: whether block is active depends on input value, which varies.
-    # This needs a different ONNX approach: can't use static gather.
-    # But we CAN use: Tile input -> Mul by mask derived from input
-    # Actually we need: for each (bi,bj) block position, multiply by inp[bi,bj] != 0
-    # This is NOT static - it depends on input content.
-    # Skip for now - spatial_gather can handle if block positions are fixed.
     return None
 
 def s_kronecker(td):
@@ -699,7 +773,6 @@ def s_kronecker(td):
         if not np.array_equal(out, expected):
             return None
     
-    # This is identical to upscale - build gather index
     idx = np.zeros((OH,OW,2), dtype=np.int64)
     for r in range(OH):
         for c in range(OW):
@@ -728,7 +801,6 @@ def s_diagonal_tile(td):
                     if not np.all(block == 0):
                         return None
     
-    # Build: diagonal blocks map to input, off-diagonal are constant 0
     idx = np.zeros((OH,OW,2), dtype=np.int64)
     cst = np.full((OH,OW), -1, dtype=np.int64)
     for bi in range(rH):
@@ -765,9 +837,8 @@ def s_shift(td):
                 if not np.array_equal(shifted, out):
                     ok = False; break
             if not ok: continue
-            # Build gather index
             idx = np.zeros((OH, OW, 2), dtype=np.int64)
-            cst = np.full((OH, OW), 0, dtype=np.int64)  # zeros for out-of-bounds
+            cst = np.full((OH, OW), 0, dtype=np.int64)
             for r in range(OH):
                 for c in range(OW):
                     sr, sc = r - dr, c - dc
@@ -802,10 +873,6 @@ def s_gravity(td):
     
     for d in ('down', 'up', 'left', 'right'):
         if all(np.array_equal(_gravity(inp, d), out) for inp, out in exs):
-            # Gravity is input-dependent (positions depend on content)
-            # Can't use static Gather — need Conv to learn it
-            # But conv also can't learn arbitrary sorting...
-            # Skip for now — this needs a specialized ONNX graph
             return None
     return None
 
@@ -820,7 +887,6 @@ def s_mirror_h(td):
     for inp, out in exs:
         expected = np.concatenate([inp, np.flip(inp, 1)], 1)
         if not np.array_equal(expected, out): return None
-    # Build gather index
     idx = np.zeros((OH, OW, 2), dtype=np.int64)
     for r in range(OH):
         for c in range(OW):
@@ -984,9 +1050,7 @@ def solve_conv_fixed(td, path, time_budget=30.0):
     if len(shapes) != 1: return None
     IH, IW = shapes.pop()
     
-    # Use ARC-GEN data for better fitting
     fit_exs = get_exs_for_fitting(td)
-    # Filter to same-shape, same IH/IW
     fit_exs = [(i,o) for i,o in fit_exs if i.shape == o.shape and i.shape == (IH, IW)]
     
     t_start = time.time()
@@ -1000,8 +1064,8 @@ def solve_conv_fixed(td, path, time_budget=30.0):
             pad_h, pad_w = GH - IH, GW - IW
 
             inits = [
-                numpy_helper.from_array(np.array([0,0,0,0], dtype=np.int64), 'sl_st'),
-                numpy_helper.from_array(np.array([1,10,IH,IW], dtype=np.int64), 'sl_en'),
+                _make_int64_init('sl_st', [0,0,0,0]),
+                _make_int64_init('sl_en', [1,10,IH,IW]),
                 numpy_helper.from_array(Wconv, 'W'),
             ]
             conv_inputs = ['grid', 'W']
@@ -1015,10 +1079,7 @@ def solve_conv_fixed(td, path, time_budget=30.0):
                 helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
             ]
             add_onehot_block(nodes, inits, 'am', 'oh_out')
-            nodes.append(
-                helper.make_node('Pad', ['oh_out'], ['output'],
-                    pads=[0,0,0,0,0,0,pad_h,pad_w], value=0.0)
-            )
+            nodes.append(_build_pad_node('oh_out', 'output', pad_h, pad_w, inits))
 
             model = mk(nodes, inits)
             onnx.save(model, path)
@@ -1031,7 +1092,6 @@ def solve_conv_variable(td, path, time_budget=30.0):
     for inp, out in exs:
         if inp.shape != out.shape: return None
     
-    # Use ARC-GEN data for better fitting (variable shape, embedded in 30x30)
     fit_exs = get_exs_for_fitting_variable(td)
     fit_exs = [(i,o) for i,o in fit_exs if i.shape == o.shape]
     
@@ -1122,11 +1182,11 @@ def solve_conv_diffshape(td, path, time_budget=30.0):
                 
                 pad_h, pad_w = GH - OH, GW - OW
                 inits = [
-                    numpy_helper.from_array(np.array([0,0,0,0], dtype=np.int64), 'sl_st'),
-                    numpy_helper.from_array(np.array([1,10,IH,IW], dtype=np.int64), 'sl_en'),
+                    _make_int64_init('sl_st', [0,0,0,0]),
+                    _make_int64_init('sl_en', [1,10,IH,IW]),
                     numpy_helper.from_array(Wconv, 'W'),
-                    numpy_helper.from_array(np.array([0,0,dr_off,dc_off], dtype=np.int64), 'cr_st'),
-                    numpy_helper.from_array(np.array([1,10,dr_off+OH,dc_off+OW], dtype=np.int64), 'cr_en'),
+                    _make_int64_init('cr_st', [0,0,dr_off,dc_off]),
+                    _make_int64_init('cr_en', [1,10,dr_off+OH,dc_off+OW]),
                 ]
                 conv_inputs = ['grid', 'W']
                 if B is not None:
@@ -1140,10 +1200,7 @@ def solve_conv_diffshape(td, path, time_budget=30.0):
                     helper.make_node('ArgMax', ['co_crop'], ['am'], axis=1, keepdims=1),
                 ]
                 add_onehot_block(nodes, inits, 'am', 'oh_out')
-                nodes.append(
-                    helper.make_node('Pad', ['oh_out'], ['output'],
-                        pads=[0,0,0,0,0,0,pad_h,pad_w], value=0.0)
-                )
+                nodes.append(_build_pad_node('oh_out', 'output', pad_h, pad_w, inits))
 
                 model = mk(nodes, inits)
                 onnx.save(model, path)
@@ -1151,8 +1208,7 @@ def solve_conv_diffshape(td, path, time_budget=30.0):
     return None
 
 def solve_conv_var_diff(td, path, time_budget=30.0):
-    """Variable diff-shape conv: Conv(30x30) -> ArgMax -> Equal+Cast -> Mul(output_mask).
-    Works when output shape differs from input but mapping is convolutional on 30x30 grid."""
+    """Variable diff-shape conv: Conv(30x30) -> ArgMax -> Equal+Cast -> Mul(output_mask)."""
     exs = get_exs(td)
     
     t_start = time.time()
@@ -1200,495 +1256,214 @@ def solve_conv_var_diff(td, path, time_budget=30.0):
                 Wconv = WT.T.reshape(10, 10, ks, ks).astype(np.float32)
                 B = None
             
-            # Use ReduceSum of output channels as mask (sum across channels == 1 for valid pixels)
-            # But we don't know the output mask at inference time from input alone...
-            # We need a way to derive the output mask from the input.
-            # For same-shape: mask = ReduceSum(input, axis=1) works
-            # For diff-shape: we need to compute the output mask differently
-            # 
-            # Approach: Conv output at valid positions should have max > threshold,
-            # and at padding positions max ≈ 0. Use the ArgMax+OneHot and then
-            # mask with ReduceSum(input) which is 1 at input positions but 0 at padding.
-            # BUT output may be LARGER than input...
-            #
-            # Alternative: just use Conv -> ArgMax -> Equal+Cast -> Mul(input_mask_expanded)
-            # where input_mask covers the output region too.
-            # This won't work if output extends beyond input region.
-            #
-            # Simplest correct approach: let the conv produce valid one-hot everywhere,
-            # then the padding region should naturally produce channel-0 output.
-            # Since padding is all-zero input, conv output there = bias only.
-            # If no bias, conv output = 0 for all channels -> argmax gives channel 0 -> onehot gives [1,0,...,0]
-            # which equals the padding encoding (channel 0 = 1 in padding).
-            # Wait - that's WRONG for the NeuroGolf format. In the padding region, ALL channels should be 0.
-            # The one-hot encoding has channel[color]=1, but padding = ALL zeros.
-            #
-            # So we NEED a mask. But for diff-shape, what mask?
-            # If output is always top-left aligned and we know max output size...
-            # We can't statically determine the output mask from the input.
-            #
-            # However: we can try the ReduceSum approach anyway — if conv naturally
-            # produces channel-0 dominant output in padding, then:
-            # mask = ReduceSum(input, axis=1) gives 1 for input pixels, 0 for padding
-            # If output region ⊆ input region, this works.
-            # If output region > input region... we need the output's ReduceSum instead.
-            
             # For tasks where output fits within input bounds, use input mask
             all_output_within_input = all(
-                out_g.shape[0] <= inp_g.shape[0] and out_g.shape[1] <= inp_g.shape[1] 
+                out_g.shape[0] <= inp_g.shape[0] and out_g.shape[1] <= inp_g.shape[1]
                 for inp_g, out_g in exs
             )
             
-            if not all_output_within_input:
-                continue  # Skip tasks where output extends beyond input
-            
-            inits = [numpy_helper.from_array(Wconv, 'W')]
-            conv_inputs = ['input', 'W']
-            if B is not None:
-                inits.append(numpy_helper.from_array(B, 'B'))
-                conv_inputs.append('B')
-
-            nodes = [
-                helper.make_node('ReduceSum', ['input'], ['mask'], axes=[1], keepdims=1),
-                helper.make_node('Conv', conv_inputs, ['co'], kernel_shape=[ks,ks], pads=[pad]*4),
-                helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
-            ]
-            add_onehot_block(nodes, inits, 'am', 'oh_out')
-            nodes.append(helper.make_node('Mul', ['oh_out', 'mask'], ['output']))
-
-            model = mk(nodes, inits)
-            onnx.save(model, path)
-            if validate(path, td): return 'conv_var_diff', model
-    return None
-
-# ============================================================
-# PYTORCH LEARNED CONV (gradient descent, multi-seed, ternary snap)
-# ============================================================
-
-def _ternary_snap(w, eps=0.2):
-    """Snap weights to {-1, 0, 1} — smaller model, often still correct."""
-    return np.where(w > eps, 1.0, np.where(w < -eps, -1.0, 0.0)).astype(np.float32)
-
-def _build_conv_onnx_from_weights(W, ks, use_full_30=False, IH=None, IW=None):
-    """Build ONNX conv model from numpy weight array W [10,10,ks,ks].
-    For fixed-shape: Slice→Conv→ArgMax→Equal+Cast→Pad
-    For variable/full30: Conv→ArgMax→Equal+Cast→Mul(mask)"""
-    pad = ks // 2
-    if use_full_30:
-        # Variable shape: full 30x30 conv with mask
-        inits = [numpy_helper.from_array(W, 'W')]
-        nodes = [
-            helper.make_node('ReduceSum', ['input'], ['mask'], axes=[1], keepdims=1),
-            helper.make_node('Conv', ['input', 'W'], ['co'], kernel_shape=[ks,ks], pads=[pad]*4),
-            helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
-        ]
-        add_onehot_block(nodes, inits, 'am', 'oh_out')
-        nodes.append(helper.make_node('Mul', ['oh_out', 'mask'], ['output']))
-        return mk(nodes, inits)
-    else:
-        # Fixed shape: slice, conv, pad
-        pad_h, pad_w = GH - IH, GW - IW
-        inits = [
-            numpy_helper.from_array(np.array([0,0,0,0], dtype=np.int64), 'sl_st'),
-            numpy_helper.from_array(np.array([1,10,IH,IW], dtype=np.int64), 'sl_en'),
-            numpy_helper.from_array(W, 'W'),
-        ]
-        nodes = [
-            helper.make_node('Slice', ['input','sl_st','sl_en'], ['grid']),
-            helper.make_node('Conv', ['grid', 'W'], ['co'], kernel_shape=[ks,ks], pads=[pad]*4),
-            helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
-        ]
-        add_onehot_block(nodes, inits, 'am', 'oh_out')
-        nodes.append(
-            helper.make_node('Pad', ['oh_out'], ['output'],
-                pads=[0,0,0,0,0,0,pad_h,pad_w], value=0.0)
-        )
-        return mk(nodes, inits)
-
-def _build_two_layer_conv_onnx(W1, W2, ks1, ks2, use_full_30=False, IH=None, IW=None):
-    """Build ONNX two-layer conv: Conv→ReLU→Conv→ArgMax→Equal+Cast→Pad/Mul(mask)."""
-    pad1, pad2 = ks1 // 2, ks2 // 2
-    if use_full_30:
-        inits = [
-            numpy_helper.from_array(W1, 'W1'),
-            numpy_helper.from_array(W2, 'W2'),
-        ]
-        nodes = [
-            helper.make_node('ReduceSum', ['input'], ['mask'], axes=[1], keepdims=1),
-            helper.make_node('Conv', ['input', 'W1'], ['h1'], kernel_shape=[ks1,ks1], pads=[pad1]*4),
-            helper.make_node('Relu', ['h1'], ['h1r']),
-            helper.make_node('Conv', ['h1r', 'W2'], ['co'], kernel_shape=[ks2,ks2], pads=[pad2]*4),
-            helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
-        ]
-        add_onehot_block(nodes, inits, 'am', 'oh_out')
-        nodes.append(helper.make_node('Mul', ['oh_out', 'mask'], ['output']))
-        return mk(nodes, inits)
-    else:
-        pad_h, pad_w = GH - IH, GW - IW
-        inits = [
-            numpy_helper.from_array(np.array([0,0,0,0], dtype=np.int64), 'sl_st'),
-            numpy_helper.from_array(np.array([1,10,IH,IW], dtype=np.int64), 'sl_en'),
-            numpy_helper.from_array(W1, 'W1'),
-            numpy_helper.from_array(W2, 'W2'),
-        ]
-        nodes = [
-            helper.make_node('Slice', ['input','sl_st','sl_en'], ['grid']),
-            helper.make_node('Conv', ['grid', 'W1'], ['h1'], kernel_shape=[ks1,ks1], pads=[pad1]*4),
-            helper.make_node('Relu', ['h1'], ['h1r']),
-            helper.make_node('Conv', ['h1r', 'W2'], ['co'], kernel_shape=[ks2,ks2], pads=[pad2]*4),
-            helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
-        ]
-        add_onehot_block(nodes, inits, 'am', 'oh_out')
-        nodes.append(
-            helper.make_node('Pad', ['oh_out'], ['output'],
-                pads=[0,0,0,0,0,0,pad_h,pad_w], value=0.0)
-        )
-        return mk(nodes, inits)
-
-def solve_pytorch_conv(td, path, time_budget=30.0):
-    """PyTorch gradient descent conv solver. Tries single-layer then two-layer.
-    Multi-seed training with ternary weight snapping for smaller models.
-    Validates against arc-gen before accepting."""
-    try:
-        import torch
-        import torch.nn as nn
-        import copy as _copy
-    except ImportError:
-        return None
-    
-    exs = get_exs(td)
-    same_shape = all(inp.shape == out.shape for inp, out in exs)
-    if not same_shape:
-        return None  # Only handle same-shape for now
-    
-    shapes = set(inp.shape for inp, _ in exs)
-    fixed_in = len(shapes) == 1
-    
-    # Prepare tensors
-    all_pairs = td['train'] + td['test']
-    inp_list = [to_onehot(p['input'])[0] for p in all_pairs]
-    out_list = [to_onehot(p['output'])[0] for p in all_pairs]
-    inp_t = torch.tensor(np.stack(inp_list), dtype=torch.float32)
-    out_t = torch.tensor(np.stack(out_list), dtype=torch.float32)
-    
-    if fixed_in:
-        IH, IW = list(shapes)[0]
-        # Train on cropped region
-        inp_t = inp_t[:, :, :IH, :IW]
-        out_t = out_t[:, :, :IH, :IW]
-    
-    t_start = time.time()
-    best_result = None
-    
-    # Phase 1: Single-layer conv (multiple kernel sizes and seeds)
-    for ks in [1, 3, 5, 7]:
-        if time.time() - t_start > time_budget * 0.6:
-            break
-        pad = ks // 2
-        for seed in [0, 7, 42]:
-            if time.time() - t_start > time_budget * 0.6:
-                break
-            torch.manual_seed(seed)
-            conv = nn.Conv2d(CH, CH, kernel_size=ks, padding=pad, bias=False)
-            if seed == 0:
-                nn.init.zeros_(conv.weight)
-            opt = torch.optim.Adam(conv.parameters(), lr=0.03)
-            best_loss, best_state = float('inf'), None
-            for step in range(3000):
-                opt.zero_grad()
-                pred = conv(inp_t)
-                loss = nn.functional.mse_loss(pred, out_t)
-                loss.backward()
-                opt.step()
-                if loss.item() < best_loss:
-                    best_loss = loss.item()
-                    best_state = _copy.deepcopy(conv.state_dict())
-                if best_loss < 1e-8:
-                    break
-            if best_state is None:
-                continue
-            conv.load_state_dict(best_state)
-            w = conv.weight.detach().numpy()
-            
-            # Try continuous weights, then ternary-snapped
-            for w_cand in [w, _ternary_snap(w)]:
-                use_full = not fixed_in
-                model = _build_conv_onnx_from_weights(
-                    w_cand, ks, use_full_30=use_full,
-                    IH=IH if fixed_in else None,
-                    IW=IW if fixed_in else None
-                )
-                onnx.save(model, path)
-                if validate(path, td):
-                    sz = os.path.getsize(path)
-                    if best_result is None or sz < best_result[2]:
-                        best_result = ('pt_conv', model, sz)
-    
-    # Phase 2: Two-layer conv (Conv→ReLU→Conv)
-    for ks1, ks2, hidden in [(3, 1, CH), (5, 1, CH), (3, 3, CH)]:
-        if time.time() - t_start > time_budget:
-            break
-        for seed in [0, 7]:
-            if time.time() - t_start > time_budget:
-                break
-            torch.manual_seed(seed)
-            net = nn.Sequential(
-                nn.Conv2d(CH, hidden, kernel_size=ks1, padding=ks1//2, bias=False),
-                nn.ReLU(),
-                nn.Conv2d(hidden, CH, kernel_size=ks2, padding=ks2//2, bias=False),
-            )
-            opt = torch.optim.Adam(net.parameters(), lr=0.01)
-            best_loss, best_state = float('inf'), None
-            for step in range(2500):
-                opt.zero_grad()
-                pred = net(inp_t)
-                loss = nn.functional.mse_loss(pred, out_t)
-                loss.backward()
-                opt.step()
-                if loss.item() < best_loss:
-                    best_loss = loss.item()
-                    best_state = _copy.deepcopy(net.state_dict())
-                if best_loss < 1e-8:
-                    break
-            if best_state is None:
-                continue
-            net.load_state_dict(best_state)
-            w1 = net[0].weight.detach().numpy()
-            w2 = net[2].weight.detach().numpy()
-            
-            for w1c, w2c in [(w1, w2), (_ternary_snap(w1), _ternary_snap(w2))]:
-                use_full = not fixed_in
-                model = _build_two_layer_conv_onnx(
-                    w1c, w2c, ks1, ks2, use_full_30=use_full,
-                    IH=IH if fixed_in else None,
-                    IW=IW if fixed_in else None
-                )
+            if all_output_within_input:
+                inits = [numpy_helper.from_array(Wconv, 'W')]
+                conv_inputs = ['input', 'W']
+                if B is not None:
+                    inits.append(numpy_helper.from_array(B, 'B'))
+                    conv_inputs.append('B')
+                
+                nodes = [
+                    helper.make_node('ReduceSum', ['input'], ['mask'], axes=[1], keepdims=1),
+                    helper.make_node('Conv', conv_inputs, ['co'], kernel_shape=[ks,ks], pads=[pad]*4),
+                    helper.make_node('ArgMax', ['co'], ['am'], axis=1, keepdims=1),
+                ]
+                add_onehot_block(nodes, inits, 'am', 'oh_out')
+                nodes.append(helper.make_node('Mul', ['oh_out', 'mask'], ['output']))
+                
+                model = mk(nodes, inits)
                 onnx.save(model, path)
-                if validate(path, td):
-                    sz = os.path.getsize(path)
-                    if best_result is None or sz < best_result[2]:
-                        best_result = ('pt_conv2', model, sz)
-    
-    if best_result is not None:
-        sname, model, _ = best_result
-        onnx.save(model, path)
-        return sname, model
+                if validate(path, td): return 'conv_var_diff', model
     return None
 
 # ============================================================
-# MAIN
+# MAIN SOLVER
 # ============================================================
 
 ANALYTICAL_SOLVERS = [
-    ('identity', s_identity), ('constant', s_constant), ('color_map', s_color_map),
-    ('transpose', s_transpose), ('flip', s_flip), ('rotate', s_rotate),
-    ('tile', s_tile), ('upscale', s_upscale), ('kronecker', s_kronecker),
+    ('identity', s_identity),
+    ('constant', s_constant),
+    ('color_map', s_color_map),
+    ('transpose', s_transpose),
+    ('flip', s_flip),
+    ('rotate', s_rotate),
+    ('shift', s_shift),
+    ('tile', s_tile),
+    ('upscale', s_upscale),
+    ('kronecker', s_kronecker),
     ('nonuniform_scale', s_nonuniform_scale),
-    ('mirror_h', s_mirror_h), ('mirror_v', s_mirror_v), ('quad_mirror', s_quad_mirror),
-    ('concat', s_concat), ('concat_enhanced', s_concat_enhanced),
+    ('mirror_h', s_mirror_h),
+    ('mirror_v', s_mirror_v),
+    ('quad_mirror', s_quad_mirror),
+    ('concat', s_concat),
+    ('concat_enhanced', s_concat_enhanced),
     ('diagonal_tile', s_diagonal_tile),
     ('fixed_crop', s_fixed_crop),
     ('spatial_gather', s_spatial_gather),
-    ('shift', s_shift),
     ('varshape_spatial_gather', s_varshape_spatial_gather),
 ]
 
-def solve_task(tn, td, outdir, conv_budget=30.0):
-    t_start = time.time()
-    os.makedirs(outdir, exist_ok=True)
-    path = os.path.join(outdir, f"task{tn:03d}.onnx")
-    
-    # Skip excluded tasks
-    if tn in EXCLUDED_TASKS:
-        return False, 'excluded', None, time.time() - t_start, path
+def solve_task(tn, td, output_dir, conv_budget=30.0, verbose=True):
+    """Try all solvers on a task. Returns (solver_name, score) or None."""
+    path = os.path.join(output_dir, f"task{tn:03d}.onnx")
     
-    # 1. Try analytical solvers (fast, tiny models)
-    for sname, sfn in ANALYTICAL_SOLVERS:
+    # Try analytical solvers first (instant, arc-gen safe)
+    for name, solver in ANALYTICAL_SOLVERS:
         try:
-            model = sfn(td)
-            if model is None: continue
+            model = solver(td)
+        except Exception as e:
+            if verbose: print(f"  {name}: ERROR {e}")
+            continue
+        if model is not None:
             onnx.save(model, path)
-            if validate(path, td): 
-                return True, sname, os.path.getsize(path), time.time() - t_start, path
-        except: pass
-    
-    # 2. Determine task shape category and try conv solvers
-    exs = get_exs(td)
-    same_shape = all(inp.shape == out.shape for inp, out in exs)
-    shapes = set(inp.shape for inp, _ in exs)
-    fixed_in = len(shapes) == 1
-    
-    conv_time = conv_budget
-    
-    if same_shape:
-        if fixed_in:
-            result = solve_conv_fixed(td, path, time_budget=conv_time/2)
-            if result is not None:
-                sname, model = result
-                return True, sname, os.path.getsize(path), time.time() - t_start, path
-        result = solve_conv_variable(td, path, time_budget=conv_time)
-        if result is not None:
-            sname, model = result
-            return True, sname, os.path.getsize(path), time.time() - t_start, path
-        # 3. PyTorch learned conv as fallback for same-shape tasks
-        remaining = max(1, conv_time - (time.time() - t_start))
-        result = solve_pytorch_conv(td, path, time_budget=remaining)
-        if result is not None:
-            sname, model = result
-            return True, sname, os.path.getsize(path), time.time() - t_start, path
-    else:
-        sp = fixed_shapes(td)
-        if sp is not None:
-            (IH,IW),(OH,OW) = sp
-            if OH <= IH and OW <= IW:
-                result = solve_conv_diffshape(td, path, time_budget=conv_time)
-                if result is not None:
-                    sname, model = result
-                    return True, sname, os.path.getsize(path), time.time() - t_start, path
-        
-        # Try variable diff-shape conv (output within input bounds)
-        result = solve_conv_var_diff(td, path, time_budget=conv_time)
+            if validate(path, td):
+                macs, mem, par = score_network(path)
+                if macs is not None:
+                    cost = macs + mem + par
+                    score = max(1.0, 25.0 - math.log(cost)) if cost > 0 else 25.0
+                    if verbose: print(f"  {name}: PASS  cost={cost}  score={score:.2f}")
+                    return name, score
+            else:
+                if verbose: print(f"  {name}: model built but FAILED validation")
+    
+    # Try conv solvers
+    conv_solvers = [
+        ('conv_fixed', solve_conv_fixed),
+        ('conv_variable', solve_conv_variable),
+        ('conv_diffshape', solve_conv_diffshape),
+        ('conv_var_diff', solve_conv_var_diff),
+    ]
+    for name, solver in conv_solvers:
+        try:
+            result = solver(td, path, time_budget=conv_budget)
+        except Exception as e:
+            if verbose: print(f"  {name}: ERROR {e}")
+            continue
         if result is not None:
-            sname, model = result
-            return True, sname, os.path.getsize(path), time.time() - t_start, path
+            solver_type, model = result
+            onnx.save(model, path)
+            macs, mem, par = score_network(path)
+            if macs is not None:
+                cost = macs + mem + par
+                score = max(1.0, 25.0 - math.log(cost)) if cost > 0 else 25.0
+                if verbose: print(f"  {solver_type}: PASS  cost={cost}  score={score:.2f}")
+                return solver_type, score
     
-    return False, None, None, time.time() - t_start, path
-
-def run_tasks(task_nums, tasks, output_dir, conv_budget, use_wandb):
-    results = {}
-    costs_dict = {}
-    total_score = 0
-    for tn in task_nums:
-        if tn not in tasks:
-            continue
-        if tn in EXCLUDED_TASKS:
-            print(f"Task {tn:3d}: EXCLUDED (officially)")
-            continue
-
-        td = tasks[tn]['data']
-        ok, sname, sz, t_task, model_path = solve_task(tn, td, output_dir, conv_budget)
-
-        if ok:
-            macs, memory, params = score_network(model_path)
-            if macs is None:
-                macs, memory, params = 0, 0, 0
-            cost = macs + memory + params
-            score = max(1.0, 25.0 - math.log(max(1, cost)))
-            total_score += score
-
-            results[tn] = (sname, t_task, sz)
-            costs_dict[tn] = cost
-            print(f"Task {tn:3d}: {sname:25s} {score:7.3f} {cost:>12} {t_task:7.3f}s  ({sz:>8,} bytes)")
-        else:
-            print(f"Task {tn:3d}: UNSOLVED  {t_task:7.3f}s")
-            cost = 0
-
-        if use_wandb and wandb is not None:
-            wandb.log({
-                "task_id": tn,
-                "solver": sname if ok else "unsolved",
-                "onnx_bytes": sz if ok else 0,
-                "task_time_sec": t_task,
-                "cost": cost,
-                "score": score if ok else 0,
-            })
-
-    return results, costs_dict, total_score
-
+    return None
 
 def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--data_dir', default='ARC-AGI/data/training/')
-    parser.add_argument('--arcgen_dir', default='', help='Path to ARC-GEN-100K/ directory')
-    parser.add_argument('--output_dir', default='submission')
-    parser.add_argument('--kaggle', action='store_true')
-    parser.add_argument('--conv_budget', type=float, default=30.0)
-    parser.add_argument('--tasks', type=str, default='')
-    parser.add_argument('--device', type=str, default='auto', choices=['auto','cpu','cuda'])
-    parser.add_argument('--use_wandb', action='store_true')
+    parser = argparse.ArgumentParser(description='NeuroGolf Solver v5')
+    parser.add_argument('--data_dir', type=str, default=None, help='Path to ARC-AGI training data')
+    parser.add_argument('--kaggle_dir', type=str, default=None, help='Path to Kaggle task JSONs')
+    parser.add_argument('--arcgen_dir', type=str, default=None, help='Path to ARC-GEN data directory')
+    parser.add_argument('--output_dir', type=str, default='submission', help='Output directory for ONNX models')
+    parser.add_argument('--conv_budget', type=float, default=30.0, help='Time budget per conv solver per task (seconds)')
+    parser.add_argument('--task', type=int, default=None, help='Solve a single task number')
+    parser.add_argument('--verbose', action='store_true', default=True)
+    parser.add_argument('--quiet', action='store_true', default=False)
     args = parser.parse_args()
-    global ORT_PROVIDERS
-    config = {
-        "device": args.device,
-        "conv_budget": args.conv_budget,
-        "data_dir": args.data_dir,
-        "arcgen_dir": args.arcgen_dir,
-        "tasks": args.tasks,
-    }
- 
-    if args.device == 'cuda':
-        ORT_PROVIDERS = ['CUDAExecutionProvider', 'CPUExecutionProvider']
-    elif args.device == 'cpu':
-        ORT_PROVIDERS = ['CPUExecutionProvider']
-    
-    ort.set_default_logger_severity(3)
-    print(f"Using providers: {ORT_PROVIDERS}")
-    
-    if args.kaggle:
-        tasks = load_tasks_kaggle(args.data_dir)
-    else:
-        arcgen = args.arcgen_dir if args.arcgen_dir else None
-        tasks = load_tasks_dir(args.data_dir, arcgen_dir=arcgen)
     
-    # Count arc-gen examples
-    total_arcgen = sum(len(t['data'].get('arc-gen', [])) for t in tasks.values())
-    print(f"Loaded {len(tasks)} tasks ({total_arcgen} ARC-GEN examples)")
-    print(f"Excluded tasks: {sorted(EXCLUDED_TASKS)}")
+    if args.quiet:
+        args.verbose = False
     
-    task_nums = [int(t) for t in args.tasks.split(',')] if args.tasks else sorted(tasks.keys())
-    active_tasks = [t for t in task_nums if t not in EXCLUDED_TASKS]
-    print(f"Solving {len(active_tasks)} active tasks (skipping {len(task_nums) - len(active_tasks)} excluded)")
-    print(f"Conv budget: {args.conv_budget}s per task")
-    print("=" * 70)
-    t0 = time.time()
+    os.makedirs(args.output_dir, exist_ok=True)
     
-    if args.use_wandb and wandb is not None:
-        with wandb.init(project="neurogolf", name="solver_run", config=config):
-            results, costs_dict, total_score = run_tasks(task_nums, tasks, args.output_dir, args.conv_budget, use_wandb=True)
+    # Load tasks
+    if args.kaggle_dir:
+        tasks = load_tasks_kaggle(args.kaggle_dir)
+    elif args.data_dir:
+        tasks = load_tasks_dir(args.data_dir, args.arcgen_dir)
     else:
-        results, costs_dict, total_score = run_tasks(task_nums, tasks, args.output_dir, args.conv_budget, use_wandb=False)
-
-    elapsed = time.time() - t0
-    print(f"\n{'='*70}")
-    print(f"Solved: {len(results)}/{len(active_tasks)} active tasks in {elapsed:.0f}s")
-    solver_names = [v[0] for v in results.values()]
-    sc = Counter(solver_names)
-    for s, c in sc.most_common(): print(f"  {s}: {c}")
+        # Try common paths
+        for p in ['/kaggle/input/competitions/neurogolf-2026/',
+                  'ARC-AGI/data/training/']:
+            if os.path.exists(p):
+                if 'kaggle' in p:
+                    tasks = load_tasks_kaggle(p)
+                else:
+                    tasks = load_tasks_dir(p, args.arcgen_dir)
+                break
+        else:
+            print("ERROR: No data directory found. Use --data_dir or --kaggle_dir")
+            sys.exit(1)
     
-    # Generate submission
-    outdir = args.output_dir
-    n_files = len([f for f in os.listdir(outdir) if f.endswith('.onnx')])
-    total_size = sum(os.path.getsize(os.path.join(outdir, f))
-                     for f in os.listdir(outdir) if f.endswith('.onnx'))
+    # Solve tasks
+    results = {}
+    total_score = 0.0
+    solved = 0
+    t_total = time.time()
     
-    # Create submission.zip
-    zip_path = os.path.join(os.path.dirname(outdir) or '.', 'submission.zip')
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
-        for f in sorted(os.listdir(outdir)):
-            if f.endswith('.onnx'):
-                zf.write(os.path.join(outdir, f), f)
-    zip_bytes = buf.getvalue()
-    with open(zip_path, 'wb') as f:
-        f.write(zip_bytes)
-    zip_size = len(zip_bytes)
+    task_nums = [args.task] if args.task else sorted(tasks.keys())
     
-    # Create submission.csv
-    csv_path = os.path.join(os.path.dirname(outdir) or '.', 'submission.csv')
+    for tn in task_nums:
+        if tn in EXCLUDED_TASKS:
+            if args.verbose: print(f"Task {tn:3d}: EXCLUDED")
+            continue
+        if tn not in tasks:
+            if args.verbose: print(f"Task {tn:3d}: NOT FOUND")
+            continue
+        
+        td = tasks[tn]['data']
+        hex_id = tasks[tn]['hex']
+        
+        if args.verbose: print(f"\nTask {tn:3d} ({hex_id}):")
+        
+        result = solve_task(tn, td, args.output_dir, args.conv_budget, args.verbose)
+        
+        if result is not None:
+            solver_type, score = result
+            results[tn] = {'solver': solver_type, 'score': score, 'hex': hex_id}
+            total_score += score
+            solved += 1
+        else:
+            # Unsolved tasks score 1.0 (minimum)
+            total_score += 1.0
+            if args.verbose: print(f"  UNSOLVED")
+    
+    # Summary
+    elapsed = time.time() - t_total
+    print(f"\n{'='*60}")
+    print(f"RESULTS: {solved}/{len(task_nums)} tasks solved")
+    print(f"Total score: {total_score:.1f}")
+    print(f"Time: {elapsed:.1f}s")
+    print(f"{'='*60}")
+    
+    # Breakdown by solver type
+    solver_counts = Counter(r['solver'] for r in results.values())
+    solver_scores = {}
+    for tn, r in results.items():
+        st = r['solver']
+        solver_scores[st] = solver_scores.get(st, 0) + r['score']
+    
+    print("\nSolver breakdown:")
+    for st in sorted(solver_counts.keys()):
+        print(f"  {st}: {solver_counts[st]} tasks, total score {solver_scores[st]:.1f}, avg {solver_scores[st]/solver_counts[st]:.2f}")
+    
+    # Generate submission.csv
+    csv_path = os.path.join(args.output_dir, 'submission.csv')
     with open(csv_path, 'w', newline='') as f:
         w = csv.writer(f)
-        w.writerow(['task_id', 'total_cost'])
-        for tn in sorted(costs_dict.keys()):
-            w.writerow([f'task{tn:03d}', costs_dict[tn]])
-    
-    # Estimate LB score: solved tasks get their score, unsolved get 1.0
-    unsolved_count = len(active_tasks) - len(results)
-    est_lb = total_score + unsolved_count * 1.0
-    
-    print(f"\n{n_files} ONNX files, {total_size/1024:.1f} KB uncompressed")
-    print(f"ZIP size: {zip_size/1024:.1f} KB / {MAX_FILESIZE/1024:.0f} KB limit {'OK' if zip_size <= MAX_FILESIZE else 'OVER!'}")
-    print(f"Estimated LB score: {est_lb:.1f} (solved: {total_score:.1f} + unsolved: {unsolved_count}×1.0)")
-    print(f"Written: {zip_path} | {csv_path}")
+        w.writerow(['task_num', 'hex_id', 'solver', 'score', 'onnx_file'])
+        for tn in sorted(results.keys()):
+            r = results[tn]
+            w.writerow([tn, r['hex'], r['solver'], f"{r['score']:.3f}", f"task{tn:03d}.onnx"])
+    
+    # Generate submission.zip
+    zip_path = os.path.join(args.output_dir, 'submission.zip')
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+        for tn in sorted(results.keys()):
+            onnx_path = os.path.join(args.output_dir, f"task{tn:03d}.onnx")
+            if os.path.exists(onnx_path):
+                zf.write(onnx_path, f"task{tn:03d}.onnx")
+    
+    print(f"\nSubmission files: {csv_path}, {zip_path}")
+    print(f"Models in zip: {len(results)}")
 
 if __name__ == '__main__':
-    main()
+    main()