{"key":"t-a","status":"complete","approach":"New-incumbent code-free reference calibration, block t-a: exact immutable combine-cash candidate C versus verified incumbent B, paired on seeds 310000..310499.","tried":["Only the assigned immutable candidate; no tuning, code changes, substitute seeds or repeated simulations. First ten timing pairs are retained in the 500-pair measurement."],"next":"Provide the B-only fixture to later blind items. This block does not promote a candidate; finalist seeds 900000..903999 were never run.","code":"\"\"\"Stale-quote defence with tick probes, a sub-tick belief and cheap YES stock.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low\nasks.  That YES is bought when it is cheap: a large bid rests at tick 1 while p\nis above it, so the arbitrageur fills it on the crossing for about 0.1 tick a\nshare instead of nearly a full tick once p is near zero, and smaller bids sit on\nwhichever tick p is within 0.15 of.  Below tick 1 the estimate of p decays with\nthe time spent there, since no probe can see it.\n\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\nP = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n         qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05,\n         ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n         fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0,\n         ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0,\n         ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\nP.update({'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'fu': 0.25, 'Hu': 500})\nC = {'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'reserve': 200, 'scar': 0.0025, 'fu': 0.25, 'Hu': 500}\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\ndef cdf(x): return 0.5 * (1.0 + math.erf(x / SQ2))\ndef pdf(x): return math.exp(-0.5 * x * x) / SQ2PI\ndef inv(p):\n    p = min(max(p, 1e-9), 1 - 1e-9)\n    t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n    x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n    x = -x if p < 0.5 else x\n    for _ in range(2):\n        d = pdf(x)\n        if d < 1e-12:\n            break\n        x -= (cdf(x) - p) / d\n    return x\ndef lpm(k):\n    return pdf(k) + k * cdf(k)\ndef fl(q):\n    return math.floor(q * 100 + 1e-9) / 100\n\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\n\n\nclass Strategy(BaseStrategy):\n    def __init__(self):\n        self.n = 0\n        self.ahead = set()     # main orders placed strictly ahead of any competitor order at their tick\n        self.res = {}          # order id -> uncovered quantity at placement\n        self.bc = None         # belief: sub-tick grid centres (ticks)\n        self.bw = None         # belief: weights\n        self.st = 0.5          # last one-step sd in ticks\n        self.pcb = self.pca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None          # competitor spread parameter\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        if self.s is None:\n            self.s = max(1, (ca - cb + 1) // 2)\n        lo, hi = cb, ca\n        for o in state.own_orders:\n            if o.side is Side.BUY:\n                lo = max(lo, o.price_ticks)\n            else:\n                hi = min(hi, o.price_ticks)\n        if P['pinf'] > 0:\n            sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n            sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n            ea = self.pa - sa\n            eb = self.pb - sb\n            if sa and ea:\n                lo = max(lo, min(max(ea), hi))\n            if eb and (sb or min(eb) <= P['p1t']):\n                hi = min(hi, max(min(eb), lo))\n        if P['jumpinfo'] > 0 and self.pcb is not None:\n            if ca > self.pca + 1:\n                lo = max(lo, ca - 1)\n            if cb < self.pcb - 1:\n                hi = min(hi, cb + 1)\n        self.pcb, self.pca = cb, ca\n        if lo > hi:\n            lo, hi = hi, lo\n        # sub-tick belief over p_(t-1): predict with one-step noise, truncate to [lo, hi]\n        wid = max(hi - lo, 1e-6)\n        nb = max(2, min(48, int(round(wid * P['bins']))))\n        cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n        if self.bc is None or P['filt'] <= 0:\n            ws = [1.0 / nb] * nb\n        else:\n            sg = max(self.st, 0.6 * wid / nb)\n            k = -0.5 / (sg * sg)\n            ws = []\n            uni = P['uni'] * sg\n            for c in cs:\n                t = uni\n                for ci, wi in zip(self.bc, self.bw):\n                    d = c - ci\n                    d2 = d * d * k\n                    if d2 > -12.5:\n                        t += wi * math.exp(d2)\n                ws.append(t)\n            tot = sum(ws)\n            ws = [w / tot for w in ws]\n        self.bc, self.bw = cs, ws\n        mean_t = sum(c * w for c, w in zip(cs, ws))\n        var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n        phat = min(max(mean_t / 100.0, 0.002), 0.998)\n        var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n        sd = math.sqrt(H * var)\n        self.tb = self.tb + 1 if hi <= 1 else 0\n        if self.tb > 0 and P['zd'] > 0:\n            # below the last tick there is no probe: the score keeps walking away from it\n            phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n        z = inv(phat)\n        Z = z * sd\n        sp = pdf(z) / sd * P['sig']\n        self.st = sp * 100.0\n        s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n        sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n        jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n        lj = P['lam_j']\n\n        def AB(x):\n            k = (x - phat) / s\n            a = s * lpm(k)\n            b = a - (x - phat)\n            ja = sum(w * max(0.0, x - p) for p, w in jp)\n            jb = sum(w * max(0.0, p - x) for p, w in jp)\n            return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n\n        if H == 1:\n            def AB(x):\n                return (1 - phat) * x, phat * (1 - x)\n        rho = P['lam_r'] * 0.5\n        mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n        kA = P['kL'] if phat < P['pL'] else P['kA']\n\n        def qsize(loss, gain, px):\n            loss *= kA\n            if gain <= 0:\n                return 0.0\n            tail = loss / (rho * gain)\n            if tail >= 1.0:\n                return 0.0\n            return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n        ptk = phat * 100\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if phat * 100 - t < P['dmin']:\n                return 0.0\n            if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n                return 0.0\n            if phat < P['pL']:\n                ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n                a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            if phat < C.get('scar_p', .1):\n                a = max(0.0, a - C.get('scar', 0.0) * (1 - min(1.0, state.yes_inventory / C.get('stock', 3000.0))))\n            return min(C.get('askcap', P['qmax']), qsize(b, a, t / 100.0))\n\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n        sticky = P['sticky'] > 0\n        def top(orders, comp, step):\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= P['min_ahead']:\n                return comp\n            return comp + step\n        bid_t = top(bids, cb, 1)\n        ask_t = top(asks, ca, -1)\n        qb = min(C.get('bidcap', 3000.0), qbid(bid_t))\n        qa = qask(ask_t)\n\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          # let the competitor's 2-tick ask erode instead of fronting it for nothing\n        # ammunition: hold YES so that low asks are covered\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n                amt, qam = t, min(P['qf'], full - Y)     # a tick p has just crossed: nearly free\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)  # rest just under p: filled only on the crossing, or by retail\n\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            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        # order management\n        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            x = o.price_ticks / 100.0\n            if o.side is Side.BUY:\n                free += x * o.remaining_quantity\n            else:\n                free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n            self.ahead.discard(o.order_id)\n            self.res.pop(o.order_id, None)\n        for o in state.own_orders:\n            if o.remaining_quantity <= PROBE + 1e-9:\n                cancel(o)\n        kept_ids = set()\n        def manage(orders, t, q, comp):\n            kept = 0.0\n            for o in orders:\n                if not (C.get('recover', 0) and o.side is Side.SELL and t < comp and self.res.get(o.order_id, 0.0) > 1 and state.yes_inventory > C.get('recover_yes', 1) and state.free_cash < C.get('recover_cash', 200)) and 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        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\n        budget = P['fb'] * max(free, 0.0)\n        cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n        if cost > budget:\n            f = budget / cost\n            add_b *= f\n            qam *= f\n            cost = budget\n        out = []\n        q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n        if q1 >= 0.01:\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n            free -= fl(q1) / 100.0 + 1e-6\n        if amt and qam >= 0.01:\n            q = fl(qam)\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            free -= q * amt / 100.0 + 1e-6\n        if bid_t >= 1 and add_b >= 0.01:\n            q = fl(add_b)\n            oid = self._oid('b')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n            free -= q * bid_t / 100.0 + 1e-6\n            if bid_t > cb:\n                self.ahead.add(oid)\n        if ask_t <= 99 and add_a >= 0.01:\n            x = ask_t / 100.0\n            covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n                       for o in asks if o.order_id in kept_ids)\n            cov = max(0.0, Y - covk - 0.1)\n            unc = max(0.0, add_a - cov)\n            if unc > 0:\n                ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n                if H < P['Hu'] and phat < 0.05:\n                    ub = max(0.0, free * (1 - H / P['Hu']))\n                ub = min(ub, max(0.0, free - C.get('reserve', 0.0) * min(1.0, H / C.get('release', 50.0))))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # probes: tiny orders that the arbitrageur removes when p crosses them\n        f = int(math.floor(ptick + 1e-9))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n                    self.pb.add(t)\n            for t in range(f + 1 - r, f + 2):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n                    self.pa.add(t)\n        return actions + out\n","code_sha256":"baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273","incumbent_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","tuning":null,"paired":{"seeds":{"start":310000,"end":310499,"inclusive":true},"n":500,"sum_d":-212.88430943989968,"sum_d2":864337.8106017043,"mean_diff":-0.4257686188797994,"se":1.861159992480063,"C_mean_edges":{"total_edge":98.4957094597722,"retail_edge":120.1905402060554,"arb_edge":-21.694830746262},"B_mean_edges":{"total_edge":98.921478078652,"retail_edge":122.97223197808721,"arb_edge":-24.050753899438803},"retail_diff":-2.781691772031801,"arb_diff":2.3559231531768,"complete":true,"role":"assigned holdout/reference measurement block; no tuning; not finalist seeds","difference_sign":"C minus B","se_method":"sample_SD(C.total_edge-B.total_edge)/sqrt(n), ddof=1; centered sum of squares","by_spread":{"1":{"n":124,"sum_d":-536.3199831977,"sum_d2":83260.146730886,"mean_diff":-4.325161154820162,"se":2.303665825898333,"C_mean_edges":{"total_edge":31.523552838925806,"retail_edge":44.616670525470965,"arb_edge":-13.093117686526613},"B_mean_edges":{"total_edge":35.848713993745974,"retail_edge":48.31200867448306,"arb_edge":-12.463294680695968},"retail_diff":-3.695338149012098,"arb_diff":-0.6298230058306452},"2":{"n":136,"sum_d":-7.585957892899642,"sum_d2":20923.091628581227,"mean_diff":-0.055779102153673835,"se":1.067510605955206,"C_mean_edges":{"total_edge":86.44560518213088,"retail_edge":109.62056104372647,"arb_edge":-23.17495586155956},"B_mean_edges":{"total_edge":86.50138428428455,"retail_edge":113.15410723452206,"arb_edge":-26.652722950211768},"retail_diff":-3.5335461907955894,"arb_diff":3.477767088652206},"3":{"n":118,"sum_d":643.4295722590997,"sum_d2":741571.8867762288,"mean_diff":5.4527929852466075,"se":7.31160800752237,"C_mean_edges":{"total_edge":124.66089306914407,"retail_edge":153.17855982708306,"arb_edge":-28.51766675795254},"B_mean_edges":{"total_edge":119.20810008389746,"retail_edge":156.41956198510002,"arb_edge":-37.21146190122966},"retail_diff":-3.24100215801695,"arb_diff":8.693795143277118},"4":{"n":122,"sum_d":-312.4079406083997,"sum_d2":18582.68546600821,"mean_diff":-2.560720824659014,"se":1.0975547684590516,"C_mean_edges":{"total_edge":154.6913646797582,"retail_edge":176.8798081666123,"arb_edge":-22.188443486813114},"B_mean_edges":{"total_edge":157.2520855044172,"retail_edge":177.45049192845,"arb_edge":-20.198406424091804},"retail_diff":-0.5706837618377057,"arb_diff":-1.9900370627213113}}},"failures":[],"missing_seeds":[],"seconds_per_simulation":1.399393435573671,"timing":{"simulations_attempted":1000,"simulation_seconds":1399.393435573671,"wall_seconds":1400.0331881057937,"simulation_time_limit_seconds":2700,"stopped_at_time_limit":false,"first_10_pairs":{"n_pairs":10,"seed_start":310000,"seed_end":310009,"total_seconds":28.568235193844885,"seconds_per_simulation":1.4284117596922443,"pairs":[[310000,1.5419601460453123,1.6622865691315383],[310001,1.415663949912414,1.4287877038586885],[310002,0.9931625979952514,1.2675137659534812],[310003,1.2525933089200407,1.3402353529818356],[310004,1.4723524199798703,1.4317406890913844],[310005,1.0512248419690877,1.0939189619384706],[310006,1.4571312919724733,1.458039325894788],[310007,1.4685239179525524,1.6090610320679843],[310008,1.5149731040000916,1.6461717700585723],[310009,1.7291018250398338,1.733792619081214]]},"C_seconds_per_simulation":1.3632255867025815,"B_seconds_per_simulation":1.4355612844447605},"checks":{"returned_seeds_checked":1000,"finite_edges_checked":1000,"source_hash_checks":"both exact UTF-8 hashes checked before run, after every simulation and during assembly","first_observed_spread":"s=max(1, ((first_ask or 100)-(first_bid or 0)+1)//2), before forwarding first StepState unchanged; checked against sampled and returned regime for both strategies","same_sampled_config":"one default sample_config(ChallengeConfig(), ParameterVariance(), seed=seed) object supplied to both engine runs; all returned regime fields checked","failed_true_seeds":{"C":[],"B":[]},"exceptions":[],"failed_pair_policy":"finite returned failed results are retained in paired statistics; any failure or missing pair makes complete=false; no retries","callbacks_per_successful_simulation":2000,"factory_isolation":"fresh load_strategy_factory call, module, factory and strategy instance for every simulation","strategy_imports":["math","orderbook_pm_challenge.strategy","orderbook_pm_challenge.types"],"strategy_observations":"only unmodified StepState; strategies receive no seed or sampled config","fixture":"decoded locally; verified every row, order, count, finite value, SHA256 and exact round-trip float equality","reserved_finalist_seeds_run":0},"simulator_commit":"b244530ee2a6247b5f930830eeca9dd950da0e7e","reproduction":{"python":"3.12.3","method":"Use the unmodified pinned simulator with the exact C and B JSON.code UTF-8 sources at the cited artifact URLs. In one Python OS process loop seed=310000..310499 in ascending order. cfg=sample_config(ChallengeConfig(),ParameterVariance(),seed=seed). For each label C then B call load_strategy_factory(path) afresh and SimulationEngine(cfg,factory,seed=seed).run(), with no workers or sandbox. A transparent on_step wrapper records only the first rival bid/ask for s and counts calls, then forwards the identical StepState and returns identical actions. Check returned seed, all sampled regime fields, finite edges, failed/error fields and source hashes. Never retry a simulation. Record each duration with perf_counter, retain first ten pairs, stop after 2700 cumulative simulation seconds. Aggregate completed pairs with math.fsum, d=C.total_edge-B.total_edge; SE=sqrt(fsum((d-mean_d)**2)/(n-1)/n), retail_diff and arb_diff are signed means of paired component differences. For each s compute the same aggregates. Encode B rows with json.dumps(rows,separators=(comma,colon),allow_nan=False).encode(UTF-8), zlib.compress(level=9), base64.b64encode; hash the uncompressed bytes.","base_config":"unmodified ChallengeConfig(), n_steps=2000","variance":"unmodified ParameterVariance()","strategy_sources":{"C":"https://api.imd.fun/artifacts/ecbc9087b4f238fc1b5b0d52f55af073f676c038bfb6756172b1e51480ac1741","B":"https://api.imd.fun/artifacts/db22aff7167a4798251ed3d20432509f30e511e4958799aba5b17b41bb39b4b6"},"simulator":"https://github.com/danrobinson/prediction-market-challenge/tree/b244530ee2a6247b5f930830eeca9dd950da0e7e","dependencies":"Python standard library and the pinned simulator only; no installation or third-party packages"},"fixture":{"codec":"base64(zlib(UTF-8 compact JSON))","row_count":500,"seed_start":310000,"seed_end":310499,"schema":["seed","s","total_edge","retail_edge","arb_edge"],"uncompressed_sha256":"8b8470ec5a570785cf61604bc9605c71f83a392ab71846ff6bc9759f65f1c314","code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","payload":"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"}}