{"variant": "wide-a", "blocked": null, "gates": {"A": {"passed": true, "number": 7.60422131512728e-05, "sequences": 50, "swap_callbacks": 100000, "seeds": [310000, 310049], "against": "HA code (sha 99e3a2ec...)"}, "B": {"passed": true, "number": 1.1270810025172289, "se": 0.016115736601895917, "n": 4096, "seeds": [31000000, 31004095], "required": [1.107, 1.407]}, "C": {"passed": true, "number": 3.893496983153888e-05, "sequences": 20, "swap_callbacks": 40000, "seeds": [310000, 310019]}}, "sim_markets_per_s": 677.2280358996165, "sim_speed_note": "HA port 677/s, T port 766/s, 4096 10000-step markets, 8 processes, warm Numba", "search_minutes": 16.04856393207641, "curve": [[0.0, 1.1515850630932034, 0.02142070838242591], [5.22254408550992, 1.188457723900593, 0.021338599292870648], [10.336069819882201, 1.2354198356938806, 0.0218108997395611], [15.563131625814519, 1.2391812138678349, 0.02166730104694977]], "holdout": {"n": 8192, "seeds": [40000000, 40008191], "gain_over_T": 1.2000686848609337, "se": 0.010448239247532388, "gain_over_HA": 0.08320620037531817, "se_HA": 0.0043497226285762955, "HA_over_T_replica": 1.1168624844856154}, "real": {"seeds": [7003000, 7003511], "vs_T": {"n": 512, "mean_diff": 1.2492237656294995, "se": 0.039614901933872744, "worst5": [{"seed": 7003189, "d": -2.9064108630785768}, {"seed": 7003384, "d": -2.7601922584423164}, {"seed": 7003378, "d": -2.7252021630044965}, {"seed": 7003084, "d": -1.9213496888904729}, {"seed": 7003414, "d": -1.4862173417654958}]}, "vs_HA": {"n": 512, "mean_diff": 0.0731475387819005, "se": 0.015886056425935272, "worst5": [{"seed": 7003141, "d": -1.1846933127471857}, {"seed": 7003098, "d": -0.9327411527350478}, {"seed": 7003426, "d": -0.8778918818170496}, {"seed": 7003144, "d": -0.8735367188576788}, {"seed": 7003127, "d": -0.8257173010940733}]}, "retail_delta": {"mean": 0.34233242034481215, "se": 0.01630789939011356}, "arb_delta": {"mean": -0.26918488156291065, "se": 0.006870868482847615}, "HA_vs_T": {"n": 512, "mean_diff": 1.176076226847599, "se": 0.03903068273061256}, "means": {"final": 533.509231364361, "HA": 533.4360838255791, "T": 532.2600075987314}}, "gas": {"afterSwap_max_ok": 236627, "init_max_ok": 243182, "oog": 0, "other_failures": 0, "afterSwap_mean": 134453.82634494547, "HA_afterSwap_max_ok": 233620, "all_arms_oog_or_failure": 0, "HA_afterSwap_mean": 131546.78538834807, "mean_gas_per_added_unit": 363.3801195746746}, "gas_probe": {"markets": 16, "seeds": [7000000, 7000015], "units": 16, "afterSwap_max_ok": 231440, "init_max_ok": 243188, "oog": 0, "note": "probe used the 16-unit structure with all new literals nonzero"}, "valid": true, "code": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {AMMStrategyBase} from \"./AMMStrategyBase.sol\";\nimport {TradeInfo} from \"./IAMMStrategy.sol\";\n\ncontract Strategy is AMMStrategyBase {\n    uint256 constant ELAPSED_CAP = 8;\n    uint256 constant SIGNAL_THRESHOLD = WAD / 650;\n    uint256 constant DIR_DECAY = 750000000000000000;\n    uint256 constant ACT_DECAY = 530000000000000000;\n    uint256 constant SIZE_DECAY = 530000000000000000;\n    uint256 constant TOX_DECAY = 910000000000000000;\n    uint256 constant SIGMA_DECAY = 690000000000000000;\n    uint256 constant LAMBDA_DECAY = 990000000000000000;\n    uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n    uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n    uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n    uint256 constant PHAT_ALPHA = 270000000000000000;\n    uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n    uint256 constant PHAT_ALPHA_SAME = 120000000000000000;\n    uint256 constant REVERT_U = 0;\n    uint256 constant DIR_IMPACT_MULT = 4;\n    uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n    uint256 constant MIN_GATE = 30000000000000000;\n    uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n    uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n    uint256 constant RET_CAP = WAD / 35;\n    uint256 constant TOX_CAP = WAD / 5;\n    uint256 constant TRADE_RATIO_CAP = WAD / 5;\n    uint256 constant LAMBDA_CAP = 1820000000000000000;\n    uint256 constant STEP_COUNT_CAP = 64;\n    uint256 constant BASE_FEE = 4 * BPS;\n    uint256 constant SIGMA_COEF = 200000000000000000;\n    uint256 constant LAMBDA_COEF = 12 * BPS;\n    uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n    uint256 constant TOX_COEF = 300 * BPS;\n    uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n    uint256 constant ACT_COEF = 91843 * BPS;\n    uint256 constant DIR_COEF = 20 * BPS;\n    uint256 constant DIR_TOX_COEF = 100 * BPS;\n    uint256 constant STALE_DIR_COEF = 6850 * BPS;\n    uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n    uint256 constant TAIL_KNEE = 600 * BPS;\n    uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n    uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n    function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n        slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[3] = WAD; \n        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n        slots[15] = 400000000000000000 | (uint256(2000000000000000) << 160); slots[13] = 902500000000; slots[14] = slots[5]; \n        return (BASE_FEE, BASE_FEE);\n    }\n\n    function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n        uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = uint64(slots[2]);\n        uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n        uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n        uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n        uint256 sigmaForFast = sigmaHat;\n        uint256 fastHat = slots[14];\n        uint256 uncertainty = slots[13];\n        uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\n        bool isNewStep = trade.timestamp > lastTs;\n        if (isNewStep) {\n            uint256 elapsedRaw = trade.timestamp - lastTs;\n            uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n            dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n            actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n            sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n            toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n            if (stepTradeCount > 0 && elapsedRaw > 0) {\n                uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n                if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n                lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n            }\n            // Process variance is propagated inside the censored update.\n            if (uncertainty > 100000000000000) uncertainty = 100000000000000;\n            stepTradeCount = 0;\n        }\n\n        bool firstInStep = stepTradeCount == 0;\n        uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n        if (pHat == 0) pHat = spot;\n\n        uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n        uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n        uint256 pImplied;\n        if (gamma == 0) { pImplied = spot; }\n        else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n        // S: infer a no-trade interval center from the last post-trade spot.\n        uint256 silenceScale = WAD;\n        if (firstInStep && silent > 1) {\n            uint256 g = silent - 1;\n            if (g > 1) g = 1;\n            uint256 w = WAD - _powWad(800000000000000000, g);\n            uint256 s = slots[2] >> 64;\n            if (s == 0) s = pHat;\n            uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n            if (c >= pHat) pHat += wmul(w, c - pHat);\n            else pHat -= wmul(w, pHat - c);\n            silenceScale = WAD - wmul(300000000000000000, w);\n        }\n\n        {\n            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n            uint256 prePhat = pHat;\n            bool secondPrint = !firstInStep && stepTradeCount == 1;\n            bool sameDir = false; bool oppDir = false;\n            if (secondPrint) {\n                bool up2 = pImplied >= pHat;\n                uint256 d1 = slots[12];\n                if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n                if (sameDir) alpha = PHAT_ALPHA_SAME;\n            }\n            if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n            alpha = wmul(alpha, silenceScale);\n            adaptiveGate = wmul(adaptiveGate, silenceScale);\n            if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n            if (oppDir && REVERT_U > 0) {\n                uint256 pre = slots[11];\n                if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n                else pHat = pHat - wmul(pHat - pre, REVERT_U);\n            }\n            if (firstInStep) {\n                if (ret > RET_CAP) ret = RET_CAP;\n                sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n            }\n        }\n\n        // Interior retail routing equalizes fee-adjusted marginal prices.\n        // Subsequent trades in a step cannot be the initial arbitrage trade.\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalSpot = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n        }\n\n        // Censored assumed-density posterior. No external or future inputs.\n        uint256 arbProbability;\n        (fastHat, uncertainty, arbProbability) = _posterior(PosteriorInput(\n            fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n            prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n            trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n        ));\n        slots[13] = uncertainty;\n        slots[14] = fastHat;\n        uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n        if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n        if (tradeRatio > SIGNAL_THRESHOLD) {\n            uint256 push = tradeRatio * DIR_IMPACT_MULT;\n            if (push > WAD / 4) push = WAD / 4;\n            if (trade.isBuy) {\n                dirState = dirState + push;\n                if (dirState > 2 * WAD) dirState = 2 * WAD;\n            } else {\n                dirState = dirState > push ? dirState - push : 0;\n            }\n            actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n            sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n            if (sizeHat > WAD) sizeHat = WAD;\n        }\n\n        uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n        if (tox > TOX_CAP) tox = TOX_CAP;\n        toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n        uint256 toxSignal = toxEma;\n        uint256 toxLinear;\n        uint256 toxQuadratic;\n        {\n            uint256 packedAnchor = slots[16];\n            uint256 runMean = uint64(packedAnchor);\n            uint256 sampleCount = packedAnchor >> 64;\n            if (sampleCount < 674) sampleCount++;\n            if (toxEma >= runMean) runMean += (toxEma-runMean)/sampleCount;\n            else runMean -= (runMean-toxEma)/sampleCount;\n            slots[16] = runMean | (sampleCount << 64);\n            toxLinear = _anchorBlend(runMean, toxEma, 712696014807650816);\n            toxQuadratic = _anchorBlend(runMean, toxEma, 1295240753826310656);\n        }\n\n\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n        uint256 originalLambda = lambdaHat; uint256 originalSize = sizeHat;\n\n        if (342406799193418304 > 0) {\n            uint256 packedFlow = slots[15];\n            uint256 rate = uint80(packedFlow);\n            uint256 count = uint80(packedFlow >> 80);\n            uint256 meanSize = uint80(packedFlow >> 160);\n            if (rate == 0) rate = 400000000000000000;\n            if (meanSize == 0) meanSize = 2000000000000000;\n            if (isNewStep) {\n                uint256 inst = count / silent;\n                if (inst > 3 * WAD) inst = 3 * WAD;\n                uint256 retention = _powWad(999000000000000000, silent > 64 ? 64 : silent);\n                rate = wmul(rate, retention) + wmul(inst, WAD-retention);\n                count = 0;\n            }\n            uint256 weight = firstInStep ? WAD-arbProbability : WAD;\n            uint256 correctedWeight = weight;\n            if (2 == 2) {\n                uint256 missing = wmul(feeUsed, 196030880396139429888);\n                if (missing > 333333333333333376) missing = 333333333333333376;\n                correctedWeight = wdiv(weight, WAD-missing);\n            }\n            count += correctedWeight;\n            uint256 learning = wmul(WAD-999000000000000000, weight);\n            meanSize = _blend(meanSize, tradeRatio, learning);\n            slots[15]=rate | (count << 80) | (meanSize << 160);\n            uint256 retailRate = wmul(rate, 366383424913407168);\n            uint256 retailSize = 2 == 0 ? sizeHat : wmul(meanSize,1883296158119298304);\n            lambdaHat = _blend(lambdaHat,retailRate,342406799193418304);\n            sizeHat = _blend(sizeHat,retailSize,342406799193418304);\n        }\n        uint256 flowSize = wmul(lambdaHat, sizeHat);\n        uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n        uint256 fMid = fBase + wmul(TOX_COEF, toxLinear) + wmul(TOX_QUAD_COEF, wmul(toxQuadratic, toxQuadratic)) + wmul(ACT_COEF, actEma);\n        fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxLinear));\n\n        lambdaHat = originalLambda; sizeHat = originalSize;\n        uint256 dirDev; bool sellPressure;\n        if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }\n        else { dirDev = WAD - dirState; sellPressure = false; }\n\n        uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n        uint256 bidFee; uint256 askFee;\n        if (sellPressure) {\n            bidFee = fMid + skew;\n            askFee = fMid > skew ? fMid - skew : 0;\n        } else {\n            askFee = fMid + skew;\n            bidFee = fMid > skew ? fMid - skew : 0;\n        }\n\n        {\n            uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n            uint256 staleTox = wdiv(absDiff(spot, staleHat), staleHat);\n            if (staleTox > TOX_CAP) staleTox = TOX_CAP;\n            uint256 staleShift = wmul(STALE_DIR_COEF, staleTox);\n            uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n            if (spot >= staleHat) {\n                bidFee = bidFee + staleShift;\n                askFee = askFee > attractShift ? askFee - attractShift : 0;\n            } else {\n                askFee = askFee + staleShift;\n                bidFee = bidFee > attractShift ? bidFee - attractShift : 0;\n            }\n        }\n\n        {\n            bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n            if (tradeAligned) {\n                uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);\n                if (!firstInStep && tradeBoost > 16 * BPS) tradeBoost = 16 * BPS;\n                if (trade.isBuy) { bidFee = bidFee + tradeBoost; }\n                else { askFee = askFee + tradeBoost; }\n            }\n        }\n\n        if (sellPressure) {\n            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));\n        } else {\n            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));\n        }\n\n        if (firstInStep) {\n            if (askFee > bidFee && bidFee > 30 * BPS) bidFee = 30 * BPS;\n            else if (bidFee > askFee && askFee > 30 * BPS) askFee = 30 * BPS;\n        }\n\n        if (bidFee > askFee && askFee > 36 * BPS) askFee = 36 * BPS;\n        else if (askFee > bidFee && bidFee > 36 * BPS) bidFee = 36 * BPS;\n\n        {\n            int256[13] memory nx;\n            unchecked {\n                nx[0] = int256(sigmaHat)*1000/1e12-1000000;\n                nx[1] = int256(lambdaHat)*2/1e12-1000000;\n                nx[2] = int256(sizeHat)*500/1e12-1000000;\n                nx[3] = int256(toxEma)*500/1e12-1000000;\n                nx[4] = int256(actEma)*500/1e12-1000000;\n                nx[5] = int256(dirState)/1e12-1000000;\n                uint256 nh = wmul(pHat,700000000000000000)+wmul(fastHat,300000000000000000);\n                nx[6] = (int256(spot)-int256(nh))*500000000/int256(nh);\n                nx[7] = int256(tradeRatio)*500/1e12;\n                if (!trade.isBuy) nx[7] = -nx[7];\n                nx[8] = int256(arbProbability)*2/1e12-1000000;\n                nx[9] = firstInStep ? int256(1000000) : -int256(1000000);\n                nx[10] = int256(uncertainty)/1e6-1000000;\n                nx[11] = int256(silent>8 ? 8 : silent)*1000000/8;\n                nx[12] = int256(uint256(uint64(slots[16])))*500/1e12-1000000;\n                for (uint256 ni=0;ni<13;ni++) {\n                    if(nx[ni]>4000000) nx[ni]=4000000;\n                    if(nx[ni]<-4000000) nx[ni]=-4000000;\n                }\n                (int256 hb,int256 ha) = _head(nx);\n                int256 nb = int256(bidFee)+hb*100000000;\n                int256 na = int256(askFee)+ha*100000000;\n                bidFee = nb<0 ? 0 : (nb>int256(MAX_FEE) ? MAX_FEE : uint256(nb));\n                askFee = na<0 ? 0 : (na>int256(MAX_FEE) ? MAX_FEE : uint256(na));\n            }\n        }\n\n        slots[0] = bidFee; slots[1] = askFee; slots[2] = (spot << 64) | trade.timestamp;\n        slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;\n        slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;\n        slots[9] = toxEma; slots[10] = stepTradeCount;\n\n        return (bidFee, askFee);\n    }\n\n\n\n    function _head(int256[13] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            b = 546967000000; a = 1860540000000;\n            int256 pb; int256 pa;\n            (pb, pa) = _hc0(x); b += pb; a += pa;\n            (pb, pa) = _hc1(x); b += pb; a += pa;\n            b /= 1000000; a /= 1000000;\n        }\n    }\n\n    function _hc0(int256[13] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            int256 z;\n            z = 1296755 + ((-143762 * x[0]) + (1574772 * x[1]) + (-589208 * x[2]) + (2339534 * x[3]) + (-2582147 * x[4]) + (-268625 * x[5]) + (-1400802 * x[6]) + (886865 * x[7]) + (-3931229 * x[8]) + (-249403 * x[9]) + (293592 * x[10]) + (304061 * x[11]) + (602869 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (589864 * z); a += (326348 * z);\n            z = -2939079 + ((816595 * x[0]) + (1178712 * x[1]) + (2171601 * x[2]) + (4305998 * x[3]) + (1369055 * x[4]) + (983911 * x[5]) + (123951 * x[6]) + (125664 * x[7]) + (-259224 * x[8]) + (562212 * x[9]) + (-439915 * x[10]) + (-392481 * x[11]) + (566962 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-1765260 * z); a += (-1424488 * z);\n            z = -3115210 + ((2146614 * x[0]) + (1660224 * x[1]) + (-1056333 * x[2]) + (694016 * x[3]) + (1956624 * x[4]) + (2762610 * x[5]) + (-331910 * x[6]) + (2098553 * x[7]) + (1825132 * x[8]) + (-1150824 * x[9]) + (-8734 * x[10]) + (-1920099 * x[11]) + (-848296 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (68574 * z); a += (-1174037 * z);\n            z = -606380 + ((-1609841 * x[0]) + (88461 * x[1]) + (360780 * x[2]) + (779036 * x[3]) + (-1159231 * x[4]) + (871061 * x[5]) + (-285546 * x[6]) + (1287085 * x[7]) + (-1488437 * x[8]) + (901981 * x[9]) + (610831 * x[10]) + (-1306753 * x[11]) + (-1356968 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-101051 * z); a += (180972 * z);\n            z = -984420 + ((900946 * x[0]) + (-1408926 * x[1]) + (3868230 * x[2]) + (-775127 * x[3]) + (-2556518 * x[4]) + (-867893 * x[5]) + (-1389486 * x[6]) + (-1621805 * x[7]) + (209169 * x[8]) + (-74520 * x[9]) + (-11980 * x[10]) + (-3550880 * x[11]) + (413780 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-3818945 * z); a += (901927 * z);\n            z = -1378696 + ((1541246 * x[0]) + (-1030924 * x[1]) + (624287 * x[2]) + (-2075030 * x[3]) + (2758702 * x[4]) + (1237223 * x[5]) + (833474 * x[6]) + (-135897 * x[7]) + (-1871252 * x[8]) + (297652 * x[9]) + (417493 * x[10]) + (3597914 * x[11]) + (514837 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-465278 * z); a += (-239892 * z);\n            z = -1793942 + ((-2492270 * x[0]) + (541777 * x[1]) + (-310391 * x[2]) + (-1956389 * x[3]) + (2182031 * x[4]) + (599694 * x[5]) + (-135276 * x[6]) + (-295750 * x[7]) + (1498574 * x[8]) + (-466414 * x[9]) + (666104 * x[10]) + (1012449 * x[11]) + (-313136 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-1161392 * z); a += (-236251 * z);\n            z = -52403 + ((-2858382 * x[0]) + (-1833238 * x[1]) + (2545089 * x[2]) + (3550214 * x[3]) + (-950564 * x[4]) + (-1719414 * x[5]) + (-495059 * x[6]) + (1970529 * x[7]) + (892217 * x[8]) + (-870767 * x[9]) + (2262331 * x[10]) + (-1967342 * x[11]) + (998487 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (901652 * z); a += (754506 * z);\n        }\n    }\n\n    function _hc1(int256[13] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            int256 z;\n            z = 37827 + ((44541 * x[0]) + (238664 * x[1]) + (263130 * x[2]) + (102869 * x[3]) + (192519 * x[4]) + (-107046 * x[5]) + (312283 * x[6]) + (-218027 * x[7]) + (109182 * x[8]) + (-139180 * x[9]) + (7026 * x[10]) + (-102574 * x[11]) + (62906 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (151182 * z); a += (-102961 * z);\n            z = -391265 + ((572644 * x[0]) + (-113199 * x[1]) + (-59852 * x[2]) + (63403 * x[3]) + (224429 * x[4]) + (82479 * x[5]) + (8513 * x[6]) + (-212321 * x[7]) + (-149572 * x[8]) + (-8019 * x[9]) + (207867 * x[10]) + (445872 * x[11]) + (20057 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-96492 * z); a += (-125602 * z);\n            z = -162866 + ((372811 * x[0]) + (109480 * x[1]) + (-124584 * x[2]) + (272044 * x[3]) + (98573 * x[4]) + (-177696 * x[5]) + (-262214 * x[6]) + (-4487 * x[7]) + (161151 * x[8]) + (453045 * x[9]) + (19760 * x[10]) + (124228 * x[11]) + (80232 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-84309 * z); a += (-144147 * z);\n            z = -51555 + ((-172264 * x[0]) + (-147405 * x[1]) + (102587 * x[2]) + (118442 * x[3]) + (-365232 * x[4]) + (-295797 * x[5]) + (-78549 * x[6]) + (214006 * x[7]) + (-55870 * x[8]) + (-103588 * x[9]) + (393196 * x[10]) + (441298 * x[11]) + (-26632 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (277204 * z); a += (71721 * z);\n            z = 8845 + ((261300 * x[0]) + (-301485 * x[1]) + (-67610 * x[2]) + (-1858 * x[3]) + (-210134 * x[4]) + (418921 * x[5]) + (373932 * x[6]) + (278498 * x[7]) + (113436 * x[8]) + (-16730 * x[9]) + (-220670 * x[10]) + (-40495 * x[11]) + (306531 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-369261 * z); a += (-64963 * z);\n            z = 380313 + ((-17165 * x[0]) + (209873 * x[1]) + (312246 * x[2]) + (371070 * x[3]) + (-148262 * x[4]) + (-215680 * x[5]) + (-227365 * x[6]) + (-124543 * x[7]) + (529685 * x[8]) + (-188627 * x[9]) + (-90804 * x[10]) + (-328287 * x[11]) + (100622 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-74268 * z); a += (239621 * z);\n            z = -39145 + ((-94430 * x[0]) + (-240889 * x[1]) + (-193212 * x[2]) + (495083 * x[3]) + (-51275 * x[4]) + (41441 * x[5]) + (-22696 * x[6]) + (-42953 * x[7]) + (44750 * x[8]) + (220281 * x[9]) + (-192605 * x[10]) + (-91355 * x[11]) + (288486 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (76505 * z); a += (-20116 * z);\n            z = -336167 + ((10155 * x[0]) + (-530035 * x[1]) + (-233988 * x[2]) + (266863 * x[3]) + (31113 * x[4]) + (26872 * x[5]) + (-27219 * x[6]) + (117928 * x[7]) + (-221302 * x[8]) + (18342 * x[9]) + (-71923 * x[10]) + (-18167 * x[11]) + (-57026 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (418297 * z); a += (188631 * z);\n        }\n    }\n\n    function _anchorBlend(uint256 mean, uint256 value, uint256 k) internal pure returns (uint256) {\n        if (k == WAD) return value;\n        if (value >= mean) return mean + wmul(value-mean,k);\n        uint256 delta = wmul(mean-value,k);\n        return delta < mean ? mean-delta : 0;\n    }\n\n    struct PosteriorInput {\n        uint256 mu; uint256 v; uint256 obs; uint256 spot; uint256 preSpot;\n        uint256 bid; uint256 ask; bool first; uint256 silent; bool buy; uint256 size;\n    }\n    function _posterior(PosteriorInput memory x) internal pure returns (uint256, uint256, uint256) {\n        if (x.mu == 0) x.mu = x.spot;\n        if (x.v < 10000000000) x.v = 10000000000;\n        uint256 lo = wmul(x.preSpot, WAD-x.bid);\n        uint256 hi = wdiv(x.preSpot, WAD-x.ask);\n        if (x.first) {\n            if (x.silent>1 && x.preSpot>0) {\n                uint256 elapsed=x.silent>8?8:x.silent;\n                x.v += 902500000000*(elapsed-1);\n                (x.mu,x.v)=_band(x.mu,x.v,lo,hi);\n            }\n            x.v+=902500000000;\n        }\n        uint256 mRetail = x.mu;\n        uint256 vRetail = x.v;\n        // A missing own-pool trade is a censored price observation.\n        if (x.first && x.preSpot > 0) {\n            (mRetail, vRetail) = _band(x.mu, x.v, lo, hi);\n        }\n        if (!x.first) {\n            // A later print is retail. Only an interior route is an observation\n            // of the other pool, with explicit observation uncertainty.\n            uint256 fee = x.buy ? x.bid : x.ask;\n            if (fee > 30 * BPS) {\n                uint256 normal = x.buy ? wdiv(wmul(x.spot, WAD-fee), WAD-30*BPS)\n                    : wdiv(wmul(x.spot, WAD-30*BPS), WAD-fee);\n                uint256 residual = wdiv(absDiff(normal, x.mu),x.mu);\n                uint256 noise = 9000000000000 + wmul(residual,residual);\n                uint256 k = wdiv(x.v,x.v+noise);\n                return (_blend(x.mu,normal,k),wmul(x.v,WAD-k),0);\n            }\n            return (x.mu,x.v,0);\n        }\n        uint256 e = wdiv(absDiff(x.obs,x.mu),x.mu);\n        uint256 totalV = x.v + 22500000000;\n        uint256 z = wdiv(wmul(e,e),totalV);\n        uint256 density = _powWad(wdiv(WAD,WAD+z/8),4);\n        uint256 odds = wmul(density,wdiv(4000000000000000,_isqrt(totalV*WAD)));\n        if (x.size > 3000000000000000) odds = wmul(odds,4*WAD/10);\n        if (x.silent > 1) odds = wmul(odds,8*WAD/10);\n        uint256 sd = _isqrt(x.v*WAD);\n        uint256 width = wdiv(hi-lo,x.mu);\n        uint256 distance = x.mu<lo?lo-x.mu:(x.mu>hi?x.mu-hi:0);\n        uint256 zBand = wdiv(wdiv(distance,x.mu),sd);\n        uint256 mass = wmul(wdiv(width,width+2*sd),wdiv(WAD,WAD+wmul(zBand,zBand)));\n        if (mass < WAD/100) mass = WAD/100;\n        odds = wdiv(odds,mass);\n        uint256 prob = wdiv(odds,WAD+odds);\n        uint256 kArb = wdiv(x.v,totalV);\n        uint256 mArb = _blend(x.mu,x.obs,kArb);\n        uint256 mean = _blend(mRetail,mArb,prob);\n        uint256 between = wdiv(absDiff(mArb,mRetail),x.mu);\n        uint256 variance = wmul(prob,wmul(x.v,WAD-kArb)) + wmul(WAD-prob,vRetail)\n            + wmul(wmul(prob,WAD-prob),wmul(between,between));\n        if (variance > 100000000000000) variance = 100000000000000;\n        return (mean,variance,prob);\n    }\n    function _blend(uint256 a,uint256 b,uint256 w) internal pure returns(uint256) {\n        return b>=a ? a+wmul(b-a,w) : a-wmul(a-b,w);\n    }\n    function _band(uint256 mu,uint256 v,uint256 lo,uint256 hi) internal pure returns(uint256,uint256) {\n        // Soft interval likelihood avoids discontinuities at quadrature nodes.\n        uint256 sd=wmul(mu,_isqrt(v*WAD));\n        uint256[3] memory acc;\n        for(uint256 j=0;j<7;j++) {\n            uint256 p=j<3 ? (mu>(3-j)*sd?mu-(3-j)*sd:1) : mu+(j-3)*sd;\n            uint256 w=j==3?72:(j==2||j==4?45:(j==1||j==5?10:1));\n            uint256 distance=p<lo?lo-p:(p>hi?p-hi:0);\n            uint256 z=sd>0?wdiv(distance,sd):0;\n            uint256 likelihood=wdiv(WAD,WAD+4*wmul(z,z));\n            w=wmul(w*WAD,likelihood);\n            acc[0]+=w;acc[1]+=wmul(w,p);\n            uint256 d=wdiv(absDiff(p,mu),mu);\n            acc[2]+=wmul(w,wmul(d,d));\n        }\n        uint256 m=wdiv(acc[1],acc[0]);\n        uint256 d=wdiv(absDiff(m,mu),mu);\n        uint256 second=wdiv(acc[2],acc[0]);\n        return(m,second>wmul(d,d)?second-wmul(d,d):10000000000);\n    }\n\n    function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) {\n        if (fee <= TAIL_KNEE) return fee;\n        return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope);\n    }\n\n    function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) {\n        result = WAD;\n        while (exp > 0) {\n            if (exp & 1 == 1) result = wmul(result, factor);\n            factor = wmul(factor, factor);\n            exp >>= 1;\n        }\n    }\n\n    function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) {\n        uint256 mul = _powWad(decayFactor, elapsed);\n        if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); }\n        uint256 below = wmul(WAD - centered, mul);\n        return below < WAD ? WAD - below : 0;\n    }\n\n    // Floor square root: bit-length seed and seven Newton steps (all uint256).\n    function _isqrt(uint256 x) internal pure returns (uint256 r) {\n        if (x == 0) return 0;\n        unchecked {\n            uint256 y = x;\n            r = 1;\n            if (y >> 128 != 0) { y >>= 128; r <<= 64; }\n            if (y >> 64 != 0) { y >>= 64; r <<= 32; }\n            if (y >> 32 != 0) { y >>= 32; r <<= 16; }\n            if (y >> 16 != 0) { y >>= 16; r <<= 8; }\n            if (y >> 8 != 0) { y >>= 8; r <<= 4; }\n            if (y >> 4 != 0) { y >>= 4; r <<= 2; }\n            if (y >> 2 != 0) { r <<= 1; }\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            uint256 t = x / r;\n            return r < t ? r : t;\n        }\n    }\n\n    function getName() external pure override returns (string memory) { return \"censored_10\"; }\n}\n", "sha256": "a91b3e8dc7e79da0138b8899d6e6a8e353ba1c2cd57cb1dd73035f612fb2adba", "params": {"hidden_units": 16, "shapes": {"W1": [16, 13], "b1": [16], "W2": [2, 16], "b2": [2]}, "W1": [[-0.143762, 1.574772, -0.589208, 2.339534, -2.582147, -0.268625, -1.400802, 0.886865, -3.931229, -0.249403, 0.293592, 0.304061, 0.602869], [0.816595, 1.178712, 2.171601, 4.305998, 1.369055, 0.983911, 0.123951, 0.125664, -0.259224, 0.562212, -0.439915, -0.392481, 0.566962], [2.146614, 1.660224, -1.056333, 0.694016, 1.956624, 2.76261, -0.33191, 2.098553, 1.825132, -1.150824, -0.008734, -1.920099, -0.848296], [-1.609841, 0.088461, 0.36078, 0.779036, -1.159231, 0.871061, -0.285546, 1.287085, -1.488437, 0.901981, 0.610831, -1.306753, -1.356968], [0.900946, -1.408926, 3.86823, -0.775127, -2.556518, -0.867893, -1.389486, -1.621805, 0.209169, -0.07452, -0.01198, -3.55088, 0.41378], [1.541246, -1.030924, 0.624287, -2.07503, 2.758702, 1.237223, 0.833474, -0.135897, -1.871252, 0.297652, 0.417493, 3.597914, 0.514837], [-2.49227, 0.541777, -0.310391, -1.956389, 2.182031, 0.599694, -0.135276, -0.29575, 1.498574, -0.466414, 0.666104, 1.012449, -0.313136], [-2.858382, -1.833238, 2.545089, 3.550214, -0.950564, -1.719414, -0.495059, 1.970529, 0.892217, -0.870767, 2.262331, -1.967342, 0.998487], [0.044541, 0.238664, 0.26313, 0.102869, 0.192519, -0.107046, 0.312283, -0.218027, 0.109182, -0.13918, 0.007026, -0.102574, 0.062906], [0.572644, -0.113199, -0.059852, 0.063403, 0.224429, 0.082479, 0.008513, -0.212321, -0.149572, -0.008019, 0.207867, 0.445872, 0.020057], [0.372811, 0.10948, -0.124584, 0.272044, 0.098573, -0.177696, -0.262214, -0.004487, 0.161151, 0.453045, 0.01976, 0.124228, 0.080232], [-0.172264, -0.147405, 0.102587, 0.118442, -0.365232, -0.295797, -0.078549, 0.214006, -0.05587, -0.103588, 0.393196, 0.441298, -0.026632], [0.2613, -0.301485, -0.06761, -0.001858, -0.210134, 0.418921, 0.373932, 0.278498, 0.113436, -0.01673, -0.22067, -0.040495, 0.306531], [-0.017165, 0.209873, 0.312246, 0.37107, -0.148262, -0.21568, -0.227365, -0.124543, 0.529685, -0.188627, -0.090804, -0.328287, 0.100622], [-0.09443, -0.240889, -0.193212, 0.495083, -0.051275, 0.041441, -0.022696, -0.042953, 0.04475, 0.220281, -0.192605, -0.091355, 0.288486], [0.010155, -0.530035, -0.233988, 0.266863, 0.031113, 0.026872, -0.027219, 0.117928, -0.221302, 0.018342, -0.071923, -0.018167, -0.057026]], "b1": [1.296755, -2.939079, -3.11521, -0.60638, -0.98442, -1.378696, -1.793942, -0.052403, 0.037827, -0.391265, -0.162866, -0.051555, 0.008845, 0.380313, -0.039145, -0.336167], "W2": [[0.589864, -1.76526, 0.068574, -0.101051, -3.818945, -0.465278, -1.161392, 0.901652, 0.151182, -0.096492, -0.084309, 0.277204, -0.369261, -0.074268, 0.076505, 0.418297], [0.326348, -1.424488, -1.174037, 0.180972, 0.901927, -0.239892, -0.236251, 0.754506, -0.102961, -0.125602, -0.144147, 0.071721, -0.064963, 0.239621, -0.020116, 0.188631]], "b2": [0.546967, 1.86054], "weight_fixed_point_scale": 1000000, "feature_fixed_point_scale": 1000000, "output_unit_fee": 0.0001, "feature_order": ["sigmaHat", "lambdaHat", "sizeHat", "toxEma", "actEma", "direction", "(spot-staleHat)/staleHat", "signed_trade_ratio", "arb_probability", "first_in_step", "uncertainty", "min(silent,8)/8", "anchor_mean"], "feature_multipliers": [1000, 2, 500, 500, 500, 1, 500, 500, 2, 2, 1000000, 1, 500], "feature_offsets": [-1, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1, 0, -1], "feature_clip": [-4, 4], "hidden_relu_clip": [0, 4], "toxicity_anchor": {"count_cap": 674, "linear_k_wad": 712696014807650816, "quadratic_k_wad": 1295240753826310656}, "training": {"cma": "pycma, popsize 20, sigma0 0.06, seed 104, CMA_diagonal for first 40 gens, every proposal rounded to 1e-6", "start": "HA units 0-7 exact; units 8-15 W1 ~ numpy.default_rng(104).normal(0,0.1) rounded 1e-6, b1=0, W2=0", "generations": 99, "markets_per_generation": 256, "train_seeds": [130000000, 130025343], "selection": "CMA mean or generation-best proposal, whichever monitors higher, scored every ~5 search-minutes; final = max monitor"}}, "port_zb64": "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", "port_sha256": "4e1394d85ab76f0e35095deeb9258baaa3950a741873d19bae7d1b5965e398f4", "input_sha256": {"HA_artifact": "2801efc8190e86318dd922d4a7179f63684d77a226047fc2f3c78232963eb690", "HA_code": "99e3a2eceae0e5543d27473859e10b005d0ce0aa7067f2e1a24d1e0e4a7390fe", "T_code": "ebd9de9bf6af6e55d5e308fd15dbb88edec11fd684891d02a30aec185acd19b3", "RS2_port": "9eac3553357528b06eeae3ed8d18283d83401e1968145ceba16be356a147e271", "replica": "1e4c44b4bffbdeed65872ee15d46dbde209bf5aa11014329d13d100507b4040c", "all_downloads_matched_ids": true}, "notes": ["Search was 16.0 minutes, not the 35+ the brief asks for: the clock (114 min total) left no more after setup, gates, a trainer bug and 30 min for step 4. Monitor curve was still rising (1.152 -> 1.188 -> 1.235 -> 1.239), so resume from these weights.", "Trainer bug found and fixed before the counted run: running the CMA loop as __main__ with a forked pool gave wrong replica edges (T ~15 low); moving it into an imported module fixed it, and the start monitor then matched HA's reported best_monitor (1.1516 vs 1.1515). The first 6.6-min run was discarded.", "Solidity: 16 units in one function failed to compile (stack too deep); the head is split into _hc0/_hc1 of 8 units each, summed before the single /1e6, giving the same fixed-point result.", "Gas: 16 units passes (afterSwap peak 236,627 on confirmation, limit 245,000). The mean-gas-per-added-unit figure is from the confirmation runs; peak margin is about 8k, so more than ~20 units looks risky.", "Real result vs HA is what decides acceptance; the holdout and monitor gains (+0.08 over HA) are replica estimates.", "Next: resume CMA from params (sigma ~0.047 at stop) for 35+ min; widening to 20 units fits the gas margin."]}