{"approach":"Every block, then fixes spread by spread in ascending listed gain: a1-free, a1-jumps; a2-ledger, a2-after; a3-free, a3-rich; a4-stock, a4-free, a4-rich. Each fix is retained only when both sequential 500-run paired halves gain. Source-specific branches are guarded by the observed competitor spread; no parameter tuning or seed recognition.","blocked":null,"base_mean_edge":108.63974289615767,"exact":{"spread1":{"runs":600,"identical":true},"spread2":{"runs":600,"identical":true},"spread3":{"runs":600,"identical":true},"spread4":{"runs":600,"identical":true}},"fixes":[{"name":"a1-free","kept":true,"gain":0.35149849538759986,"standard_error":0.1473650964688594},{"name":"a1-jumps","kept":false,"gain":-0.46009330345589977,"standard_error":0.5348458123513586},{"name":"a2-ledger","kept":true,"gain":1.0912132155852996,"standard_error":0.10001626498595995},{"name":"a2-after","kept":true,"gain":0.8675470084540006,"standard_error":0.13694721873193286},{"name":"a3-free","kept":true,"gain":0.2967595907355999,"standard_error":0.055760086084229464},{"name":"a3-rich","kept":true,"gain":0.7203253607131,"standard_error":0.20022945125849764},{"name":"a4-stock","kept":true,"gain":0.3884841414820999,"standard_error":0.04321751641266317},{"name":"a4-free","kept":false,"gain":0.10763674876980042,"standard_error":0.14029986176237702},{"name":"a4-rich","kept":true,"gain":0.3102652228154002,"standard_error":0.0836897732963366}],"by_spread":{"spread1":{"runs":1016,"mean":1.9515104762154525,"standard_error":0.3478722551131989,"retail":0.7234912613565947,"arb":1.2280192148513778},"spread2":{"runs":980,"mean":3.005904837975102,"standard_error":0.51538162827511,"retail":1.7416755060861226,"arb":1.2642293318903062},"spread3":{"runs":958,"mean":1.1897131414110653,"standard_error":0.1500223481925494,"retail":-0.4360777386556363,"arb":1.6257908800641963},"spread4":{"runs":1046,"mean":2.6607117105554496,"standard_error":0.26368738893498095,"retail":-0.6165757799718925,"arb":3.277287490525717}},"holdout":{"mean_edge":102.11399036791022,"retail_edge":125.7037225511236,"arb_edge":-23.589732183230424,"failures":0},"diff":{"mean":2.2128427559408252,"standard_error":0.1728962114120029,"retail":0.3448020945050003,"arb":1.868040661433225},"seconds":{"start":107.23521068086848,"yours":115.86656947713345},"code":"import math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\nP_s1 = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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_s1 = math.sqrt(2.0)\nSQ2PI_s1 = math.sqrt(2.0 * math.pi)\n\ndef cdf_s1(x):\n return 0.5 * (1.0 + math.erf(x / SQ2_s1))\n\ndef pdf_s1(x):\n return math.exp(-0.5 * x * x) / SQ2PI_s1\n\ndef inv_s1(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\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_s1(x)\n  if d < 1e-12:\n   break\n  x -= (cdf_s1(x) - p) / d\n return x\n\ndef lpm_s1(k):\n return pdf_s1(k) + k * cdf_s1(k)\n\ndef fl_s1(q):\n return math.floor(q * 100 + 1e-09) / 100\nNODES_s1 = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\nPROBE_s1 = 0.01\nF_AH_s1 = 1\nF_FL_s1 = 1\nF_QB_s1 = 1\nF_LK_s1 = 0\nF_SB_s1 = 0\nFLOW_CAPS_s1 = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0)\nFLOW_GRID_s1 = []\nFLOW_PRIORS_s1 = []\nfor _rn_s1, _rw_s1 in ((-math.sqrt(0.6), 5 / 18), (0.0, 4 / 9), (math.sqrt(0.6), 5 / 18)):\n _r_s1 = 0.1265 + 0.0495 * _rn_s1\n for _mn_s1, _mw_s1 in ((-0.906179845938664, 0.118463442528095), (-0.538469310105683, 0.239314335249683), (0.0, 0.284444444444444), (0.538469310105683, 0.239314335249683), (0.906179845938664, 0.118463442528095)):\n  _m_s1 = 4.488 + 1.848 * _mn_s1\n  _parts_s1 = []\n  for _n_s1 in (1, 2, 3):\n   _v_s1 = math.log(1 + (math.exp(1.44) - 1) / _n_s1)\n   _sg_s1 = math.sqrt(_v_s1)\n   _mu_s1 = math.log(_n_s1 * _m_s1) - _v_s1 / 2\n   _w_s1 = _r_s1 ** _n_s1 / math.factorial(_n_s1)\n   _parts_s1.append((_mu_s1, _sg_s1, _w_s1))\n  _norm_s1 = []\n  for _c_s1 in FLOW_CAPS_s1:\n   _prob_s1 = sum((w * (cdf_s1((math.log(_c_s1) - mu) / sg) - cdf_s1((math.log(0.03) - mu) / sg)) for mu, sg, w in _parts_s1))\n   _norm_s1.append(math.log1p(_prob_s1))\n  _tails_s1 = []\n  for _c_s1 in FLOW_CAPS_s1:\n   _cdf_s1 = 1 + sum((w * cdf_s1((math.log(_c_s1) - mu) / sg) for mu, sg, w in _parts_s1))\n   _tails_s1.append(math.log(max(1e-100, 1 - math.exp(-_r_s1) * _cdf_s1)))\n  FLOW_GRID_s1.append((_r_s1, _m_s1, _parts_s1, _norm_s1, _tails_s1))\n  FLOW_PRIORS_s1.append(math.log(_rw_s1 * _mw_s1))\nP_s2 = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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_s2 = math.sqrt(2.0)\nSQ2PI_s2 = math.sqrt(2.0 * math.pi)\n\ndef cdf_s2(x):\n return 0.5 * (1.0 + math.erf(x / SQ2_s2))\n\ndef pdf_s2(x):\n return math.exp(-0.5 * x * x) / SQ2PI_s2\n\ndef inv_s2(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\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_s2(x)\n  if d < 1e-12:\n   break\n  x -= (cdf_s2(x) - p) / d\n return x\n\ndef lpm_s2(k):\n return pdf_s2(k) + k * cdf_s2(k)\n\ndef fl_s2(q):\n return math.floor(q * 100 + 1e-09) / 100\nNODES_s2 = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\nPROBE_s2 = 0.01\nP_s3 = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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_s3 = math.sqrt(2.0)\nSQ2PI_s3 = math.sqrt(2.0 * math.pi)\n\ndef cdf_s3(x):\n return 0.5 * (1.0 + math.erf(x / SQ2_s3))\n\ndef pdf_s3(x):\n return math.exp(-0.5 * x * x) / SQ2PI_s3\n\ndef inv_s3(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\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_s3(x)\n  if d < 1e-12:\n   break\n  x -= (cdf_s3(x) - p) / d\n return x\n\ndef lpm_s3(k):\n return pdf_s3(k) + k * cdf_s3(k)\n\ndef fl_s3(q):\n return math.floor(q * 100 + 1e-09) / 100\nNODES_s3 = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\nPROBE_s3 = 0.01\nP_s4 = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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_s4 = math.sqrt(2.0)\nSQ2PI_s4 = math.sqrt(2.0 * math.pi)\n\ndef cdf_s4(x):\n return 0.5 * (1.0 + math.erf(x / SQ2_s4))\n\ndef pdf_s4(x):\n return math.exp(-0.5 * x * x) / SQ2PI_s4\n\ndef inv_s4(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\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_s4(x)\n  if d < 1e-12:\n   break\n  x -= (cdf_s4(x) - p) / d\n return x\n\ndef lpm_s4(k):\n return pdf_s4(k) + k * cdf_s4(k)\n\ndef fl_s4(q):\n return math.floor(q * 100 + 1e-09) / 100\nNODES_s4 = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\nPROBE_s4 = 0.01\n\nclass Strategy(BaseStrategy):\n\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 = None\n\n def _oid(self, tag):\n  self.n += 1\n  return tag + str(self.n)\n\n def on_step(self, state):\n  _spread = self.s if self.s is not None else max(1, ((state.competitor_best_ask_ticks or 100) - (state.competitor_best_bid_ticks or 0) + 1) // 2)\n  if _spread == 1:\n   cdf, pdf, inv, lpm, fl, NODES, PROBE = (cdf_s1, pdf_s1, inv_s1, lpm_s1, fl_s1, NODES_s1, PROBE_s1)\n   FLOW_CAPS, FLOW_GRID, FLOW_PRIORS, F_AH, F_FL, F_LK, F_QB, F_SB = (FLOW_CAPS_s1, FLOW_GRID_s1, FLOW_PRIORS_s1, F_AH_s1, F_FL_s1, F_LK_s1, F_QB_s1, F_SB_s1)\n  if self.s is None and _spread == 1:\n   self.params = P_s1.copy()\n  if _spread == 2:\n   cdf, pdf, inv, lpm, fl, NODES, PROBE = (cdf_s2, pdf_s2, inv_s2, lpm_s2, fl_s2, NODES_s2, PROBE_s2)\n  if self.s is None and _spread == 2:\n   self.params = P_s2.copy()\n  if _spread == 3:\n   cdf, pdf, inv, lpm, fl, NODES, PROBE = (cdf_s3, pdf_s3, inv_s3, lpm_s3, fl_s3, NODES_s3, PROBE_s3)\n  if self.s is None and _spread == 3:\n   self.params = P_s3.copy()\n  if _spread == 4:\n   cdf, pdf, inv, lpm, fl, NODES, PROBE = (cdf_s4, pdf_s4, inv_s4, lpm_s4, fl_s4, NODES_s4, PROBE_s4)\n  if self.s is None and _spread == 4:\n   self.params = P_s4.copy()\n  if self.s is None and _spread == 1:\n   self.fl_obs = ()\n   self.fl_scores = FLOW_PRIORS.copy()\n   self.fl_bins = [0] * len(FLOW_CAPS)\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)\n  if self.s is None and _spread == 2:\n   self.s2_mb = set()\n   self.s2_ma = set()\n   self.s2_lb = self.s2_la = -99\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 _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n     else:\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      self.params.update({'kLf': 0.16})\n    else:\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   else:\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-06)\n  P = self.params\n  if _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\n     s1 = True\n     AH = s1 and F_AH\n     FL = s1 and F_FL\n     QB = s1 and F_QB\n     LK = s1 and F_LK\n     SB = s1 and F_SB\n    elif 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   elif 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  else:\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-06, 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  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-09}\n   sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-09}\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  if _spread != 4:\n   if _spread != 3:\n    if _spread == 2:\n     hitB = hitA = shB = shA = False\n     ids = {o.order_id for o in state.own_orders}\n     hitB = bool(self.s2_mb) and (not self.s2_mb & ids)\n     hitA = bool(self.s2_ma) and (not self.s2_ma & ids)\n     if hitB:\n      self.s2_lb = state.step\n     if hitA:\n      self.s2_la = state.step\n     hitB = state.step - self.s2_lb < 1\n     hitA = state.step - self.s2_la < 1\n     if self.pcb is not None:\n      shB = cb < self.pcb - 1\n      shA = ca > self.pca + 1\n  self.pcb, self.pca = (cb, ca)\n  if lo > hi:\n   lo, hi = (hi, lo)\n  wid = max(hi - lo, 1e-06)\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 _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      prior = tuple(zip(self.bc, self.bw))\n      exp = math.exp\n    for c in cs:\n     t = uni\n     if _spread != 3:\n      if _spread != 2:\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      else:\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     else:\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   else:\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   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 _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\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[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):\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)]\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))) / den\n       self.fl_r = sum((w * g[0] for w, g in zip(weights, FLOW_GRID))) / den\n       self.fl_m = sum((w * g[1] for w, g in zip(weights, FLOW_GRID))) / den\n     s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n  s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\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\n  def AB(x):\n   k = (x - phat) / s\n   a = s * lpm(k)\n   b = a - (x - phat)\n   if _spread != 4:\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   else:\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   return ((1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb)\n  if H == 1:\n\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  if _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\n\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-06))) / px)\n    else:\n\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-06))) / px)\n   else:\n\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-06))) / px)\n  else:\n\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 tail <= 1e-06:\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-06))) / px)\n  ptk = phat * 100\n\n  def qbid(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   if _spread == 4:\n    if 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 _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      if P['nb1'] > 0 and t == 1 and (ptk < 1.0):\n       return 0.0\n     elif P['nb1'] > 0 and False:\n      return 0.0\n    elif P['nb1'] > 0 and False:\n     return 0.0\n   elif P['nb1'] > 0 and False:\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 _spread != 4:\n     if _spread == 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\n  def qask(t):\n   if not 1 <= t <= 99:\n    return 0.0\n   if _spread == 4:\n    if 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 _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      return qsize(b, a, t / 100.0, flow=True, cap=15000 if AH and t == 2 and (phat < 0.01) else None)\n     else:\n      return qsize(b, a, t / 100.0)\n    else:\n     return qsize(b, a, t / 100.0)\n   else:\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-06 else inv(1 - tail))) / (t / 100.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-09]\n  asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-09]\n  sticky = P['sticky'] > 0\n  if _spread == 4:\n   ma_ask = 50.0 if phat < 0.05 else P['min_ahead']\n\n  def top(orders, comp, step):\n   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\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     elif sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= max(P['min_ahead'], 400.0 / max(comp, 1)):\n      return comp\n    else:\n     threshold = max(P['min_ahead'], 20 * 100.0 / comp) if step == -1 and 1 <= comp <= 5 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   elif sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (ma_ask if step < 0 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  if _spread != 4:\n   if _spread != 3:\n    if _spread == 2:\n     s2f = bid_t == cb and qb > 0 and (cb / 100.0 < phat)\n  elif phat < 0.05 and bid_t >= 2:\n   qb *= 0.5\n  qa = qask(ask_t)\n  if _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\n     if 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  if _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\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   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\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     else:\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    else:\n     flow_scale = 1.0\n     target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\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   else:\n    flow_scale = self.f4_flow / 0.6\n    target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\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-09))))\n   g = t - ptick\n   if _spread != 4:\n    if _spread != 3:\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 _spread != 2:\n      if Y < target and phat < P['ammo_pmax'] and (bid_t <= t < ask_t) and (t / 100.0 - phat < P['ammo_maxpay']):\n       passive_t = t - 1\n       if passive_t >= max(1, bid_t):\n        amt, qam = (passive_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     elif t == 1 and 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    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   elif 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   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      stock_rate = flow_scale * P['ydf1']\n     else:\n      stock_rate = P['ydf1']\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    else:\n     stock_rate = P['ydf1']\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   else:\n    stock_rate = P['ydf1']\n    stock_rate *= self.f4_flow / 0.6\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   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      goal = min(flow_scale * qa, 0.3 * max(wealth, 0.0) / phat)\n     else:\n      goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n    else:\n     goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n   else:\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  if _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\n     if SB and 2 <= amt <= 5:\n      amt, qam = (0, 0.0)\n    else:\n     if hitB:\n      qb = 0.0\n      qam = 0.0\n      q1 = 0.0\n     if hitA:\n      qa = 0.0\n  actions = []\n  free = state.free_cash - 2.0\n  keep_ask = 0.0\n  new_b = []\n  new_a = []\n\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-09:\n    cancel(o)\n  kept_ids = set()\n\n  def manage(orders, t, q, comp):\n   kept = 0.0\n   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\n      banked = {}\n      bound_t, bound_q = (t, q)\n     else:\n      buy = comp == cb\n      held = {}\n   for o in orders:\n    if _spread != 4:\n     if _spread != 3:\n      if _spread != 2:\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 (o.remaining_quantity <= bound_q if o.side is Side.BUY else 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) or (s1 and ah and (o.side is Side.SELL) and (o.price_ticks <= 2)) or (LK and ah) 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      else:\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     elif 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    elif o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * (3.0 if o.side is Side.SELL and o.order_id in self.ahead and (o.price_ticks == comp) else 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 _spread != 4:\n    if _spread != 3:\n     if _spread == 2:\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 _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\n     kb = manage(bids, bid_t, qb, cb)\n    elif 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 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   else:\n    kb = manage(bids, 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-06\n  if amt and qam >= 0.01:\n   q = fl(qam)\n   if _spread != 4:\n    if _spread != 3:\n     if _spread != 2:\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     else:\n      out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n    else:\n     out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n   else:\n    out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n   free -= q * amt / 100.0 + 1e-06\n  if bid_t >= 1 and add_b >= 0.01:\n   q = fl(add_b)\n   if _spread == 4:\n    total_q = q\n    if 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   if _spread != 4:\n    free -= q * bid_t / 100.0 + 1e-06\n   else:\n    free -= total_q * bid_t / 100.0 + 1e-06\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) 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-06\n    if ask_t < ca:\n     self.ahead.add(oid)\n  f = int(math.floor(ptick + 1e-09))\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 _spread != 4:\n   if _spread != 3:\n    if _spread != 2:\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) and FLOW_CAPS[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    else:\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     self.s2_mb = {o.order_id for o in bids if o.order_id in kept_ids} | {o.client_order_id for o in out if o.side is Side.BUY and o.client_order_id}\n     self.s2_ma = {o.order_id for o in asks if o.order_id in kept_ids} | {o.client_order_id for o in out if o.side is Side.SELL and o.client_order_id}\n   else:\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  else:\n   self.f4_last = [None, None]\n   for side, tick, bound, conv, distance in ((0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat), (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","code_sha256":"4f9167dddd457f394e988bf9c9e2576dd6120834bfb8d93573ce9451fd587598","tried":["Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; Python 3.12.3; unsandboxed default 2000-step runs.","Reference CLI: 600 seeds 1000..1599, workers=4; exact author mean reproduced, zero failures; completed under five minutes, no counts halved.","Four source blocks selected by first-step spread, retaining source-specific arithmetic and constants. AST guards join common statement paths without changing arithmetic; unreachable other-spread paths omitted.","Final block merge: 2400 paired comparisons (600 per spread; 300 selected from 100000 and 300 from 104000), every result field identical to its original source. An earlier merge also passed 2400 pairs before helpers/constants were separated into private copies.","All nine textual patches reconstructed the supplied fix source exactly when applied to start; all transported to their block without conflict.","a1-free: 1000 paired spread-1 runs; half gains 0.2003454376935999, 0.5026515530815998; kept.","a1-jumps: 1000 paired spread-1 runs; half gains 0.01157165371580044, -0.9317582606276; dropped.","a2-ledger: 1000 paired spread-2 runs; half gains 1.0892823903585995, 1.093144040812; kept.","a2-after: 1000 paired spread-2 runs; half gains 0.9920426559752006, 0.7430513609328006; kept.","a3-free: 1000 paired spread-3 runs; half gains 0.2874991533861995, 0.3060200280850003; kept.","a3-rich: 1000 paired spread-3 runs; half gains 1.0534169749278004, 0.3872337464983997; kept.","a4-stock: 1000 paired spread-4 runs; half gains 0.3573658353869996, 0.4196024475772003; kept.","a4-free: 1000 paired spread-4 runs; half gains -0.07531248578080038, 0.29058598332040125; dropped.","a4-rich: 1000 paired spread-4 runs; half gains 0.33215620011300023, 0.2883742455178001; kept.","Frozen before holdout: seeds 130000..133999, 4000 paired runs; by_spread and diff are paired yours-minus-start differences, standard error uses sample standard deviation / sqrt(n).","Timed 200 seeds 130000..130199 per strategy sequentially in one process, after one untimed import warmup each; all timed results exactly equal their parallel holdout results. No seed access in strategy.","All source URLs re-fetched and exact quoted passages checked before submission.","Final audit recomputed all 9000 fix comparisons, both halves of each decision, all 4000 holdout pairs and statistics; verified 2400 exact pairs, serial/parallel equality, syntax, SHA-256, schema keys and byte limits."],"next":"Enter the code field as the strategy file by hand. Seven fixes retained; a1-jumps and a4-free dropped. Exact checks apply to the four-block merge before fixes; the holdout compares the frozen final strategy against start on identical seeds. No account key is needed."}