# r4-remove merge 01: six one-deletion screens against N

Ranked by mean_diff/se on the target spread (seeds 430000-430499, paired, untuned):

| # | key | spr | d | se | t |
|---|---|---|---|---|---|
| 1 | remove-s4-ask-risk-premium | 4 | +0.339 | 0.284 | +1.19 |
| 2 | remove-s3-cheap-ask-queue-threshold | 3 | +3.300 | 3.820 | +0.86 |
| 3 | remove-s1-queue-retention | 1 | -0.998 | 0.520 | -1.92 |
| 4 | remove-s4-bid-tranches | 4 | -0.321 | 0.155 | -2.07 |
| 5 | remove-s4-reduced-cheap-bids | 4 | -0.499 | 0.136 | -3.67 |
| 6 | remove-s3-qa-cap | 3 | -0.468 | 0.122 | -3.84 |

No row is flagged: all n=500, complete, SHA-256 of code matches, no failures, check values agree, incumbent mean 95.542. No row reaches 2 se, so no promotion. Inputs: .imd/reads/artifacts/item-<key> for the six keys; 3 results had a cited source fail re-read (see notes).

```json
{
 "rows": [
  {
   "key": "remove-s4-ask-risk-premium",
   "idea": "Remove only the spread-4 1.4x ask-loss risk premium; screen paired against incumbent N without tuning.",
   "what_was_deleted": "                if P['pL'] <= phat <= 0.95:\n                    b *= 1.4\nRemoved from qask(t), inside elif self.s == 4. Ask loss b now enters sizing without the extra 1.4 multiplier, as in other spreads. Retained the independently implemented spread-4 learned flow rate/mean sizing, all pricing, and all other mechanisms.",
   "not_applicable": false,
   "code_sha256": "324acde86027cc793cdb88482560d00c720494e60ceee8720b76ed03ebfb141e",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    4
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.54201511346659,
   "mean_diff": 0.07856379387599995,
   "se": 0.06602885009643784,
   "retail_diff": 0.36946327381700056,
   "arb_diff": -0.29089947994560006,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "4": {
     "n": 116,
     "mean_diff": 0.3386370425689653,
     "se": 0.2842117622502329,
     "sum_d": 39.281896937999974,
     "sum_d2": 1090.8584915960314
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.13.5",
   "flag": null,
   "source_recheck_warning": "The run reported that 1 source cited by this result did not hold on re-read. The result file cites no URL, so the affected claim cannot be identified; its numbers are self-reported and not re-run here."
  },
  {
   "key": "remove-s4-reduced-cheap-bids",
   "idea": "Delete only the spread-4 half-size reduction of cheap bids; no tuning.",
   "what_was_deleted": "        elif self.s == 4:\n            if phat < 0.05 and bid_t >= 2:\n                qb *= 0.5\n",
   "not_applicable": false,
   "code_sha256": "a4e92bbd806d5c9d633c0a2fac6a71e777168f3f63d915515ba88ef9edb9e2bb",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    4
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.54201511346659,
   "mean_diff": -0.11587716332539975,
   "se": 0.032883342564773384,
   "retail_diff": 0.03610994761440011,
   "arb_diff": -0.15198711093780012,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "4": {
     "n": 116,
     "mean_diff": -0.49947053157499893,
     "se": 0.13622756386731052,
     "sum_d": -57.938581662699875,
     "sum_d2": 276.5016559391139
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]",
   "flag": null,
   "source_recheck_warning": null
  },
  {
   "key": "remove-s4-bid-tranches",
   "idea": "Deletion: spread-4 bid tranches. N splits a spread-4 main bid (when bid_t is ahead of the rival and exactly ca-4, q>=4, notional >= 4*m) into a head half and a remainder; the candidate places one b...",
   "what_was_deleted": "            if self.s == 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.ad...",
   "not_applicable": false,
   "code_sha256": "9180d3d6f5d370bec543ad47e8afc934cac788e81e13ffa3ca402f2162b911bc",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    4
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.542015,
   "mean_diff": -0.074369,
   "se": 0.036292,
   "retail_diff": -0.077573,
   "arb_diff": 0.003204,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "4": {
     "n": 116,
     "mean_diff": -0.320555,
     "se": 0.154752,
     "sum_d": -37.184386,
     "sum_d2": 331.386793
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.12.3",
   "flag": null,
   "source_recheck_warning": null
  },
  {
   "key": "remove-s3-qa-cap",
   "idea": "Remove only the spread-3 inventory target cap imposed by the main ask quantity qa; no tuning.",
   "what_was_deleted": "Deleted exactly one line inside elif self.s == 3:\n                target = min(target, qa)\nThe existing self.s == 3 branch guards the deletion; all other source bytes are unchanged.",
   "not_applicable": false,
   "code_sha256": "d1a7a3d80765d9063d669b55d349dd816cd51f14de99757382776c515657af9b",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    3
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.5420151134666,
   "mean_diff": -0.12447464027040026,
   "se": 0.033648335107487534,
   "retail_diff": 0.01864388720759993,
   "arb_diff": -0.1431185274780001,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": -0.46794977545263255,
     "se": 0.12195471089532457,
     "sum_d": -62.23732013520013,
     "sum_d2": 290.23347668391455
    },
    "4": {
     "n": 116,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.12.3",
   "flag": null,
   "source_recheck_warning": "The run reported that 1 source cited by this result did not hold on re-read. The result file cites no URL, so the affected claim cannot be identified; its numbers are self-reported and not re-run here."
  },
  {
   "key": "remove-s3-cheap-ask-queue-threshold",
   "idea": "Without tuning, delete only the spread-3 cheap-ask queue-size threshold, retaining the rival-price quote whenever any eligible ahead ask exists at ticks 1 through 5; preserve the existing sticky ga...",
   "what_was_deleted": "Removed:\n                threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and 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:\nReplaced with:\n                if sticky and (any(o.price_ticks == comp and o.order_id in self.ahead for o i...",
   "not_applicable": false,
   "code_sha256": "4825cd0ff98624d385e559d79572683d10842d325ec6f07affe74ad264d11886",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    3
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.54201511346659,
   "mean_diff": 0.8778439116246004,
   "se": 1.0153928263373104,
   "retail_diff": -0.1313982226224001,
   "arb_diff": 1.0092421342452,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": 3.30016508129549,
     "se": 3.8199459638787134,
     "sum_d": 438.9219558123002,
     "sum_d2": 257625.44161501742
    },
    "4": {
     "n": 116,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.12.3",
   "flag": null,
   "source_recheck_warning": "The run reported that 1 source cited by this result did not hold on re-read. The result file cites no URL, so the affected claim cannot be identified; its numbers are self-reported and not re-run here."
  },
  {
   "key": "remove-s1-queue-retention",
   "idea": "Delete only spread-1 retention of resting orders away from the current target price.",
   "what_was_deleted": "In manage(), replaced the opening of the self.s == 1 branch:\n                if self.s == 1:\n                    ah = o.order_id in self.ahead\nwith:\n                if self.s == 1:\n                    if o.price_ticks != t:\n                        cancel(o)\n                        continue\n                    ah = o.order_id in self.ahead\nThis bypasses both AH off-target retention and QB off-ta...",
   "not_applicable": false,
   "code_sha256": "5e1848340ba7d35bd4cdb197bff7673ad09e7de683cbcd60a14fe6d05b9e1f3d",
   "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae",
   "target_spreads": [
    1
   ],
   "complete": true,
   "h_n": 500,
   "incumbent_mean": 95.54201511346659,
   "mean_diff": -0.2615163180124,
   "se": 0.13728715941955488,
   "retail_diff": -0.1842780122028,
   "arb_diff": -0.07723830580539998,
   "by_spread": {
    "1": {
     "n": 131,
     "mean_diff": -0.9981538855435115,
     "se": 0.5200724790897479,
     "sum_d": -130.7581590062,
     "sum_d2": 4736.7125455952055
    },
    "2": {
     "n": 120,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "3": {
     "n": 133,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    },
    "4": {
     "n": 116,
     "mean_diff": 0,
     "se": 0,
     "sum_d": 0,
     "sum_d2": 0
    }
   },
   "failures": [],
   "check_values_ok": true,
   "python_version": "3.12.3",
   "flag": null,
   "source_recheck_warning": null
  }
 ],
 "top": {
  "key": "remove-s4-ask-risk-premium",
  "code_sha256": "324acde86027cc793cdb88482560d00c720494e60ceee8720b76ed03ebfb141e",
  "target_spread": 4,
  "target_mean_diff": 0.3386370425689653,
  "target_se": 0.2842117622502329,
  "promotion": false,
  "code": "\"\"\"Exact per-spread merge: c1-pairs, c2-queue, a3-ledger, c4-all; no fixes.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\ndef _spread1():\n    P = 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)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(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(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    F_AH = 1\n    F_FL = 1\n    F_QB = 1\n    F_LK = 0\n    F_SB = 0\n    FLOW_CAPS = (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)\n    FLOW_GRID = []\n    FLOW_PRIORS = []\n    for _rn, _rw in ((-math.sqrt(0.6), 5 / 18), (0.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, 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:\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:\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.append((_r, _m, _parts, _norm, _tails))\n            FLOW_PRIORS.append(math.log(_rw * _mw))\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS)\n\ndef _spread2():\n    P = 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)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(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(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread3():\n    P = 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)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(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(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread4():\n    P = 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)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(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(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\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        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        initializing = self.s is None\n        if initializing:\n            self.s = max(1, (ca - cb + 1) // 2)\n            if self.s == 1:\n                self._scope = _spread1()\n            elif self.s == 2:\n                self._scope = _spread2()\n            elif self.s == 3:\n                self._scope = _spread3()\n            elif self.s == 4:\n                self._scope = _spread4()\n            self.params = self._scope[0].copy()\n        if self.s == 1:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS = self._scope\n        elif self.s == 2:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        elif self.s == 3:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        elif self.s == 4:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        if initializing:\n            if self.s == 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            elif 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                self.params.update({'kLf': 0.16})\n            elif self.s == 4:\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            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 == 1:\n            s1 = self.s == 1\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.s == 2:\n            if 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.s == 3:\n            if 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.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-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        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 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            elif self.s == 2:\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            elif self.s == 3:\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            elif 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            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 self.s == 1:\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 self.s == 1:\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            elif self.s == 2:\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            elif self.s == 3:\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            elif 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            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 self.s == 1:\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        elif self.s == 2:\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        elif self.s == 3:\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        elif self.s == 4:\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 self.s == 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 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\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 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 self.s == 1:\n                return qsize(b, a, t / 100.0, flow=True, cap=15000 if AH and t == 2 and (phat < 0.01) else None)\n            elif self.s == 2:\n                return qsize(b, a, t / 100.0)\n            elif self.s == 3:\n                return qsize(b, a, t / 100.0)\n            elif self.s == 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 self.s == 4:\n            ma_ask = 50.0 if self.s == 4 and phat < 0.05 else P['min_ahead']\n\n        def top(orders, comp, step):\n            if self.s == 1:\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 self.s == 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)) >= (P['min_ahead'] if self.s != 2 else max(P['min_ahead'], 400.0 / max(comp, 1))):\n                    return comp\n            elif self.s == 3:\n                threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and 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 self.s == 4:\n                if 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 self.s == 2:\n            s2f = self.s == 2 and bid_t == cb and (qb > 0) and (cb / 100.0 < phat)\n        elif self.s == 4:\n            if phat < 0.05 and bid_t >= 2:\n                qb *= 0.5\n        qa = qask(ask_t)\n        if self.s == 1:\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 self.s == 1:\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 self.s == 1:\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            elif self.s == 2:\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            elif self.s == 3:\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                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            elif self.s == 4:\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                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 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 self.s == 1:\n                stock_rate = flow_scale * P['ydf1']\n            elif self.s == 2:\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            elif self.s == 3:\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            elif self.s == 4:\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 self.s == 1:\n                goal = min(flow_scale * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 2:\n                goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 3:\n                goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 4:\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 self.s == 1:\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\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 self.s == 1:\n                banked = {}\n                bound_t, bound_q = (t, q)\n            elif 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 self.s == 1:\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                elif self.s == 2:\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                elif self.s == 3:\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                elif self.s == 4:\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)):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n            return kept\n        if self.s == 1:\n            kb = manage(bids, bid_t, qb, cb)\n        elif self.s == 2:\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 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        elif self.s == 3:\n            kb = manage(bids, bid_t, qb, cb)\n        elif self.s == 4:\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 self.s == 1:\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            elif self.s == 2:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            elif self.s == 3:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            elif self.s == 4:\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 self.s == 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 self.s == 1:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 2:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 3:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 4:\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 self.s == 1:\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        elif self.s == 2:\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        elif 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        elif self.s == 4:\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"
 },
 "notes": "All six rows screen one untuned deletion from N (sha256 bf0d179f...ffae) on seeds 430000-430499 (n=500, ~116-133 per target spread); off-target d is exactly 0 in every row; none touched finalist seeds 900000-903999 and none is a promotion. HARMFUL, keep the mechanism: s3 qa target cap (-0.468 se 0.122 on s3, t=-3.8, arbitrage loss), s4 half-size cheap bids (-0.499 se 0.136, t=-3.7, arbitrage loss), s4 bid tranches (-0.321 se 0.155, t=-2.1, retail loss), s1 off-target queue retention (-0.998 se 0.520, t=-1.9; borderline, keep). NEUTRAL/possibly positive, candidates for simplification: s4 1.4x ask risk premium (+0.339 se 0.284, t=1.19; retail +1.59 offset by arb -1.25) and s3 cheap-ask queue threshold (+3.30 se 3.82, t=0.86; very noisy, sum_d2 dominated by few seeds, arb +3.79). Neither clears 2 se; both need a measure item on more seeds before any simplification. Caveat: the ask-risk-premium, qa-cap and cheap-ask-threshold results each had 1 cited source that did not hold on re-read; their files list no URL, so their numbers stand as self-reported. ask-risk-premium ran on Python 3.13.5 (others 3.12.3) but reproduced the same incumbent mean and check values."
}
```