{"variant":"th-a","blocked":null,"gates":{"A":{"passed":true,"number":7.60422131512728e-05,"units":"max absolute fee difference in bps","sequences":50,"swap_callbacks":100000,"threshold":0.01},"B":{"passed":true,"number":1.1271278373224305,"difference_from_supplied_real_gain":-0.1298721626775694,"se":0.01611522613616835,"n":4096,"required_interval":[1.107,1.407],"seeds":[31000000,31004095]},"C":{"passed":true,"number":0.00011536126623412635,"units":"max absolute fee difference in bps","sequences":50,"swap_callbacks":100000,"threshold":0.1}},"sim_markets_per_s":325.8756293533633,"search_minutes":70.0687754710787,"curve":[[0.0,1.1515077919987904,0.021420320033637877],[4.885647105949465,1.1515077919987904,0.021420320033637877],[5.3822865208649695,1.1515077919987904,0.021420320033637877],[10.71366105353615,1.1515077919987904,0.021420320033637877],[15.990279493100632,1.271979863957031,0.024355048458106796],[21.284051197037723,1.362938718273564,0.026166289530218205],[26.63643656000495,1.4036031498746213,0.02524277779883609],[31.95467998298894,1.4064599319766007,0.026145729206089912],[37.32443026127294,1.4434728557190502,0.027315054248209986],[42.68073342355589,1.4434728557190502,0.027315054248209986],[48.002728138770905,1.4550241853479453,0.02738278568353107],[53.38201242442398,1.543906961461209,0.02733131367664945],[58.72468437782566,1.560733773771872,0.026804880826866117],[63.99086553341088,1.560733773771872,0.026804880826866117],[69.39825799257572,1.5760565544960157,0.02679064395906955],[70.0687701783958,1.5760565544960157,0.02679064395906955]],"holdout":{"n":8192,"gain_over_T":1.538262993281796,"se":0.011599680975776863,"gain_over_HA":0.42140961704436564,"se_HA":0.008299750884847468},"real":{"seeds":[7001000,7001511],"vs_T":{"n":512,"mean_diff":1.5268429342340526,"se":0.04337219107560843,"worst5":[{"seed":7001342,"d":-2.535217783501821},{"seed":7001087,"d":-2.4671212919894288},{"seed":7001178,"d":-1.7098962306001795},{"seed":7001379,"d":-1.444232260041872},{"seed":7001088,"d":-1.314352097176652}]},"vs_HA":{"n":512,"mean_diff":0.3701919611609784,"se":0.03068890296452205,"worst5":[{"seed":7001392,"d":-2.219599158894539},{"seed":7001393,"d":-1.91274019062962},{"seed":7001510,"d":-1.52213732018555},{"seed":7001088,"d":-1.5140489044796368},{"seed":7001201,"d":-1.3994497620665243}]},"retail_delta":{"mean":-0.5826132273488169,"se":0.03138066825527134},"arb_delta":{"mean":0.9528051885097983,"se":0.015376899184542759}},"gas":{"afterSwap_max_ok":231358,"init_max_ok":243147,"oog":0,"other_failures":0},"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 = 1252766202173000;\n    uint256 constant DIR_DECAY = 724908139086560000;\n    uint256 constant ACT_DECAY = 668115479317573376;\n    uint256 constant SIZE_DECAY = 422668081931616192;\n    uint256 constant TOX_DECAY = 916770456428308736;\n    uint256 constant SIGMA_DECAY = 683932344553900672;\n    uint256 constant LAMBDA_DECAY = 989714145242425088;\n    uint256 constant SIZE_BLEND_DECAY = 829252018334151168;\n    uint256 constant TOX_BLEND_DECAY = 47993127274426912;\n    uint256 constant ACT_BLEND_DECAY = 983862729180940160;\n    uint256 constant PHAT_ALPHA = 239157641325866592;\n    uint256 constant PHAT_ALPHA_RETAIL = 55342945369369536;\n    uint256 constant PHAT_ALPHA_SAME = 135463375220832160;\n    uint256 constant REVERT_U = 0;\n    uint256 constant DIR_IMPACT_MULT = 4;\n    uint256 constant GATE_SIGMA_MULT = 6326684306974222336;\n    uint256 constant MIN_GATE = 28592074168111160;\n    uint256 constant TRADE_TOX_BOOST = 357314175129025792;\n    uint256 constant STALE_ATTRACT_FRAC = 897364233377190784;\n    uint256 constant RET_CAP = 25822696835652108;\n    uint256 constant TOX_CAP = 203098909254385248;\n    uint256 constant TRADE_RATIO_CAP = 221455814364995840;\n    uint256 constant LAMBDA_CAP = 1487024665229817344;\n    uint256 constant STEP_COUNT_CAP = 57;\n    uint256 constant BASE_FEE = 408347607775738;\n    uint256 constant SIGMA_COEF = 177151340725185888;\n    uint256 constant LAMBDA_COEF = 1120226891229501;\n    uint256 constant FLOW_SIZE_COEF = 566467230941507520;\n    uint256 constant TOX_COEF = 30804760292710680;\n    uint256 constant TOX_QUAD_COEF = 1667710361429514752;\n    uint256 constant ACT_COEF = 6859918175059293184;\n    uint256 constant DIR_COEF = 2463007811313886;\n    uint256 constant DIR_TOX_COEF = 8406225381484594;\n    uint256 constant STALE_DIR_COEF = 726017521512939648;\n    uint256 constant SIGMA_TOX_COEF = 58030048118668056;\n    uint256 constant TAIL_KNEE = 53471714052889224;\n    uint256 constant TAIL_SLOPE_PROTECT = 838230595408997504;\n    uint256 constant TAIL_SLOPE_ATTRACT = 771971807017047552;\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 < 638) 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, 676297844586462080);\n            toxQuadratic = _anchorBlend(runMean, toxEma, 1182546486430324480);\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 = 1001310000000; a = 1372933000000;\n            int256 z;\n            z = 1305230 + ((-76918 * x[0]) + (711114 * x[1]) + (-488054 * x[2]) + (1348283 * x[3]) + (-3261521 * x[4]) + (-89416 * x[5]) + (-1013351 * x[6]) + (1080494 * x[7]) + (-4679033 * x[8]) + (-207184 * x[9]) + (-13660 * x[10]) + (122368 * x[11]) + (1081028 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (617872 * z); a += (371317 * z);\n            z = -1546631 + ((677949 * x[0]) + (859018 * x[1]) + (1655733 * x[2]) + (3145290 * x[3]) + (1146464 * x[4]) + (738894 * x[5]) + (125580 * x[6]) + (-213337 * x[7]) + (-367646 * x[8]) + (323461 * x[9]) + (-204524 * x[10]) + (-817914 * x[11]) + (572143 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-2254371 * z); a += (-1882619 * z);\n            z = -2666884 + ((2336705 * x[0]) + (3123999 * x[1]) + (-1509697 * x[2]) + (212099 * x[3]) + (3729638 * x[4]) + (4663417 * x[5]) + (-196460 * x[6]) + (2972771 * x[7]) + (1622317 * x[8]) + (-1025094 * x[9]) + (-32344 * x[10]) + (-1617459 * x[11]) + (-1149783 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-67869 * z); a += (-926204 * z);\n            z = -684168 + ((-2772526 * x[0]) + (-166940 * x[1]) + (785469 * x[2]) + (698468 * x[3]) + (-1189457 * x[4]) + (1364074 * x[5]) + (-287527 * x[6]) + (1356628 * x[7]) + (-1387860 * x[8]) + (1345624 * x[9]) + (436903 * x[10]) + (-1110139 * x[11]) + (-1407947 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-313069 * z); a += (205543 * z);\n            z = -950787 + ((1113713 * x[0]) + (-1990066 * x[1]) + (2344113 * x[2]) + (-500639 * x[3]) + (-2201482 * x[4]) + (-835196 * x[5]) + (-1033896 * x[6]) + (-1407900 * x[7]) + (497020 * x[8]) + (49494 * x[9]) + (-154273 * x[10]) + (-2979412 * x[11]) + (170655 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-3050669 * z); a += (599348 * z);\n            z = -1140696 + ((1160509 * x[0]) + (-938241 * x[1]) + (688303 * x[2]) + (-1059552 * x[3]) + (1953071 * x[4]) + (748920 * x[5]) + (900473 * x[6]) + (-343789 * x[7]) + (-1479561 * x[8]) + (85825 * x[9]) + (350655 * x[10]) + (4133272 * x[11]) + (317738 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-257131 * z); a += (-246775 * z);\n            z = -1485776 + ((-2107884 * x[0]) + (558518 * x[1]) + (-530845 * x[2]) + (-1470808 * x[3]) + (1657529 * x[4]) + (1091497 * x[5]) + (-371229 * x[6]) + (-96873 * x[7]) + (1398141 * x[8]) + (-571605 * x[9]) + (425218 * x[10]) + (1150211 * x[11]) + (-186954 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-2323972 * z); a += (-510586 * z);\n            z = -91471 + ((-1584556 * x[0]) + (-1795916 * x[1]) + (2567238 * x[2]) + (1881666 * x[3]) + (-648969 * x[4]) + (-1804886 * x[5]) + (-764449 * x[6]) + (1929042 * x[7]) + (841923 * x[8]) + (-582901 * x[9]) + (1822776 * x[10]) + (-1642320 * x[11]) + (516199 * x[12]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (1398695 * z); a += (513512 * z);\n            b /= 1000000; a /= 1000000;\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":"fa223ef69d6d7ded2fcd8a555f4a18c75bcb76ffb3d932266ee5a0aa277ff28a","params":{"W1":[[-0.076918,0.711114,-0.488054,1.348283,-3.261521,-0.089416,-1.013351,1.080494,-4.679033,-0.207184,-0.01366,0.122368,1.081028],[0.677949,0.859018,1.655733,3.14529,1.146464,0.738894,0.12558,-0.213337,-0.367646,0.323461,-0.204524,-0.817914,0.572143],[2.336705,3.123999,-1.509697,0.212099,3.729638,4.663417,-0.19646,2.972771,1.622317,-1.025094,-0.032344,-1.617459,-1.149783],[-2.772526,-0.16694,0.785469,0.698468,-1.189457,1.364074,-0.287527,1.356628,-1.38786,1.345624,0.436903,-1.110139,-1.407947],[1.113713,-1.990066,2.344113,-0.500639,-2.201482,-0.835196,-1.033896,-1.4079,0.49702,0.049494,-0.154273,-2.979412,0.170655],[1.160509,-0.938241,0.688303,-1.059552,1.953071,0.74892,0.900473,-0.343789,-1.479561,0.085825,0.350655,4.133272,0.317738],[-2.107884,0.558518,-0.530845,-1.470808,1.657529,1.091497,-0.371229,-0.096873,1.398141,-0.571605,0.425218,1.150211,-0.186954],[-1.584556,-1.795916,2.567238,1.881666,-0.648969,-1.804886,-0.764449,1.929042,0.841923,-0.582901,1.822776,-1.64232,0.516199]],"b1":[1.30523,-1.546631,-2.666884,-0.684168,-0.950787,-1.140696,-1.485776,-0.091471],"W2":[[0.617872,-2.254371,-0.067869,-0.313069,-3.050669,-0.257131,-2.323972,1.398695],[0.371317,-1.882619,-0.926204,0.205543,0.599348,-0.246775,-0.510586,0.513512]],"b2":[1.00131,1.372933],"constants":{"ELAPSED_CAP":8.0,"SIGNAL_THRESHOLD":0.001252766202173,"DIR_DECAY":0.72490813908656,"ACT_DECAY":0.6681154793175733,"SIZE_DECAY":0.4226680819316162,"TOX_DECAY":0.9167704564283087,"SIGMA_DECAY":0.6839323445539007,"LAMBDA_DECAY":0.9897141452424251,"SIZE_BLEND_DECAY":0.8292520183341512,"TOX_BLEND_DECAY":0.04799312727442691,"ACT_BLEND_DECAY":0.9838627291809402,"PHAT_ALPHA":0.2391576413258666,"PHAT_ALPHA_RETAIL":0.05534294536936954,"PHAT_ALPHA_SAME":0.13546337522083216,"DIR_IMPACT_MULT":4.0,"GATE_SIGMA_MULT":6.326684306974222,"MIN_GATE":0.02859207416811116,"TRADE_TOX_BOOST":0.3573141751290258,"STALE_ATTRACT_FRAC":0.8973642333771907,"RET_CAP":0.02582269683565211,"TOX_CAP":0.20309890925438526,"TRADE_RATIO_CAP":0.22145581436499584,"LAMBDA_CAP":1.4870246652298174,"STEP_COUNT_CAP":57.0,"BASE_FEE":0.0004083476077757383,"SIGMA_COEF":0.17715134072518587,"LAMBDA_COEF":0.0011202268912295006,"FLOW_SIZE_COEF":0.5664672309415075,"TOX_COEF":0.03080476029271068,"TOX_QUAD_COEF":1.6677103614295148,"ACT_COEF":6.859918175059293,"DIR_COEF":0.002463007811313886,"DIR_TOX_COEF":0.008406225381484594,"STALE_DIR_COEF":0.7260175215129396,"SIGMA_TOX_COEF":0.058030048118668055,"TAIL_KNEE":0.053471714052889224,"TAIL_SLOPE_PROTECT":0.8382305954089975,"TAIL_SLOPE_ATTRACT":0.7719718070170476,"ANCHOR_N":638.0,"ANCHOR_K1":0.676297844586462,"ANCHOR_K2":1.1825464864303246},"shapes":{"W1":[8,13],"b1":[8],"W2":[2,8],"b2":[2]},"constant_fixed_point_scale":1000000000000000000,"integer_constants":["ELAPSED_CAP","DIR_IMPACT_MULT","STEP_COUNT_CAP","ANCHOR_N"],"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"],"weight_fixed_point_scale":1000000,"feature_fixed_point_scale":1000000,"output_unit_fee":0.0001,"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],"training":{"seed":102,"population":16,"dimension":171,"initial_sigma":0.12,"coordinate_transform":"HA_value * 2**x, with x initially zero; phenotype coordinates are bounded before decoding","constant_mutation_scale_after_restart":0.35,"decay_mutation_scale_after_restart":"0.35 * min(1, (1-HA_value)/HA_value)","generations":265,"train_markets_per_generation":256,"seed_start":110000000,"seed_end":110067839,"monitor_seeds":[30000000,30002047],"selection":"highest observed mean on monitor seeds only","bounds":"each trained value between 0.5x and 2x its signed HA value; decays < 1; integer caps rounded; network weights rounded to 1e-6","restarts":[{"generation":44,"minutes":10.71388312833539,"reason":"isotropic log mutations did not improve monitor; use 0.35 scaling for constants, and complement/base scaling for decays","seed":102}]}},"port_zb64":"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","port_sha256":"6cb62369cfaef502855362a0aad7072d19883b3c8e650a357354e06df0654d13","notes":["Input artifact download hashes and embedded source hashes verified; pinned checkout 6b6921f8d463314aa7c96234e1be25a25245f704; simulator wheel SHA256 aedb68280aca34c110968f00148387c95885207913fb2cf19a1ab4c5cfd6887a. Setup and starter validation passed.","The neutral initial Solidity has identical tokens to HA apart from whitespace; the starting port uses the HA weights exactly. 38 nonzero declared T constants, both anchor coefficients and its count cap, plus 130 neural parameters are trained. REVERT_U stays zero because its allowed multiplicative interval is zero.","Gate A uses 50 sequences of 2000 callbacks from seeds 310000..310049 with common WAD-quantized inputs and alternating EVM/port-driven fills. Gate C repeats the same callback construction for the frozen policy. Gate B measures HA minus T on 4096 replica markets, and differs from the supplied real estimate 1.257 by the measured difference reported in the gate.","Speed is warmed full 10000-step HA markets across eight processes, excluding compilation. Search time sums saved segments including generation and monitor evaluations; process startup, setup, gaps, and the independent diagnostic check are excluded. Each command was bounded below eight minutes. No timer waiting was part of training.","Manual orchestration gaps reduced the final confirmation reserve to about 27 minutes, below the requested 30-minute reserve; search_minutes excludes those gaps. Frozen validation began at 16:21 UTC.","All candidates in each generation share its fresh 256-market block. The first isotropic log search failed to beat HA; the recorded restart uses smaller constant mutations and decay scaling proportional to (1-decay)/decay. The initial optional distribution-center monitor mistakenly decoded internal coordinates without the CMA bounds transform; this was corrected after two segments. Those center scores did not select a policy. Sampled training candidates were bounded correctly throughout.","Monitor checks consider generation winners and the bounded CMA distribution center; later checks also include the best training proposal since the previous monitor; the highest monitor score, including the initial HA policy, is retained. Curve points report cumulative search minutes, retained monitor gain over T, and paired SE. No holdout or real score selected the final policy.","Real arms each run alone against 30 bps Vanilla via amm_sim_rs.run_batch(...,8), exactly once per confirmation seed. SE uses paired sample SD/sqrt(n); worst5 lists the lowest five seed deltas. Retail and arb deltas are against HA, reconstructed by the supplied decomposition harness with each arm actual initial fee. Gas is from amm_sim_rs.gas_stats(), scoped to Submission callbacks.","The port uses float64 features; Solidity uses WAD constants and signed 1e6 features/weights with truncation. Gate C bounds the resulting fee arithmetic differences.","amm-match validate passed on the frozen Solidity. The delivered module embeds the full float port and replica, with no dependency on scratch files. Load params and score as described in its docstring; requires the setup numpy and numba runtime. No board submission or leaderboard rank is claimed. Next training can resume from these weights and constants with a larger population or more fresh markets per generation.","Real reference gas: {\"T\":{\"afterSwap_max_ok\":223348,\"init_max_ok\":243115,\"oog\":0,\"other_failures\":0},\"HA\":{\"afterSwap_max_ok\":231418,\"init_max_ok\":243147,\"oog\":0,\"other_failures\":0}}","Pretraining neutral probe: {\"afterSwap_max_ok\":231290,\"init_max_ok\":243147,\"oog\":0,\"other_failures\":0}","Real confirmation gain over HA was 0.3701919611609784, from retail delta -0.5826132273488169 and arb delta 0.9528051885097983. This does not close the requested top-10 gap. A next leg can train from these frozen values to recover retail edge while retaining the arb improvement; no leaderboard placement is established."]}