{"approach": "Dispatcher at first step on the start file's spread rule max(1,(ca-cb+1)//2): spread 1 -> c1-pairs block class, spread 2 -> c2-queue block class (each block file's own top-level code kept, colliding names suffixed _1/_2, identical helpers shared), spreads 3/4 -> start file with a3-ledger and c4-all lines added under self.s guards. Fixes a3-rich, a3-free, a4-rich, a4-free, a4-stock carried onto it under their guards; all kept. Indentation reduced to 1 space/level to fit size (AST proven identical).", "blocked": null, "base_mean_edge": null, "exact": {"spread1": {"runs": 30, "identical": true}, "spread2": {"runs": 30, "identical": true}, "spread3": {"runs": 30, "identical": true}, "spread4": {"runs": 30, "identical": true}}, "fixes": [{"name": "a3-rich", "kept": true, "gain": 0.8334181773983345, "standard_error": 0.25588320751442933}, {"name": "a3-free", "kept": true, "gain": 0.17271267671833232, "standard_error": 0.3251756280361294}, {"name": "a4-rich", "kept": true, "gain": 0.38517936668833586, "standard_error": 0.14609271528377196}, {"name": "a4-free", "kept": true, "gain": 0.6258003894733333, "standard_error": 0.3207823409434335}, {"name": "a4-stock", "kept": true, "gain": 0.4463098442333328, "standard_error": 0.2447708962752243}, {"name": "a1-jumps", "kept": false, "gain": null, "standard_error": null}, {"name": "a1-free", "kept": false, "gain": null, "standard_error": null}, {"name": "a2-after", "kept": false, "gain": null, "standard_error": null}, {"name": "a2-ledger", "kept": false, "gain": null, "standard_error": null}], "by_spread": {"spread1": {"runs": 43, "mean": 6.598859834299999, "standard_error": 4.055074254964557, "retail": 5.725346243925583, "arb": 0.8735135903418605}, "spread2": {"runs": 31, "mean": -0.8770969421709667, "standard_error": 1.686404881540754, "retail": 1.1638107733387089, "arb": -2.0409077154870965}, "spread3": {"runs": 28, "mean": 1.1220349091964241, "standard_error": 0.8654988375657654, "retail": -1.2141622702500008, "arb": 2.336197179435714}, "spread4": {"runs": 38, "mean": 0.28620535582368517, "standard_error": 1.7948490793683292, "retail": 0.5231070907605265, "arb": -0.2369017348815793}}, "holdout": {"mean_edge": 89.19867549086285, "retail_edge": 120.57814024763785, "arb_edge": -31.37946475679786, "failures": 0}, "diff": {"mean": 2.1346696331885706, "standard_error": 1.410839002179575, "retail": 1.915353916744286, "arb": 0.21931571645214276}, "seconds": {"start": 241.93915333066667, "yours": 251.27556937081474}, "code": "\"\"\"Crossing-cover base with isolated, untuned per-spread overrides stacked: each acts only in runs of its own competitor spread.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\nP = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n   qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05,\n   ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n   fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0,\n   ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0,\n   ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\ndef cdf(x): return 0.5 * (1.0 + math.erf(x / SQ2))\ndef pdf(x): return math.exp(-0.5 * x * x) / SQ2PI\ndef inv(p):\n p = min(max(p, 1e-9), 1 - 1e-9)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n  d = pdf(x)\n  if d < 1e-12:\n   break\n  x -= (cdf(x) - p) / d\n return x\ndef lpm(k):\n return pdf(k) + k * cdf(k)\ndef fl(q):\n return math.floor(q * 100 + 1e-9) / 100\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\nclass Strategy_0(BaseStrategy):\n def __init__(self):\n  self.n = 0\n  self.ahead = set()\n  self.res = {}\n  self.bc = None\n  self.bw = None\n  self.st = 0.5\n  self.pcb = self.pca = None\n  self.pb = set()\n  self.pa = set()\n  self.tb = 0\n  self.s = None\n  self.flow_notional = 0.0\n  self.flow_exposure = 0\n  self.last_ask_tick = None\n  self.last_quote_exposed = False\n  self.last_flow_ca = None\n  self.last_flow_cap = 0.0\n  self.last_flow_correction = 1.0\n  self.params = P.copy()\n def _oid(self, tag):\n  self.n += 1\n  return tag + str(self.n)\n def on_step(self, state):\n  H = max(1, state.steps_remaining)\n  cb = state.competitor_best_bid_ticks or 0\n  ca = state.competitor_best_ask_ticks or 100\n  if self.s is None:\n   self.s = max(1, (ca - cb + 1) // 2)\n   if self.s == 4:\n    self.params['kLb'] = self.params['kLf'] = self.params['kL']\n    self.f4_exposure = [0, 0]\n    self.f4_events = [0, 0]\n    self.f4_weights = [[0.0] * 9, [0.0] * 9]\n    self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n    self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n    self.f4_last = [None, None]\n    self.f4_rate = 0.1265\n    self.f4_mean = 4.488\n    self.f4_flow = self.f4_rate * self.f4_mean\n    self.f4_extreme = inv(1 - 1e-6)\n   if self.s == 2:\n    self.params.update(dict(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\n   if self.s == 1:\n    self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n   if self.s == 3:\n    self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n  P = self.params\n  if self.s == 4:\n   for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n    last = self.f4_last[side]\n    if last is None:\n     continue\n    tick, conv, cap, old_bound, ids = last\n    if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n     continue\n    remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n    value = max(0.0, cap - remaining * conv)\n    self.f4_exposure[side] += 1\n    if value > 0.01:\n     self.f4_events[side] += 1\n     censored = remaining < 0.011\n     logv = math.log(max(value, 0.01))\n     weights = self.f4_weights[side]\n     for i, mu4 in enumerate(self.f4_mu):\n      z4 = (logv - mu4) / 1.2\n      weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n   if state.step % 25 == 0:\n    exposure = sum(self.f4_exposure)\n    events = sum(self.f4_events)\n    event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n    self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n    weights = [a + b for a, b in zip(*self.f4_weights)]\n    peak = max(weights)\n    weights = [math.exp(w - peak) for w in weights]\n    self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n    self.f4_flow = self.f4_rate * self.f4_mean\n  if self.s == 3 and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n   self.flow_exposure += 1\n   self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n  lo, hi = cb, ca\n  for o in state.own_orders:\n   if o.side is Side.BUY:\n    lo = max(lo, o.price_ticks)\n   else:\n    hi = min(hi, o.price_ticks)\n  if P['pinf'] > 0:\n   sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n   sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n   ea = self.pa - sa\n   eb = self.pb - sb\n   if sa and ea:\n    lo = max(lo, min(max(ea), hi))\n   if eb and (sb or min(eb) <= P['p1t']):\n    hi = min(hi, max(min(eb), lo))\n  if P['jumpinfo'] > 0 and self.pcb is not None:\n   if ca > self.pca + 1:\n    lo = max(lo, ca - 1)\n   if cb < self.pcb - 1:\n    hi = min(hi, cb + 1)\n  self.pcb, self.pca = cb, ca\n  if lo > hi:\n   lo, hi = hi, lo\n  wid = max(hi - lo, 1e-6)\n  nb = max(2, min(48, int(round(wid * P['bins']))))\n  cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n  if self.bc is None or P['filt'] <= 0:\n   ws = [1.0 / nb] * nb\n  else:\n   sg = max(self.st, 0.6 * wid / nb)\n   k = -0.5 / (sg * sg)\n   ws = []\n   uni = P['uni'] * sg\n   if self.s == 4:\n    exp = math.exp\n    if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n     kernel = []\n     c0 = cs[0]\n     for ci in self.bc:\n      d = c0 - ci\n      d2 = d * d * k\n      kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n     kernel = kernel[:0:-1] + kernel\n     for i in range(nb):\n      t = uni\n      start = nb - 1 - i\n      for wi, e in zip(self.bw, kernel[start:start + nb]):\n       if e:\n        t += wi * e\n      ws.append(t)\n    else:\n     previous = tuple(zip(self.bc, self.bw))\n     for c in cs:\n      t = uni\n      for ci, wi in previous:\n       d = c - ci\n       d2 = d * d * k\n       if d2 > -12.5:\n        t += wi * exp(d2)\n      ws.append(t)\n   else:\n    for c in cs:\n     t = uni\n     for ci, wi in zip(self.bc, self.bw):\n      d = c - ci\n      d2 = d * d * k\n      if d2 > -12.5:\n       t += wi * math.exp(d2)\n     ws.append(t)\n   tot = sum(ws)\n   ws = [w / tot for w in ws]\n  self.bc, self.bw = cs, ws\n  mean_t = sum(c * w for c, w in zip(cs, ws))\n  var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n  phat = min(max(mean_t / 100.0, 0.002), 0.998)\n  var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n  sd = math.sqrt(H * var)\n  self.tb = self.tb + 1 if hi <= 1 else 0\n  if self.tb > 0 and P['zd'] > 0:\n   phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n  z = inv(phat)\n  Z = z * sd\n  sp = pdf(z) / sd * P['sig']\n  self.st = sp * 100.0\n  s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n  sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n  jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n  lj = P['lam_j']\n  def AB(x):\n   k = (x - phat) / s\n   a = s * lpm(k)\n   b = a - (x - phat)\n   if self.s == 4:\n    ja = jb = 0.0\n    for p, w in jp:\n     if x > p:\n      ja += w * (x - p)\n     else:\n      jb += w * (p - x)\n   else:\n    ja = sum(w * max(0.0, x - p) for p, w in jp)\n    jb = sum(w * max(0.0, p - x) for p, w in jp)\n   return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n  if H == 1:\n   def AB(x):\n    return (1 - phat) * x, phat * (1 - x)\n  rho = P['lam_r'] * 0.5\n  mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n  kA = P['kL'] if phat < P['pL'] else P['kA']\n  def qsize(loss, gain, px):\n   loss *= kA\n   if gain <= 0:\n    return 0.0\n   tail = loss / (rho * gain)\n   if tail >= 1.0:\n    return 0.0\n   if self.s == 4 and tail <= 1e-6:\n    return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\n   return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n  ptk = phat * 100\n  def qbid(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   if self.s == 4 and phat * 100 - t < P['dmin']:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if phat * 100 - t < P['dmin']:\n    return 0.0\n   if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n    return 0.0\n   if phat < P['pL']:\n    ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n    a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n    if self.s == 3:\n     flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n     if state.yes_inventory >= flow * H / max(ca - 1, ptk + 1) * 100.0:\n      a *= P['kA'] / P['kLf']\n   return qsize(a, b, max(phat, 0.05))\n  def qask(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   if self.s == 4 and t - phat * 100 < P['dmin']:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if t - phat * 100 < P['dmin']:\n    return 0.0\n   if self.s == 4:\n    if P['pL'] <= phat <= 0.95:\n     b *= 1.4\n    tail = b * kA / max(self.f4_rate * a, 1e-30)\n    if a <= 0 or tail >= 1.0:\n     return 0.0\n    return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n   if self.s == 2 and phat < 0.1:\n    a = max(0.0, a - 0.0015 * (1 - min(1.0, state.yes_inventory / 3000.0)))\n   return qsize(b, a, t / 100.0)\n  bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n  asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n  sticky = P['sticky'] > 0\n  ma_ask = 50.0 if (self.s == 4 and phat < 0.05) else P['min_ahead']\n  def top(orders, comp, step):\n   threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else (ma_ask if step < 0 else P['min_ahead'])\n   if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\n    return comp\n   return comp + step\n  bid_t = top(bids, cb, 1)\n  ask_t = top(asks, ca, -1)\n  qb = qbid(bid_t)\n  qa = qask(ask_t)\n  if self.s == 4 and phat < 0.05 and bid_t >= 2:\n   qb *= 0.5\n  if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n   qa *= 5\n  Y = state.yes_inventory\n  if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n   qa = qa if Y >= P['a1'] > 0 else 0.0\n  ptick = phat * 100\n  amt = 0\n  qam = 0.0\n  if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n   wealth = state.cash + Y * phat\n   x = max(ask_t, ptick + 1) / 100.0\n   capw = P['fy'] * wealth / max(phat, 0.005)\n   flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n   target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n   if self.s == 4:\n    target = min(target, qa)\n   if self.s == 3:\n    target = min(target, qa)\n   full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n   t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n   g = t - ptick\n   if self.s != 3 and Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n    amt, qam = t, min(P['qf'], full - Y)\n   elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n    amt, qam = t, min(P['ammo_q'], target - Y)\n   elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n    amt, qam = t - 1, min(P['qf'], full - Y)\n  if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n   amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n  q1 = 0.0\n  if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n   stock_rate = P['ydf1']\n   if self.s == 4:\n    stock_rate *= self.f4_flow / 0.6\n   if self.s == 3:\n    flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n    scale = max(0.5, min(2.0, flow / P['flow_level']))\n    stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n   q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n  if 0.02 < phat < 0.1:\n   ct = max(2, min(99, int(math.floor(ptick))))\n   wealth = state.cash + Y * phat\n   goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n   if Y < goal and ct < ask_t:\n    amt, qam = ct, min(3000.0, goal - Y)\n  actions = []\n  free = state.free_cash - 2.0\n  keep_ask = 0.0\n  new_b = []\n  new_a = []\n  def cancel(o):\n   nonlocal free\n   actions.append(CancelOrder(o.order_id))\n   x = o.price_ticks / 100.0\n   if o.side is Side.BUY:\n    free += x * o.remaining_quantity\n   else:\n    free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n   self.ahead.discard(o.order_id)\n   self.res.pop(o.order_id, None)\n  for o in state.own_orders:\n   if o.remaining_quantity <= PROBE + 1e-9:\n    cancel(o)\n  kept_ids = set()\n  def manage(orders, t, q, comp):\n   kept = 0.0\n   for o in orders:\n    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * (3.0 if self.s == 4 and o.side is Side.SELL and o.order_id in self.ahead and o.price_ticks == comp else P['keep_hi']), 1.0) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\n     kept += o.remaining_quantity\n     kept_ids.add(o.order_id)\n    else:\n     cancel(o)\n   return kept\n  kb = manage(bids, bid_t, qb, cb)\n  ka = manage(asks, ask_t, qa, ca)\n  add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n  add_a = (qa - ka) if (ka < qa * P['keep_lo'] and ask_t != ca) else 0.0\n  budget = P['fb'] * max(free, 0.0)\n  cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n  if cost > budget:\n   f = budget / cost\n   add_b *= f\n   qam *= f\n   cost = budget\n  out = []\n  q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n  if q1 >= 0.01:\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n   free -= fl(q1) / 100.0 + 1e-6\n  if amt and qam >= 0.01:\n   q = fl(qam)\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n   free -= q * amt / 100.0 + 1e-6\n  if bid_t >= 1 and add_b >= 0.01:\n   q = fl(add_b)\n   total_q = q\n   if self.s == 4 and ca <= 99 and bid_t > cb and bid_t == ca - 4 and q >= 4.0 and q * bid_t / 100 >= 4 * P['m']:\n    head = fl(q / 2)\n    oid = self._oid('b')\n    out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=head, client_order_id=oid))\n    self.ahead.add(oid)\n    q = fl(q - head)\n   oid = self._oid('b')\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n   free -= total_q * bid_t / 100.0 + 1e-6\n   if bid_t > cb:\n    self.ahead.add(oid)\n  if ask_t <= 99 and add_a >= 0.01:\n   x = ask_t / 100.0\n   covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n        for o in asks if o.order_id in kept_ids)\n   cov = max(0.0, Y - covk - 0.1)\n   unc = max(0.0, add_a - cov)\n   if unc > 0:\n    ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n    if H < P['Hu'] and phat < 0.05:\n     ub = max(0.0, free * (1 - H / P['Hu']))\n    if self.s == 2:\n     ub = min(ub, max(0.0, free - 200 * min(1.0, H / 50.0)))\n    unc = min(unc, ub / (1 - x))\n   q = fl(min(add_a, cov + unc))\n   if q >= 0.01:\n    oid = self._oid('a')\n    out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n    r = max(0.0, q - cov)\n    self.res[oid] = r\n    free -= r * (1 - x) + 1e-6\n    if ask_t < ca:\n     self.ahead.add(oid)\n  f = int(math.floor(ptick + 1e-9))\n  r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n  self.pb = set()\n  self.pa = set()\n  if free > 1.0:\n   for t in range(f, f + r + 1):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n     self.pb.add(t)\n   for t in range(f + 1 - r, f + 2):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n     self.pa.add(t)\n   if self.s == 4:\n    for t in range(max(cb, bid_t) + 1, f):\n     if t < ca and 1 <= t <= 99:\n      out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n      self.pb.add(t)\n    for t in range(f + 2, min(ca, ask_t)):\n     if t > cb and 1 <= t <= 99:\n      out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n      self.pa.add(t)\n  if self.s == 3:\n   self.last_ask_tick = ask_t\n   self.last_flow_ca = ca\n   exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n   self.last_flow_cap = exposed_qty * ask_t / 100.0\n   self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n   if self.last_quote_exposed:\n    logcap = math.log(self.last_flow_cap)\n    mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n    clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n    self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n  if self.s == 4:\n   self.f4_last = [None, None]\n   for side, tick, bound, conv, distance in (\n    (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n    (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n    if distance < max(0.01, 3.0 * self.st / 100.0):\n     continue\n    if side == 0:\n     if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n      continue\n     orders = asks\n     order_side = Side.SELL\n    else:\n     if not (bid_t > cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n      continue\n     if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n      continue\n     orders = bids\n     order_side = Side.BUY\n    tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n    tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n    cap = sum(tracked.values()) * conv\n    if cap >= 0.5:\n     self.f4_last[side] = (tick, conv, cap, bound, tracked)\n  return actions + out\n\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\nF_AH_1 = 1\nF_FL_1 = 1\nF_QB_1 = 1\nF_LK_1 = 0\nF_SB_1 = 0\nFLOW_CAPS_1 = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.)\nFLOW_GRID_1 = []\nFLOW_PRIORS_1=[]\nfor _rn,_rw in ((-math.sqrt(0.6),5/18),(0.,4/9),(math.sqrt(0.6),5/18)):\n _r=0.1265+0.0495*_rn\n for _mn,_mw in ((-0.906179845938664,0.118463442528095),(-0.538469310105683,0.239314335249683),(0.,0.284444444444444),(0.538469310105683,0.239314335249683),(0.906179845938664,0.118463442528095)):\n  _m=4.488+1.848*_mn\n  _parts=[]\n  for _n in (1,2,3):\n   _v=math.log(1+(math.exp(1.44)-1)/_n)\n   _sg=math.sqrt(_v)\n   _mu=math.log(_n*_m)-_v/2\n   _w=_r**_n/math.factorial(_n)\n   _parts.append((_mu,_sg,_w))\n  _norm=[]\n  for _c in FLOW_CAPS_1:\n   _prob=sum(w*(cdf((math.log(_c)-mu)/sg)-cdf((math.log(0.03)-mu)/sg)) for mu,sg,w in _parts)\n   _norm.append(math.log1p(_prob))\n  _tails=[]\n  for _c in FLOW_CAPS_1:\n   _cdf=1+sum(w*cdf((math.log(_c)-mu)/sg) for mu,sg,w in _parts)\n   _tails.append(math.log(max(1e-100,1-math.exp(-_r)*_cdf)))\n  FLOW_GRID_1.append((_r,_m,_parts,_norm,_tails))\n  FLOW_PRIORS_1.append(math.log(_rw*_mw))\nclass Strategy_1(BaseStrategy):\n def __init__(self):\n  self.n = 0\n  self.ahead = set()\n  self.res = {}\n  self.bc = None\n  self.bw = None\n  self.st = 0.5\n  self.pcb = self.pca = None\n  self.pb = set()\n  self.pa = set()\n  self.tb = 0\n  self.s = None\n  self.flow_notional = 0.0\n  self.flow_exposure = 0\n  self.last_ask_tick = None\n  self.last_quote_exposed = False\n  self.last_flow_ca = None\n  self.last_flow_cap = 0.0\n  self.last_flow_correction = 1.0\n  self.params = P.copy()\n  self.fl_obs = ()\n  self.fl_scores = FLOW_PRIORS_1.copy()\n  self.fl_bins = [0]*len(FLOW_CAPS_1)\n  self.fl_rate = 0.568734\n  self.fl_r = 0.1265\n  self.fl_m = 4.488\n  self.fl_buy_sum = self.fl_sell_sum = 0.0\n  self.fl_buy_exp = self.fl_sell_exp = 0.0\n  self.fl_exp = 0\n  self.fl_dirty=False\n  self.fl_ahead=set()\n  self.fl_safe_n=0\n  self.fl_sbins=[0]*len(FLOW_CAPS_1)\n def _oid(self, tag):\n  self.n += 1\n  return tag + str(self.n)\n def on_step(self, state):\n  H = max(1, state.steps_remaining)\n  cb = state.competitor_best_bid_ticks or 0\n  ca = state.competitor_best_ask_ticks or 100\n  if self.s is None:\n   self.s = max(1, (ca - cb + 1) // 2)\n   if self.s == 1:\n    self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n   if self.s == 3:\n    self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n  P = self.params\n  s1 = self.s == 1\n  AH = s1 and F_AH_1\n  FL = s1 and F_FL_1\n  QB = s1 and F_QB_1\n  LK = s1 and F_LK_1\n  SB = s1 and F_SB_1\n  if self.s == 3 and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n   self.flow_exposure += 1\n   self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n  lo, hi = cb, ca\n  for o in state.own_orders:\n   if o.side is Side.BUY:\n    lo = max(lo, o.price_ticks)\n   else:\n    hi = min(hi, o.price_ticks)\n  if P['pinf'] > 0:\n   sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n   sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n   ea = self.pa - sa\n   eb = self.pb - sb\n   if sa and ea:\n    lo = max(lo, min(max(ea), hi))\n   if eb and (sb or min(eb) <= P['p1t']):\n    hi = min(hi, max(min(eb), lo))\n  if P['jumpinfo'] > 0 and self.pcb is not None:\n   if ca > self.pca + 1:\n    lo = max(lo, ca - 1)\n   if cb < self.pcb - 1:\n    hi = min(hi, cb + 1)\n  self.pcb, self.pca = cb, ca\n  if lo > hi:\n   lo, hi = hi, lo\n  wid = max(hi - lo, 1e-6)\n  nb = max(2, min(48, int(round(wid * P['bins']))))\n  cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n  if self.bc is None or P['filt'] <= 0:\n   ws = [1.0 / nb] * nb\n  else:\n   sg = max(self.st, 0.6 * wid / nb)\n   k = -0.5 / (sg * sg)\n   ws = []\n   uni = P['uni'] * sg\n   if self.s == 1:\n    prior = tuple(zip(self.bc, self.bw))\n    exp = math.exp\n    for c in cs:\n     t = uni\n     for ci, wi in prior:\n      d = c - ci\n      d2 = d * d * k\n      if d2 > -12.5:\n       t += wi * exp(d2)\n     ws.append(t)\n   else:\n    for c in cs:\n     t = uni\n     for ci, wi in zip(self.bc, self.bw):\n      d = c - ci\n      d2 = d * d * k\n      if d2 > -12.5:\n       t += wi * math.exp(d2)\n     ws.append(t)\n   tot = sum(ws)\n   ws = [w / tot for w in ws]\n  self.bc, self.bw = cs, ws\n  mean_t = sum(c * w for c, w in zip(cs, ws))\n  var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n  phat = min(max(mean_t / 100.0, 0.002), 0.998)\n  var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n  sd = math.sqrt(H * var)\n  self.tb = self.tb + 1 if hi <= 1 else 0\n  if self.tb > 0 and P['zd'] > 0:\n   phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n  z = inv(phat)\n  Z = z * sd\n  sp = pdf(z) / sd * P['sig']\n  self.st = sp * 100.0\n  if FL:\n   remaining={o.order_id:o.remaining_quantity for o in state.own_orders} if self.fl_obs else {}\n   for px, ci, buying, previous, tick in self.fl_obs:\n    qty=max(0.0,sum(q-remaining.get(oid,0.0) for oid,q in previous))\n    x=qty*px\n    cap=FLOW_CAPS_1[ci]\n    gap=tick/100.0-phat if buying else phat-tick/100.0\n    safe=gap>max(0.005,2.0*math.sqrt(var_t)/100.0)\n    if 0<x<0.03:\n     continue\n    if x>=cap:\n     if safe:\n      self.fl_sbins[ci]+=1\n      self.fl_exp+=1\n      self.fl_dirty=True\n     continue\n    if safe:\n     self.fl_safe_n+=1\n    else:\n     self.fl_bins[ci]+=1\n    self.fl_exp+=1\n    self.fl_dirty=True\n    if buying:\n     self.fl_buy_exp+=1\n    else:\n     self.fl_sell_exp+=1\n    if x>0:\n     lx=math.log(x)\n     for i,(r,m,parts,norm,tails) in enumerate(FLOW_GRID_1):\n      density=sum(w*pdf((lx-mu)/sg)/sg for mu,sg,w in parts)\n      self.fl_scores[i]+=math.log(max(density,1e-100))\n   if state.step % 100 == 0 and (self.fl_dirty or state.step==0):\n    bins=[(i,n) for i,n in enumerate(self.fl_bins) if n]\n    sbins=[(i,n) for i,n in enumerate(self.fl_sbins) if n]\n    logs=[score-sum(n*g[3][i] for i,n in bins)-g[0]*self.fl_safe_n+sum(n*g[4][i] for i,n in sbins) for score,g in zip(self.fl_scores,FLOW_GRID_1)]\n    mx=max(logs)\n    weights=[math.exp(v-mx) for v in logs]\n    den=sum(weights)\n    self.fl_dirty=False\n    self.fl_rate=sum(w*g[0]*g[1] for w,g in zip(weights,FLOW_GRID_1))/den\n    self.fl_r=sum(w*g[0] for w,g in zip(weights,FLOW_GRID_1))/den\n    self.fl_m=sum(w*g[1] for w,g in zip(weights,FLOW_GRID_1))/den\n  s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n  s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n  sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n  jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n  lj = P['lam_j']\n  def AB(x):\n   k = (x - phat) / s\n   a = s * lpm(k)\n   b = a - (x - phat)\n   ja = sum(w * max(0.0, x - p) for p, w in jp)\n   jb = sum(w * max(0.0, p - x) for p, w in jp)\n   return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n  if H == 1:\n   def AB(x):\n    return (1 - phat) * x, phat * (1 - x)\n  rho = P['lam_r'] * 0.5\n  mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n  kA = P['kL'] if phat < P['pL'] else P['kA']\n  def qsize(loss, gain, px, flow=False, cap=None):\n   loss *= kA\n   if gain <= 0:\n    return 0.0\n   rr = (0.125+0.5*(self.fl_r-0.125)) if flow and FL else rho\n   mm = math.log(5.0+0.5*(self.fl_m-5.0))-0.5*P['sig_n']**2 if flow and FL else mu\n   tail = loss / (rr * gain)\n   if tail >= 1.0:\n    return 0.0\n   return min((cap if cap is not None else P['qmax']), math.exp(mm + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n  ptk = phat * 100\n  def qbid(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if phat * 100 - t < P['dmin']:\n    return 0.0\n   if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n    return 0.0\n   if phat < P['pL']:\n    ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n    a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n   return qsize(a, b, max(phat, 0.05))\n  def qask(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if t - phat * 100 < P['dmin']:\n    return 0.0\n   return qsize(b, a, t / 100.0, flow=True, cap=(15000 if AH and t == 2 and phat < 0.01 else None))\n  bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n  asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n  sticky = P['sticky'] > 0\n  def top(orders, comp, step):\n   if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= (PROBE + 0.01 if QB and step == 1 else P['min_ahead']):\n    return comp\n   return comp + step\n  bid_t = top(bids, cb, 1)\n  ask_t = top(asks, ca, -1)\n  qb = qbid(bid_t)\n  qa = qask(ask_t)\n  if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n   qa *= 5\n  Y = state.yes_inventory\n  if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n   qa = qa if Y >= P['a1'] > 0 else 0.0\n  ptick = phat * 100\n  flow_scale = max(0.4,min(1.9,1.0+0.5*(self.fl_rate/0.568734-1))) if FL else 1.0\n  amt = 0\n  qam = 0.0\n  if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n   wealth = state.cash + Y * phat\n   x = max(ask_t, ptick + 1) / 100.0\n   capw = P['fy'] * wealth / max(phat, 0.005)\n   target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n   full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n   t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n   g = t - ptick\n   if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n    amt, qam = t, min(P['qf'], full - Y)\n   elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n    amt, qam = t, min(P['ammo_q'], target - Y)\n   elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n    amt, qam = t - 1, min(P['qf'], full - Y)\n  if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n   amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n  q1 = 0.0\n  if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n   stock_rate = flow_scale * P['ydf1']\n   if self.s == 3:\n    flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n    scale = max(0.5, min(2.0, flow / P['flow_level']))\n    stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n   q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n  if 0.02 < phat < 0.1:\n   ct = max(2, min(99, int(math.floor(ptick))))\n   wealth = state.cash + Y * phat\n   goal = min(flow_scale * qa, 0.3 * max(wealth, 0.0) / phat)\n   if Y < goal and ct < ask_t:\n    amt, qam = ct, min(3000.0, goal - Y)\n  if SB and 2 <= amt <= 5:\n   amt, qam = 0, 0.0\n  actions = []\n  free = state.free_cash - 2.0\n  keep_ask = 0.0\n  new_b = []\n  new_a = []\n  def cancel(o):\n   nonlocal free\n   actions.append(CancelOrder(o.order_id))\n   x = o.price_ticks / 100.0\n   if o.side is Side.BUY:\n    free += x * o.remaining_quantity\n   else:\n    free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n   self.ahead.discard(o.order_id)\n   self.res.pop(o.order_id, None)\n  for o in state.own_orders:\n   if o.remaining_quantity <= PROBE + 1e-9:\n    cancel(o)\n  kept_ids = set()\n  def manage(orders, t, q, comp):\n   kept = 0.0\n   banked = {}\n   bound_t, bound_q = t, q\n   for o in orders:\n    ah = o.order_id in self.ahead\n    if AH and ah and o.remaining_quantity >= P['min_ahead'] and o.price_ticks != t:\n     if (o.side is Side.SELL and o.price_ticks > t) or (o.side is Side.BUY and o.price_ticks < t):\n      enough = bound_q > 0 and (\n       o.remaining_quantity <= bound_q if o.side is Side.BUY else\n       o.remaining_quantity * o.price_ticks <= min(bound_q, P['qmax']) * bound_t)\n      if enough:\n       kept_ids.add(o.order_id)\n       continue\n      if o.price_ticks == bound_t:\n       capacity = bound_q\n      else:\n       capacity = qask(o.price_ticks) if o.side is Side.SELL else qbid(o.price_ticks)\n       bound_t, bound_q = o.price_ticks, capacity\n      if capacity > 0 and o.remaining_quantity <= max(capacity, 1.0):\n       kept_ids.add(o.order_id)\n       continue\n    if QB and ah and o.side is Side.BUY and o.price_ticks < t and banked.get(o.price_ticks, 0.0) + o.remaining_quantity <= P['keep_hi'] * qbid(o.price_ticks):\n     banked[o.price_ticks] = banked.get(o.price_ticks, 0.0) + o.remaining_quantity\n     kept_ids.add(o.order_id)\n     continue\n    khi = 10.0 if (AH and ah) else P['keep_hi']\n    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * khi, 1.0)\n      or (s1 and ah and (o.side is Side.SELL) and o.price_ticks <= 2)\n      or (LK and ah)\n      or (QB and ah and o.side is Side.BUY and o.price_ticks == comp)):\n     kept += o.remaining_quantity\n     kept_ids.add(o.order_id)\n    else:\n     cancel(o)\n   return kept\n  kb = manage(bids, bid_t, qb, cb)\n  ka = manage(asks, ask_t, qa, ca)\n  add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n  add_a = (qa - ka) if (ka < qa * P['keep_lo'] and ask_t != ca) else 0.0\n  budget = P['fb'] * max(free, 0.0)\n  cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n  if cost > budget:\n   f = budget / cost\n   add_b *= f\n   qam *= f\n   cost = budget\n  out = []\n  q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n  if q1 >= 0.01:\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n   free -= fl(q1) / 100.0 + 1e-6\n  if amt and qam >= 0.01:\n   q = fl(qam)\n   if QB:\n    oid = self._oid('m')\n    out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n    if amt > cb:\n     self.ahead.add(oid)\n   else:\n    out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n   free -= q * amt / 100.0 + 1e-6\n  if bid_t >= 1 and add_b >= 0.01:\n   q = fl(add_b)\n   oid = self._oid('b')\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n   free -= q * bid_t / 100.0 + 1e-6\n   if bid_t > cb:\n    self.ahead.add(oid)\n  if ask_t <= 99 and add_a >= 0.01:\n   x = ask_t / 100.0\n   covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n        for o in asks if o.order_id in kept_ids)\n   cov = max(0.0, Y - covk - 0.1)\n   unc = max(0.0, add_a - cov)\n   if unc > 0:\n    ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n    if H < P['Hu'] and phat < 0.05:\n     ub = max(0.0, free * (1 - H / P['Hu']))\n    unc = min(unc, ub / (1 - x))\n   q = fl(min(add_a, cov + unc))\n   if q >= 0.01:\n    oid = self._oid('a')\n    out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n    r = max(0.0, q - cov)\n    self.res[oid] = r\n    free -= r * (1 - x) + 1e-6\n    if ask_t < ca:\n     self.ahead.add(oid)\n  f = int(math.floor(ptick + 1e-9))\n  r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n  self.pb = set()\n  self.pa = set()\n  if free > 1.0:\n   for t in range(f, f + r + 1):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n     self.pb.add(t)\n   for t in range(f + 1 - r, f + 2):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n     self.pa.add(t)\n  if self.s == 3:\n   self.last_ask_tick = ask_t\n   self.last_flow_ca = ca\n   exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n   self.last_flow_cap = exposed_qty * ask_t / 100.0\n   self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n   if self.last_quote_exposed:\n    logcap = math.log(self.last_flow_cap)\n    mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n    clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n    self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n  if FL:\n   if not kept_ids and not any(o.quantity>PROBE for o in out):\n    self.fl_obs=()\n    self.fl_ahead.clear()\n    return actions+out\n   for i,o in enumerate(out):\n    if o.client_order_id is None and o.quantity>PROBE:\n     out[i]=PlaceOrder(side=o.side,price_ticks=o.price_ticks,quantity=o.quantity,client_order_id=self._oid('f'))\n   live=[]\n   oldids={o.order_id for o in state.own_orders if o.order_id in kept_ids}\n   self.fl_ahead.intersection_update(oldids)\n   for o in state.own_orders:\n    if o.order_id in kept_ids and o.remaining_quantity>PROBE:\n     live.append((o.side,o.price_ticks,o.remaining_quantity,o.order_id))\n   for o in out:\n    if o.quantity>PROBE:\n     live.append((o.side,o.price_ticks,o.quantity,o.client_order_id))\n     if (o.side is Side.SELL and o.price_ticks<ca) or (o.side is Side.BUY and o.price_ticks>cb):\n      self.fl_ahead.add(o.client_order_id)\n   obs=[]\n   for buying,side,comp in ((True,Side.SELL,ca),(False,Side.BUY,cb)):\n    orders=[o for o in live if o[0] is side]\n    if not orders:\n     continue\n    tick=min(o[1] for o in orders) if buying else max(o[1] for o in orders)\n    orders=[o for o in orders if o[1]==tick]\n    if not all(o[3] in self.fl_ahead for o in orders):\n     continue\n    if (buying and tick>comp) or (not buying and tick<comp):\n     continue\n    px=tick/100.0 if buying else max(phat,0.05)\n    cap=sum(o[2] for o in orders)*px\n    if cap<0.04:\n     continue\n    ci=0\n    while ci+1<len(FLOW_CAPS_1) and FLOW_CAPS_1[ci+1]<cap-0.01:\n     ci+=1\n    obs.append((px,ci,buying,[(o[3],o[2]) for o in orders],tick))\n   self.fl_obs=obs\n  return actions + out\n\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\nclass Strategy_2(BaseStrategy):\n def __init__(self):\n  self.n = 0\n  self.ahead = set()\n  self.res = {}\n  self.bc = None\n  self.bw = None\n  self.st = 0.5\n  self.pcb = self.pca = None\n  self.pb = set()\n  self.pa = set()\n  self.tb = 0\n  self.s = None\n  self.flow_notional = 0.0\n  self.flow_exposure = 0\n  self.last_ask_tick = None\n  self.last_quote_exposed = False\n  self.last_flow_ca = None\n  self.last_flow_cap = 0.0\n  self.last_flow_correction = 1.0\n  self.params = P.copy()\n def _oid(self, tag):\n  self.n += 1\n  return tag + str(self.n)\n def on_step(self, state):\n  H = max(1, state.steps_remaining)\n  cb = state.competitor_best_bid_ticks or 0\n  ca = state.competitor_best_ask_ticks or 100\n  if self.s is None:\n   self.s = max(1, (ca - cb + 1) // 2)\n   if self.s == 2:\n    self.params.update(dict(flow_prior=200, flow_level=0.6, flow_strength=1.0, flow_safety=2.0, flow_exposure_min=5.0))\n   if self.s == 2:\n    self.params.update({'kLf': 0.16})\n   if self.s == 1:\n    self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n   if self.s == 3:\n    self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n  P = self.params\n  if self.s in (2, 3) and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n   self.flow_exposure += 1\n   self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n  lo, hi = cb, ca\n  for o in state.own_orders:\n   if o.side is Side.BUY:\n    lo = max(lo, o.price_ticks)\n   else:\n    hi = min(hi, o.price_ticks)\n  if P['pinf'] > 0:\n   sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n   sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n   ea = self.pa - sa\n   eb = self.pb - sb\n   if sa and ea:\n    lo = max(lo, min(max(ea), hi))\n   if eb and (sb or min(eb) <= P['p1t']):\n    hi = min(hi, max(min(eb), lo))\n  if P['jumpinfo'] > 0 and self.pcb is not None:\n   if ca > self.pca + 1:\n    lo = max(lo, ca - 1)\n   if cb < self.pcb - 1:\n    hi = min(hi, cb + 1)\n  self.pcb, self.pca = cb, ca\n  if lo > hi:\n   lo, hi = hi, lo\n  wid = max(hi - lo, 1e-6)\n  nb = max(2, min(48, int(round(wid * P['bins']))))\n  cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n  if self.bc is None or P['filt'] <= 0:\n   ws = [1.0 / nb] * nb\n  else:\n   sg = max(self.st, 0.6 * wid / nb)\n   k = -0.5 / (sg * sg)\n   ws = []\n   uni = P['uni'] * sg\n   for c in cs:\n    t = uni\n    for ci, wi in zip(self.bc, self.bw):\n     d = c - ci\n     d2 = d * d * k\n     if d2 > -12.5:\n      t += wi * math.exp(d2)\n    ws.append(t)\n   tot = sum(ws)\n   ws = [w / tot for w in ws]\n  self.bc, self.bw = cs, ws\n  mean_t = sum(c * w for c, w in zip(cs, ws))\n  var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n  phat = min(max(mean_t / 100.0, 0.002), 0.998)\n  var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n  sd = math.sqrt(H * var)\n  self.tb = self.tb + 1 if hi <= 1 else 0\n  if self.tb > 0 and P['zd'] > 0:\n   phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n  z = inv(phat)\n  Z = z * sd\n  sp = pdf(z) / sd * P['sig']\n  self.st = sp * 100.0\n  s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n  sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n  jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n  lj = P['lam_j']\n  def AB(x):\n   k = (x - phat) / s\n   a = s * lpm(k)\n   b = a - (x - phat)\n   ja = sum(w * max(0.0, x - p) for p, w in jp)\n   jb = sum(w * max(0.0, p - x) for p, w in jp)\n   return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n  if H == 1:\n   def AB(x):\n    return (1 - phat) * x, phat * (1 - x)\n  rho = P['lam_r'] * 0.5\n  mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n  kA = P['kL'] if phat < P['pL'] else P['kA']\n  def qsize(loss, gain, px):\n   loss *= kA\n   if gain <= 0:\n    return 0.0\n   tail = loss / (rho * gain)\n   if tail >= 1.0:\n    return 0.0\n   return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n  ptk = phat * 100\n  def qbid(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if phat * 100 - t < P['dmin']:\n    return 0.0\n   if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n    return 0.0\n   if phat < P['pL']:\n    ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n    a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n   return qsize(a, b, max(phat, 0.05))\n  def qask(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   a, b = AB(t / 100.0)\n   if t - phat * 100 < P['dmin']:\n    return 0.0\n   return qsize(b, a, t / 100.0)\n  bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n  asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n  sticky = P['sticky'] > 0\n  def top(orders, comp, step):\n   if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= (P['min_ahead'] if self.s != 2 else max(P['min_ahead'], 400.0 / max(comp, 1))):\n    return comp\n   return comp + step\n  bid_t = top(bids, cb, 1)\n  ask_t = top(asks, ca, -1)\n  qb = qbid(bid_t)\n  s2f = self.s == 2 and bid_t == cb and qb > 0 and cb / 100.0 < phat\n  qa = qask(ask_t)\n  Y = state.yes_inventory\n  if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n   qa = qa if Y >= P['a1'] > 0 else 0.0\n  ptick = phat * 100\n  amt = 0\n  qam = 0.0\n  if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n   wealth = state.cash + Y * phat\n   x = max(ask_t, ptick + 1) / 100.0\n   capw = P['fy'] * wealth / max(phat, 0.005)\n   target = min(P['ydem'] * min(H, P['W']) / x, capw)\n   full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n   t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n   g = t - ptick\n   if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n    amt, qam = t, min(P['qf'], full - Y)\n   elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n    amt, qam = t, min(P['ammo_q'], target - Y)\n   elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n    amt, qam = t - 1, min(P['qf'], full - Y)\n  if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n   amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n  q1 = 0.0\n  if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n   stock_rate = P['ydf1']\n   if self.s in (2, 3):\n    flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n    scale = max(0.5, min(2.0, flow / P['flow_level']))\n    stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n   q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n  if 0.02 < phat < 0.1:\n   ct = max(2, min(99, int(math.floor(ptick))))\n   wealth = state.cash + Y * phat\n   goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n   if Y < goal and ct < ask_t:\n    amt, qam = ct, min(3000.0, goal - Y)\n  actions = []\n  free = state.free_cash - 2.0\n  keep_ask = 0.0\n  new_b = []\n  new_a = []\n  def cancel(o):\n   nonlocal free\n   actions.append(CancelOrder(o.order_id))\n   x = o.price_ticks / 100.0\n   if o.side is Side.BUY:\n    free += x * o.remaining_quantity\n   else:\n    free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n   self.ahead.discard(o.order_id)\n   self.res.pop(o.order_id, None)\n  for o in state.own_orders:\n   if o.remaining_quantity <= PROBE + 1e-9:\n    cancel(o)\n  kept_ids = set()\n  def manage(orders, t, q, comp):\n   kept = 0.0\n   if self.s == 2:\n    buy = comp == cb\n    held = {}\n    for o in orders:\n     x = o.price_ticks\n     gain = ptk - x if buy else x - ptk\n     if x == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (x == comp and o.order_id in self.ahead and ptk <= 10.0 and gain >= 0.0)):\n      kept += o.remaining_quantity\n      kept_ids.add(o.order_id)\n      continue\n     if x == comp and x != t and o.order_id in self.ahead and gain >= 1.0:\n      if x not in held:\n       held[x] = [0.0, qbid(x) if buy else qask(x)]\n      h = held[x]\n      if h[0] + o.remaining_quantity <= max(h[1], 1.0) and h[1] > 0:\n       h[0] += o.remaining_quantity\n       kept_ids.add(o.order_id)\n       continue\n     cancel(o)\n    return kept\n   for o in orders:\n    if o.price_ticks == t and q > 0 and kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0):\n     kept += o.remaining_quantity\n     kept_ids.add(o.order_id)\n    else:\n     cancel(o)\n   return kept\n  if s2f and 1:\n   kb = 0.0\n   for o in bids:\n    if o.price_ticks == bid_t and o.order_id in self.ahead:\n     kb += o.remaining_quantity\n     kept_ids.add(o.order_id)\n    else:\n     cancel(o)\n  elif self.s == 2 and 1 and bid_t == cb + 1:\n   qf = qbid(cb) if 1 else 1.0\n   fr = [o for o in bids if o.price_ticks == cb and o.order_id in self.ahead and cb / 100.0 < phat - 0.0 and qf > 0]\n   for o in fr:\n    kept_ids.add(o.order_id)\n   kb = manage([o for o in bids if o not in fr], bid_t, qb, cb)\n  else:\n   kb = manage(bids, bid_t, qb, cb)\n  ka = manage(asks, ask_t, qa, ca)\n  add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n  add_a = (qa - ka) if (ka < qa * P['keep_lo'] and ask_t != ca) else 0.0\n  budget = P['fb'] * max(free, 0.0)\n  cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n  if cost > budget:\n   f = budget / cost\n   add_b *= f\n   qam *= f\n   cost = budget\n  out = []\n  q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n  if q1 >= 0.01:\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n   free -= fl(q1) / 100.0 + 1e-6\n  if amt and qam >= 0.01:\n   q = fl(qam)\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n   free -= q * amt / 100.0 + 1e-6\n  if bid_t >= 1 and add_b >= 0.01:\n   q = fl(add_b)\n   oid = self._oid('b')\n   out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n   free -= q * bid_t / 100.0 + 1e-6\n   if bid_t > cb:\n    self.ahead.add(oid)\n  if ask_t <= 99 and add_a >= 0.01:\n   x = ask_t / 100.0\n   covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n        for o in asks if o.order_id in kept_ids)\n   cov = max(0.0, Y - covk - 0.1)\n   unc = max(0.0, add_a - cov)\n   if unc > 0:\n    ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n    if H < P['Hu'] and phat < 0.05:\n     ub = max(0.0, free * (1 - H / P['Hu']))\n    unc = min(unc, ub / (1 - x))\n   q = fl(min(add_a, cov + unc))\n   if q >= 0.01:\n    oid = self._oid('a')\n    out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n    r = max(0.0, q - cov)\n    self.res[oid] = r\n    free -= r * (1 - x) + 1e-6\n    if ask_t < ca:\n     self.ahead.add(oid)\n  f = int(math.floor(ptick + 1e-9))\n  r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n  self.pb = set()\n  self.pa = set()\n  if free > 1.0:\n   for t in range(f, f + r + 1):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n     self.pb.add(t)\n   for t in range(f + 1 - r, f + 2):\n    if cb < t < ca and 1 <= t <= 99:\n     out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n     self.pa.add(t)\n  if self.s in (2, 3):\n   self.last_ask_tick = ask_t\n   self.last_flow_ca = ca\n   exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n   self.last_flow_cap = exposed_qty * ask_t / 100.0\n   self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n   if self.last_quote_exposed:\n    logcap = math.log(self.last_flow_cap)\n    mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n    clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n    self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n  return actions + out\nclass Strategy(BaseStrategy):\n def __init__(self):\n  self.d = None\n def on_step(self, state):\n  if self.d is None:\n   cb = state.competitor_best_bid_ticks or 0\n   ca = state.competitor_best_ask_ticks or 100\n   s = max(1, (ca - cb + 1) // 2)\n   self.d = Strategy_1() if s == 1 else Strategy_2() if s == 2 else Strategy_0()\n  return self.d.on_step(state)\n", "code_sha256": "d552573a648ba608a0dd5a83718641e9bf155e6145177277ba101be218b4ac46", "tried": ["Machine has 1 CPU (cgroup cpu.max 100000/100000), ~1 s per simulation; the CLI with --workers 4 did not finish 600 runs in 10 min, so every run count was cut far below the brief (more than halving).", "Step 1: base_mean_edge not measured on 600 runs; on seeds 1000-1059 (60 runs) the earlier file scored mean 155.24467708906334, not comparable to the author's 108.63974289615767.", "Step 2: exact on 15 seeds of each spread from 100000 and 15 from 104000 (30 per spread) vs c1/c2/a3-ledger/c4 files: every result field identical for all four spreads (first try failed spread 1 because a top-level loop building FLOW_GRID was dropped; fixed in the merge). Spreads 2-4 were checked on the build before that fix, which changed only the spread-1 block's top-level code.", "Step 3: fixes for spreads 3 and 4 measured on first 60 runs of the spread from seed 120000, all-on vs leave-one-out; none lost on both halves, all kept.", "Spread 1/2 fixes (a1-jumps, a1-free, a2-after, a2-ledger) were written against the start file's spread-1/2 code, which the c1-pairs/c2-queue blocks replace; not carried (no time or size budget to port them onto the block code) and so dropped untested.", "Step 4: holdout on seeds 130000-130139 only (140 runs), run by run vs start file; seconds are the 140-run wall time scaled to 200 runs, one core."], "next": "All counts are small (1 core). Re-run exactness on 300+300 per spread, fix tests on 1000 runs, and holdout on 130000-133999 on a multi-core machine before entering. Spread 1/2 fixes remain to be ported onto the c1/c2 blocks."}