{"item":"tail-a","blocked":null,"design_url":"https://api.imdnotdead.fun/artifacts/149e412fa8f15cb71e0f44725d50a5510b0abff0c807ba6cc20f744fce42d5c1","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\n    uint256 constant DAR_ETA = 0;\n    uint256 constant DAR_DMAX = 20 * BPS;\n    bytes constant DAR_TABLE = hex\"e4e0dbd7d1cdc8c5c1c1bcb9b7b2afb0ceccc9cdcae4e4e4e4e4e0dbd6d1cdc7c3bfbbb7b7b2afada8a5a6c4c2bfe4e4e4e4e4e0dbd6d1ccc7c3bdb9b5b1adada8a6a39e9b9cbab8e4e4e4e4e0dbd6d1ccc7c2bdb9b3afaba7a3a39e9c99949192b1aee4e4dfdbd6d1ccc7c2bdb8b3afa9a5a19d999994928f8a8788a7e4dfdbd6d1ccc7c2bdb8b3aea9a59f9b97938f8f8a88858080e4dfdad6d1ccc7c2bdb8b3aea9a49f9b95918d898585808080e4dfdad5d1ccc7c2bdb8b3aea9a49f9a95918b878381808080e4dfdad5d0ccc7c2bdb8b3aea9a49f9a95908b868180808080e4e4e4e4cacdc9ccb0adafb2b7b9bcc1c1c5c8cdd1d7dbe0e4e4e4e4e4bfc2a6a3a5a8adafb2b7b7bbbfc3c7cdd1d6dbe0e4e4e4e4b89c999b9ea3a6a8adadb1b5b9bdc3c7ccd1d6dbe0e4e4ae928f9194999c9ea3a3a7abafb3b9bdc2c7ccd1d6dbe0e48885878a8f929499999da1a5a9afb3b8bdc2c7ccd1d6dbdfe4808085888a8f8f93979b9fa5a9aeb3b8bdc2c7ccd1d6dbdfe48080808585898d91959b9fa4a9aeb3b8bdc2c7ccd1d6dadfe48080808183878b91959a9fa4a9aeb3b8bdc2c7ccd1d5dadfe48080808081868b90959a9fa4a9aeb3b8bdc2c7ccd0d5dadfe4\";\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[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        (fastHat, uncertainty) = _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\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\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, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n        fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));\n\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        if (DAR_ETA > 0) {\n            int256 u=_darU(spot,fastHat);\n            uint256 ta=_darLookup(0,u,bidFee);\n            uint256 tb=_darLookup(1,u,askFee);\n            askFee=_darResidual(askFee,ta);\n            bidFee=_darResidual(bidFee,tb);\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        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    // Own post-trade spot and V10 posterior only; no new state.\n    function _darU(uint256 spot,uint256 ref) internal pure returns(int256) {\n        if(ref==0) return 0;\n        // Clamp before arithmetic; table endpoints are saturated.\n        if(spot>=ref+ref/50) return 60*int256(BPS);\n        if(spot<=ref-ref/50) return -60*int256(BPS);\n        int256 z=(int256(spot)-int256(ref))*int256(WAD)/int256(ref);\n        int256 u=z-z*z/(2*int256(WAD));\n        int256 lim=60*int256(BPS);\n        return u>lim?lim:(u < -lim ? -lim:u);\n    }\n    function _darLookup(uint256 side,int256 u,uint256 other) internal pure returns(uint256) {\n        bytes memory t=DAR_TABLE;\n        uint256 ux=uint256(u+60*int256(BPS));\n        uint256 i=ux/(5*BPS); uint256 wu=ux%(5*BPS);\n        if(i>=24){i=23;wu=5*BPS;}\n        uint256 j=other/(10*BPS);uint256 wf=other%(10*BPS);\n        if(j>=8){j=7;wf=10*BPS;}\n        uint256 p=side*225+j*25+i;\n        uint256 a=(uint256(uint8(t[p]))-128)*(5*BPS-wu)+(uint256(uint8(t[p+1]))-128)*wu;\n        uint256 b=(uint256(uint8(t[p+25]))-128)*(5*BPS-wu)+(uint256(uint8(t[p+26]))-128)*wu;\n        return (a*(10*BPS-wf)+b*wf)/(50*BPS);\n    }\n    function _darResidual(uint256 f,uint256 target) internal pure returns(uint256) {\n        int256 d=int256(target)-int256(f);int256 lim=int256(DAR_DMAX);\n        if(d>lim)d=lim;else if(d < -lim)d=-lim;\n        return clampFee(uint256(int256(f)+d*int256(DAR_ETA)/int256(WAD)));\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) {\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));\n            }\n            return (x.mu,x.v);\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);\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 \"tail-a_identity\"; }\n}\n","sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259","family":"A0","params":{"name":"identity","family":"A0","eta":0,"Dmax_bps":20,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259"},"parity":{"n":32,"max_abs_diff":0.0,"seeds":[786000,786031],"fields":["edge","reconstructed_arb","reconstructed_retail","retail_volume_y"],"disabled_sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259"},"screen":[{"retail_edge_delta":{"mean":-4.4908923626605874,"se":0.12268132763551193},"arb_edge_delta":{"mean":-1.537108816944821,"se":0.08483966515397066},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":-6.028001179605409,"se":0.10370206732158437,"worst":[{"seed":780230,"d":-11.434827873340282},{"seed":780106,"d":-10.586407472567657},{"seed":780222,"d":-10.349661261896813},{"seed":780157,"d":-10.28184800353472},{"seed":780196,"d":-10.15828858987993}],"name":"T_k0.5_p0.25","sha256":"3f1edb076d8b8977fcd00e27c7a16de52e82c3aca1f7a5395fc6b45995617b3f","gas":{"max_ok":200341,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2223588,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-4.743529171172967,"se":0.12349166624725559},"arb_edge_delta":{"mean":-1.394278180767881,"se":0.08460388704783915},"reconciliation_max_abs":9.947598300641403e-14,"n":256,"mean_diff":-6.137807351940851,"se":0.10444398038969215,"worst":[{"seed":780196,"d":-10.781457869867268},{"seed":780230,"d":-10.68134543083363},{"seed":780106,"d":-10.600104852996651},{"seed":780222,"d":-10.112209250463593},{"seed":780157,"d":-10.077442259271265}],"name":"T_k0.5_p0.5","sha256":"807de68942c46040ac364ee2b7c698dfe65d6732211742358fb0ed1b4558c7ba","gas":{"max_ok":200319,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2215416,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-4.925037454889897,"se":0.12598434463040326},"arb_edge_delta":{"mean":-1.3517215385916455,"se":0.08472307919557703},"reconciliation_max_abs":1.1368683772161603e-13,"n":256,"mean_diff":-6.276758993481543,"se":0.10729256133034466,"worst":[{"seed":780230,"d":-11.636162759333502},{"seed":780196,"d":-11.359854102305121},{"seed":780222,"d":-10.758173687815429},{"seed":780106,"d":-10.697015568257825},{"seed":780157,"d":-10.372215321557178}],"name":"T_k0.5_p0.75","sha256":"2e530d55ffa557338d9fcd4a6b1ffe634569c45ef380b0c4ab0aa8e620de6b9e","gas":{"max_ok":200327,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2209447,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-5.148085710389736,"se":0.1273602353948063},"arb_edge_delta":{"mean":-1.297076723124934,"se":0.08529099917071603},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":-6.44516243351467,"se":0.10718481659523652,"worst":[{"seed":780230,"d":-11.558093342594475},{"seed":780196,"d":-11.25662355806162},{"seed":780222,"d":-10.88960263744275},{"seed":780106,"d":-10.478879466768035},{"seed":780145,"d":-10.182127380858901}],"name":"T_k1.0_p0.25","sha256":"c5a8cfda23da6ce264e037c939767c69728039e15b7c87957e7bd0545ff57d75","gas":{"max_ok":200294,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2201569,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-5.5580018811028165,"se":0.12792413669437555},"arb_edge_delta":{"mean":-1.2035406633150834,"se":0.08536716743855635},"reconciliation_max_abs":1.1013412404281553e-13,"n":256,"mean_diff":-6.761542544417902,"se":0.10672547989856865,"worst":[{"seed":780196,"d":-11.665180911143466},{"seed":780230,"d":-11.456280982615567},{"seed":780222,"d":-10.831816265923976},{"seed":780106,"d":-10.681582876146877},{"seed":780002,"d":-10.651742488872173}],"name":"T_k1.0_p0.5","sha256":"8d09e179eacc889bc269807a2564fb99e14a88c53a47e4b1fbf85c5292c35ee2","gas":{"max_ok":200330,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2187388,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-5.749698550179067,"se":0.13073862405634215},"arb_edge_delta":{"mean":-1.1517452746374366,"se":0.08506282645227696},"reconciliation_max_abs":1.0302869668521453e-13,"n":256,"mean_diff":-6.9014438248165035,"se":0.10913209907153537,"worst":[{"seed":780196,"d":-12.1539132572899},{"seed":780230,"d":-12.017428494559681},{"seed":780222,"d":-11.378060419844473},{"seed":780157,"d":-10.965592029690015},{"seed":780002,"d":-10.82010346994332}],"name":"T_k1.0_p0.75","sha256":"4c2b133303acf9f32b3d0454c14db20edc7d31b4f974d813ba88c258b3ddb7db","gas":{"max_ok":200499,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2178367,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-0.5914705456524492,"se":0.06397332697500789},"arb_edge_delta":{"mean":0.09681362000187808,"se":0.03755934089241289},"reconciliation_max_abs":9.947598300641403e-14,"n":256,"mean_diff":-0.4946569256505715,"se":0.04525005071127552,"worst":[{"seed":780097,"d":-2.2910309740456114},{"seed":780002,"d":-2.28140107050217},{"seed":780196,"d":-2.2563781098405116},{"seed":780181,"d":-2.0291438399125354},{"seed":780076,"d":-1.9452207024204426}],"name":"T_small","sha256":"fb0e67fe05d800acaa941bc558a150c5ebcd8379e5f8edfd46f9af23048d9dd1","gas":{"max_ok":199012,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2501499,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-16.71310638490018,"se":0.2699009695578888},"arb_edge_delta":{"mean":-14.102360374600316,"se":0.2954919547125264},"reconciliation_max_abs":9.947598300641403e-14,"n":256,"mean_diff":-30.815466759500495,"se":0.242263550295085,"worst":[{"seed":780105,"d":-42.48518512042051},{"seed":780230,"d":-41.76520444264327},{"seed":780157,"d":-41.11051892558896},{"seed":780196,"d":-39.63402341874939},{"seed":780104,"d":-39.43760414015992}],"name":"T_full","sha256":"e264c97667ddd0ffd276e00ce077abfe3ea69d1ce35f7e5524b72c869999d6ac","gas":{"max_ok":201649,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":1662309,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-5.616825398111179,"se":0.1301045987353112},"arb_edge_delta":{"mean":-1.1953549588980672,"se":0.08472941122564752},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":-6.812180357009247,"se":0.10767205145034775,"worst":[{"seed":780230,"d":-12.12485829016748},{"seed":780196,"d":-11.465962468084513},{"seed":780222,"d":-11.311076027928607},{"seed":780106,"d":-11.27944681581107},{"seed":780145,"d":-10.472077719234449}],"name":"D3","sha256":"49977e6eb29da7b94c30cb42360f2a0e27885b3326b51a1e06905b2bdbc42ff5","gas":{"max_ok":199833,"init_max_ok":220969,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2183156,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-4.577697799293586,"se":0.1215798140083465},"arb_edge_delta":{"mean":-1.439245530091801,"se":0.08370705157774787},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":-6.01694332938539,"se":0.1034101107951337,"worst":[{"seed":780230,"d":-11.551709739107537},{"seed":780106,"d":-10.674718833932047},{"seed":780196,"d":-10.143554543693426},{"seed":780157,"d":-9.943089708786033},{"seed":780222,"d":-9.857261229547703}],"name":"D1","sha256":"71d20811adf5d1e7794295d22e4ad671f3a1a4e112a77ae650f267cc331d286c","gas":{"max_ok":196060,"init_max_ok":220975,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2222411,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-4.468755161223203,"se":0.11061004646908502},"arb_edge_delta":{"mean":-3.9629646459375856,"se":0.08671097407010023},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":-8.431719807160793,"se":0.09423036826437328,"worst":[{"seed":780230,"d":-13.366750670918805},{"seed":780222,"d":-13.210289407626647},{"seed":780198,"d":-12.75485135802046},{"seed":780196,"d":-12.233409375083056},{"seed":780070,"d":-11.761383095192741}],"name":"A3","sha256":"0973f0bfc7f02f76028efcb16af8f828fe9d92855384ad4c16391c8dbd7ffb3f","gas":{"max_ok":199158,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2351839,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":0.0,"se":0.0},"arb_edge_delta":{"mean":0.0,"se":0.0},"reconciliation_max_abs":0.0,"n":256,"mean_diff":0.0,"se":0.0,"worst":[{"seed":780000,"d":0.0},{"seed":780001,"d":0.0},{"seed":780002,"d":0.0},{"seed":780003,"d":0.0},{"seed":780004,"d":0.0}],"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","gas":{"max_ok":192838,"init_max_ok":220981,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2611533,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":0.0,"se":0.0},"arb_edge_delta":{"mean":0.0,"se":0.0},"reconciliation_max_abs":0.0,"n":256,"mean_diff":0.0,"se":0.0,"worst":[{"seed":780000,"d":0.0},{"seed":780001,"d":0.0},{"seed":780002,"d":0.0},{"seed":780003,"d":0.0},{"seed":780004,"d":0.0}],"name":"identity","sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259","gas":{"max_ok":193082,"init_max_ok":220981,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2611533,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-0.4926500961968887,"se":0.06132318991136199},"arb_edge_delta":{"mean":0.006067486025285743,"se":0.036223124648823456},"reconciliation_max_abs":1.0302869668521453e-13,"n":256,"mean_diff":-0.4865826101716042,"se":0.04295557528221532,"worst":[{"seed":780181,"d":-2.1964517852231893},{"seed":780097,"d":-2.155980867311996},{"seed":780230,"d":-2.0936434870864105},{"seed":780156,"d":-2.0319549886881987},{"seed":780190,"d":-2.0097611805490487}],"name":"best_D1","sha256":"840f90d240eba065c4fe01bf87f92027e3b9040abf21d5512d778664420b65d0","gas":{"max_ok":194751,"init_max_ok":220975,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2511255,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-0.47938249117074205,"se":0.05930679225009913},"arb_edge_delta":{"mean":-0.8302549409753683,"se":0.03719116573945056},"reconciliation_max_abs":1.0302869668521453e-13,"n":256,"mean_diff":-1.3096374321461102,"se":0.0432030680310931,"worst":[{"seed":780181,"d":-3.266549793708691},{"seed":780196,"d":-3.0875280340087556},{"seed":780045,"d":-3.0707963871976744},{"seed":780176,"d":-2.8588337188060677},{"seed":780198,"d":-2.8501827012446483}],"name":"best_A3","sha256":"1a723abd50b855e7e1c2c5ee8c904edcc1137409bbaecad44f6b29785b17cb1d","gas":{"max_ok":199112,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2543317,"getName":256}},"valid":true}],"recheck":[{"retail_edge_delta":{"mean":0.0,"se":0.0},"arb_edge_delta":{"mean":0.0,"se":0.0},"reconciliation_max_abs":0.0,"n":256,"mean_diff":0.0,"se":0.0,"worst":[{"seed":784000,"d":0.0},{"seed":784001,"d":0.0},{"seed":784002,"d":0.0},{"seed":784003,"d":0.0},{"seed":784004,"d":0.0}],"name":"identity","sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259","gas":{"max_ok":192971,"init_max_ok":220981,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2599932,"getName":256}},"valid":true},{"retail_edge_delta":{"mean":-0.5061654971993779,"se":0.046644564567063215},"arb_edge_delta":{"mean":0.05047367305518932,"se":0.021898778005666013},"reconciliation_max_abs":1.1368683772161603e-13,"n":256,"mean_diff":-0.4556918241441894,"se":0.04424534887896712,"worst":[{"seed":784230,"d":-2.5073838726932536},{"seed":784137,"d":-2.4093625954523077},{"seed":784040,"d":-2.3242501876787856},{"seed":784052,"d":-2.279968322381933},{"seed":784242,"d":-2.175067693270762}],"name":"best_D1","sha256":"840f90d240eba065c4fe01bf87f92027e3b9040abf21d5512d778664420b65d0","gas":{"max_ok":194657,"init_max_ok":220975,"oog":0,"errors":0,"calls":{"afterInitialize":256,"afterSwap":2499260,"getName":256}},"valid":true}],"held_out":{"frozen":{"retail_edge_delta":{"mean":0.0,"se":0.0},"arb_edge_delta":{"mean":0.0,"se":0.0},"reconciliation_max_abs":0.0,"n":512,"mean_diff":0.0,"se":0.0,"worst":[{"seed":785000,"d":0.0},{"seed":785001,"d":0.0},{"seed":785002,"d":0.0},{"seed":785003,"d":0.0},{"seed":785004,"d":0.0}],"name":"identity","sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259","gas":{"max_ok":195027,"init_max_ok":220981,"oog":0,"errors":0,"calls":{"afterInitialize":512,"afterSwap":5228018,"getName":512}},"valid":true},"ablation":{"retail_edge_delta":{"mean":-0.7502490785348656,"se":0.032861696039242036},"arb_edge_delta":{"mean":0.14363206036074486,"se":0.016075672866537667},"reconciliation_max_abs":1.7053025658242404e-13,"n":512,"mean_diff":-0.606617018174123,"se":0.031301836445944704,"worst":[{"seed":785313,"d":-2.689774202839658},{"seed":785253,"d":-2.6217291236989695},{"seed":785072,"d":-2.5112822481444255},{"seed":785130,"d":-2.386121868540613},{"seed":785126,"d":-2.3305867864539778}],"name":"T_small","sha256":"fb0e67fe05d800acaa941bc558a150c5ebcd8379e5f8edfd46f9af23048d9dd1","gas":{"max_ok":200953,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":512,"afterSwap":5006291,"getName":512}},"valid":true},"frozen_minus_ablation":{"retail_edge_delta":{"mean":0.7502490785348656,"se":0.032861696039242036},"arb_edge_delta":{"mean":-0.14363206036074486,"se":0.016075672866537667},"reconciliation_max_abs":1.7053025658242404e-13,"n":512,"mean_diff":0.606617018174123,"se":0.031301836445944704},"A3_control":{"retail_edge_delta":{"mean":-0.5973457454694109,"se":0.029995963054985548},"arb_edge_delta":{"mean":-0.7929286191532371,"se":0.018463706392456317},"reconciliation_max_abs":1.1368683772161603e-13,"n":512,"mean_diff":-1.3902743646226505,"se":0.030836275276055324,"worst":[{"seed":785075,"d":-3.80901683878983},{"seed":785294,"d":-3.4734705620807063},{"seed":785072,"d":-3.456954812100207},{"seed":785313,"d":-3.2539270761810712},{"seed":785389,"d":-3.209202657485548}],"name":"best_A3","sha256":"1a723abd50b855e7e1c2c5ee8c904edcc1137409bbaecad44f6b29785b17cb1d","gas":{"max_ok":200999,"init_max_ok":220987,"oog":0,"errors":0,"calls":{"afterInitialize":512,"afterSwap":5090733,"getName":512}},"valid":true},"enabled_DAR_minus_A3":{"retail_edge_delta":{"mean":-0.15290333306545467,"se":0.024157116887861946},"arb_edge_delta":{"mean":0.9365606795139819,"se":0.009505477700584531},"reconciliation_max_abs":1.4210854715202004e-13,"n":512,"mean_diff":0.7836573464485276,"se":0.024996649311297373},"D1_control":{"retail_edge_delta":{"mean":-0.6334776785813561,"se":0.031090609789480833},"arb_edge_delta":{"mean":0.05390334359830733,"se":0.016264235072009046},"reconciliation_max_abs":1.4210854715202004e-13,"n":512,"mean_diff":-0.5795743349830509,"se":0.030112821094764666,"worst":[{"seed":785075,"d":-3.2894318268708957},{"seed":785130,"d":-2.670746951020874},{"seed":785122,"d":-2.629095007277101},{"seed":785126,"d":-2.4576734522153743},{"seed":785313,"d":-2.4484927536929035}],"name":"best_D1","sha256":"840f90d240eba065c4fe01bf87f92027e3b9040abf21d5512d778664420b65d0","gas":{"max_ok":196683,"init_max_ok":220975,"oog":0,"errors":0,"calls":{"afterInitialize":512,"afterSwap":5026533,"getName":512}},"valid":true},"enabled_DAR_minus_D1":{"retail_edge_delta":{"mean":-0.11677139995350949,"se":0.014832506820731494},"arb_edge_delta":{"mean":0.08972871676243754,"se":0.0054837328688478555},"reconciliation_max_abs":1.7053025658242404e-13,"n":512,"mean_diff":-0.02704268319107206,"se":0.015016381913234752},"seeds":[785000,785511],"n":512,"v10_mean":524.5732077622027,"v10_gas":{"max_ok":194783,"init_max_ok":220981,"oog":0,"errors":0,"calls":{"afterInitialize":512,"afterSwap":5228018,"getName":512}},"ablation_role":"enable the strongest screen DAR residual; eta/Dmax reported explicitly (Dmax has no effect at eta=0). A3 held control matches enabled DAR eta/Dmax and prior."},"gas":{"max_ok":195027,"init_max_ok":220981,"oog":0,"errors":0},"falsifiers_run":{"D1_beta_1_vs_center_DAR":{"retail_edge_delta":{"mean":0.9803040818092312,"se":0.034857766077210306},"arb_edge_delta":{"mean":-0.23570486677671743,"se":0.013333633572198859},"reconciliation_max_abs":1.0658141036401503e-13,"n":256,"mean_diff":0.7445992150325123,"se":0.035325810538934126},"A3_vs_center_DAR":{"retail_edge_delta":{"mean":1.0892467198796145,"se":0.060372278250471687},"arb_edge_delta":{"mean":-2.7594239826225024,"se":0.026348363062295883},"reconciliation_max_abs":9.947598300641403e-14,"n":256,"mean_diff":-1.6701772627428906,"se":0.06537074854323807},"D3_relaxed_vs_center_DAR":{"retail_edge_delta":{"mean":-0.05882351700836197,"se":0.020174472632508714},"arb_edge_delta":{"mean":0.00818570441701627,"se":0.008587127716279381},"reconciliation_max_abs":1.0302869668521453e-13,"n":256,"mean_diff":-0.0506378125913447,"se":0.01986244374179686},"disabled_overlay":{"n":32,"max_abs_diff":0.0},"table_and_fixed_point_checks":{"evm_lookup_and_residual_checks":1451,"ln_approx_max_error_bps":0.0007232490918767098,"table_length":450,"table_fee_range":[0,100],"A1_A3_different_cells":445,"A1_A3_max_difference_bps":83,"mirror_symmetry_max_difference_bps":0},"scalar_vs_vector_table":{"cells":[{"side":0,"u_bps":0,"other_bps":30,"scalar_argmax_bps":43,"table_bps":43},{"side":1,"u_bps":0,"other_bps":30,"scalar_argmax_bps":43,"table_bps":43},{"side":0,"u_bps":30,"other_bps":30,"scalar_argmax_bps":25,"table_bps":25},{"side":1,"u_bps":30,"other_bps":30,"scalar_argmax_bps":71,"table_bps":71},{"side":0,"u_bps":-30,"other_bps":20,"scalar_argmax_bps":71,"table_bps":71},{"side":1,"u_bps":-30,"other_bps":40,"scalar_argmax_bps":20,"table_bps":20},{"side":0,"u_bps":-60,"other_bps":0,"scalar_argmax_bps":100,"table_bps":100},{"side":1,"u_bps":60,"other_bps":80,"scalar_argmax_bps":100,"table_bps":100}],"max_argmax_difference_bps":0},"arb_reconstruction":{"n":12,"generated_n":32,"selected_seeds":[786000,786004,786009,786011,786012,786013,786019,786022,786023,786024,786025,786029],"selection":"test-only no-retail realizations; evaluation runs retain every seed","seeds":[786000,786031],"n_steps":100,"retail_arrival_rate":0,"max_abs_retail_residual":1.0276363093808527e-11},"not_run":["F1 original 1000-seed rule: replaced by the item-specific 256-seed re-check, not claimed passed","F2 low-size-sigma table","per-trade restoring-fee sign trace","D2 kappa=0","D4 pe endpoints or route-conditioned prior","D5 arb-band term"],"matched_best_D1_vs_DAR":{"retail_edge_delta":{"mean":0.09882044945556046,"se":0.0212711233962015},"arb_edge_delta":{"mean":-0.09074613397659234,"se":0.00911958834557325},"reconciliation_max_abs":9.947598300641403e-14,"n":256,"mean_diff":0.008074315478967309,"se":0.021160492748211798},"matched_best_A3_vs_DAR":{"retail_edge_delta":{"mean":0.11208805448170711,"se":0.03286175278464879},"arb_edge_delta":{"mean":-0.9270685609772464,"se":0.013446475242718555},"reconciliation_max_abs":1.1013412404281553e-13,"n":256,"mean_diff":-0.8149805064955387,"se":0.03255575814074993}},"offline_source":{"fit":{"seeds":[780000,783999],"n":4000,"M":20.011943871353818,"sp":0.0009449183863006213,"rate":0.7999024224973194,"size_sigma":1.2,"method":"configuration means; no parity, recheck or held-out data"},"variants":[{"name":"identity","family":"A0","eta":0,"Dmax_bps":20,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259"},{"name":"T_k0.5_p0.25","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":0.5,"pe":0.25,"caps_relaxed":false,"sha256":"3f1edb076d8b8977fcd00e27c7a16de52e82c3aca1f7a5395fc6b45995617b3f"},{"name":"T_k0.5_p0.5","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":0.5,"pe":0.5,"caps_relaxed":false,"sha256":"807de68942c46040ac364ee2b7c698dfe65d6732211742358fb0ed1b4558c7ba"},{"name":"T_k0.5_p0.75","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":0.5,"pe":0.75,"caps_relaxed":false,"sha256":"2e530d55ffa557338d9fcd4a6b1ffe634569c45ef380b0c4ab0aa8e620de6b9e"},{"name":"T_k1.0_p0.25","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":1.0,"pe":0.25,"caps_relaxed":false,"sha256":"c5a8cfda23da6ce264e037c939767c69728039e15b7c87957e7bd0545ff57d75"},{"name":"T_k1.0_p0.5","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":1.0,"pe":0.5,"caps_relaxed":false,"sha256":"8d09e179eacc889bc269807a2564fb99e14a88c53a47e4b1fbf85c5292c35ee2"},{"name":"T_k1.0_p0.75","family":"A1-T","eta":0.5,"Dmax_bps":20,"kappa":1.0,"pe":0.75,"caps_relaxed":false,"sha256":"4c2b133303acf9f32b3d0454c14db20edc7d31b4f974d813ba88c258b3ddb7db"},{"name":"T_small","family":"A1-T","eta":0.25,"Dmax_bps":10,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"fb0e67fe05d800acaa941bc558a150c5ebcd8379e5f8edfd46f9af23048d9dd1"},{"name":"T_full","family":"A1-T","eta":1,"Dmax_bps":40,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"e264c97667ddd0ffd276e00ce077abfe3ea69d1ce35f7e5524b72c869999d6ac"},{"name":"D3","family":"A1-T-D3","eta":0.5,"Dmax_bps":20,"kappa":1,"pe":0.5,"caps_relaxed":true,"sha256":"49977e6eb29da7b94c30cb42360f2a0e27885b3326b51a1e06905b2bdbc42ff5"},{"name":"D1","family":"D1","eta":0.5,"Dmax_bps":20,"kappa":null,"pe":null,"caps_relaxed":false,"sha256":"71d20811adf5d1e7794295d22e4ad671f3a1a4e112a77ae650f267cc331d286c"},{"name":"A3","family":"A3","eta":0.5,"Dmax_bps":20,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"0973f0bfc7f02f76028efcb16af8f828fe9d92855384ad4c16391c8dbd7ffb3f"},{"name":"best_D1","family":"D1","eta":0.25,"Dmax_bps":10,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"840f90d240eba065c4fe01bf87f92027e3b9040abf21d5512d778664420b65d0"},{"name":"best_A3","family":"A3","eta":0.25,"Dmax_bps":10,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"1a723abd50b855e7e1c2c5ee8c904edcc1137409bbaecad44f6b29785b17cb1d"}],"build_python":"import json,math,hashlib\nfrom pathlib import Path\nimport numpy as np\nROOT=Path('scratch');BASE=(ROOT/'code.txt').read_text()\n# Fit only the declared screen block's size/sigma configuration means.\nvals=[]\nfor seed in range(780000,784000):\n r=np.random.default_rng(seed); vals.append([r.uniform(19,21),r.uniform(.6,1),r.uniform(.000882,.001008)])\nM,rate,sp=np.mean(vals,axis=0)\nfit={'seeds':[780000,783999],'n':4000,'M':M,'sp':sp,'rate':rate,'size_sigma':1.2,'method':'configuration means; no parity, recheck or held-out data'}\n(ROOT/'fit.json').write_text(json.dumps(fit))\ndef table(kappa,pe,share=False,sig=1.2):\n # 7-node lognormal quadrature, 5 uniform w2 nodes plus edge atoms.\n z,wt=np.polynomial.hermite_e.hermegauss(7);wt=wt/np.sqrt(2*np.pi)\n T=(M*np.exp(-sig*sig/2+sig*z))[None,None,:]\n if share:T=np.array([[[M]]]);wt=np.array([1.])\n d=-np.log(.997);w2=np.r_[np.linspace(-.8*d,.8*d,5),-d,d]\n pw=np.r_[np.repeat((1-pe)/5,5),pe/2,pe/2][None,:,None]\n f=np.arange(101)[:,None,None]/10000;g=1-f;r=np.sqrt(g/.997);b=r*.997/(g+r*.997)\n out=[]\n for side in [0,1]:\n  for other in range(0,81,10):\n   fb,fa=(other/10000,f) if side==0 else (f,other/10000)\n   db=-np.log(1-fb);da=-np.log(1-fa)\n   for ub in range(-60,61,5):\n    u=ub/10000;s=100*np.exp(u);y=np.sqrt(1e6*s);x=1e6/y\n    s2=100*np.exp(w2)[None,:,None]\n    R=y if side==0 else x;R2=np.sqrt(1e6*s2) if side==0 else np.sqrt(1e6/s2)\n    total=T if side==0 else T/100\n    a=(r*R2-R)/(g+r*.997);q=np.clip(a+b*total,0,total);q=np.where(q>1e-4,q,0)\n    if side==0:\n     edge=q-100*x*g*q/(y+g*q);sn=(y+g*q)**2/1e6\n    else:\n     edge=100*q-y*g*q/(x+g*q);sn=1e6/(x+g*q)**2\n    def cost(un):\n     m1=un-db;m2=-un-da\n     return .25*y*(np.where(m1>0,m1*m1+sp*sp,0)+np.where(m2>0,m2*m2+sp*sp,0))\n    objective=f*q*(1 if side==0 else 100) if share else edge-kappa*(cost(np.log(sn/100))-cost(u))\n    obj=np.sum(objective*pw*wt[None,None,:],axis=(1,2))\n    out.append(int(np.argmax(obj)))\n return out\nHELPER='''\n    // Own post-trade spot and V10 posterior only; no new state.\n    function _darU(uint256 spot,uint256 ref) internal pure returns(int256) {\n        if(ref==0) return 0;\n        // Clamp before arithmetic; table endpoints are saturated.\n        if(spot>=ref+ref/50) return 60*int256(BPS);\n        if(spot<=ref-ref/50) return -60*int256(BPS);\n        int256 z=(int256(spot)-int256(ref))*int256(WAD)/int256(ref);\n        int256 u=z-z*z/(2*int256(WAD));\n        int256 lim=60*int256(BPS);\n        return u>lim?lim:(u < -lim ? -lim:u);\n    }\n    function _darLookup(uint256 side,int256 u,uint256 other) internal pure returns(uint256) {\n        bytes memory t=DAR_TABLE;\n        uint256 ux=uint256(u+60*int256(BPS));\n        uint256 i=ux/(5*BPS); uint256 wu=ux%(5*BPS);\n        if(i>=24){i=23;wu=5*BPS;}\n        uint256 j=other/(10*BPS);uint256 wf=other%(10*BPS);\n        if(j>=8){j=7;wf=10*BPS;}\n        uint256 p=side*225+j*25+i;\n        uint256 a=(uint256(uint8(t[p]))-128)*(5*BPS-wu)+(uint256(uint8(t[p+1]))-128)*wu;\n        uint256 b=(uint256(uint8(t[p+25]))-128)*(5*BPS-wu)+(uint256(uint8(t[p+26]))-128)*wu;\n        return (a*(10*BPS-wf)+b*wf)/(50*BPS);\n    }\n    function _darResidual(uint256 f,uint256 target) internal pure returns(uint256) {\n        int256 d=int256(target)-int256(f);int256 lim=int256(DAR_DMAX);\n        if(d>lim)d=lim;else if(d < -lim)d=-lim;\n        return clampFee(uint256(int256(f)+d*int256(DAR_ETA)/int256(WAD)));\n    }\n'''\nCAPS='''        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'''\nassert CAPS in BASE\n\ndef source(name,eta,dmax,tbl=None,linear=False,relax=False):\n src=BASE\n if relax:src=src.replace(CAPS,'')\n declarations=f'\\n    uint256 constant DAR_ETA = {int(eta*1e18)};\\n    uint256 constant DAR_DMAX = {dmax} * BPS;\\n'\n declarations+='    bytes constant DAR_TABLE = hex\"'+bytes(v+128 for v in (tbl or [0]*450)).hex()+'\";\\n'\n src=src.replace('    uint256 constant ELAPSED_CAP',declarations+'    uint256 constant ELAPSED_CAP',1)\n overlay='''        if (DAR_ETA > 0) {\n            int256 u=_darU(spot,fastHat);\n'''\n if linear:overlay+='''            uint256 ta=uint256(40*int256(BPS)- (u>40*int256(BPS)?40*int256(BPS):u));\n            uint256 tb=uint256(40*int256(BPS)+ (u < -40*int256(BPS)?-40*int256(BPS):u));\n'''\n else:overlay+='''            uint256 ta=_darLookup(0,u,bidFee);\n            uint256 tb=_darLookup(1,u,askFee);\n'''\n overlay+='''            askFee=_darResidual(askFee,ta);\n            bidFee=_darResidual(bidFee,tb);\n        }\n'''\n if not relax:overlay+=CAPS\n src=src.replace('        slots[0] = bidFee; slots[1] = askFee; slots[2]',overlay+'\\n        slots[0] = bidFee; slots[1] = askFee; slots[2]',1)\n src=src.replace('    struct PosteriorInput {',HELPER+'\\n    struct PosteriorInput {',1)\n src=src.replace('return \"censored_10\"','return \"tail-a_'+name+'\"')\n return src\n\nif __name__=='__main__':\n arms=[]\n def add(name,family,eta,dmax,kappa=None,pe=None,relax=False,linear=False,share=False):\n  tb=None if linear else table(kappa or 0,pe if pe is not None else .5,share)\n  src=source(name,eta,dmax,tb,linear,relax)\n  (ROOT/(name+'.sol')).write_text(src)\n  arms.append(dict(name=name,family=family,eta=eta,Dmax_bps=dmax,kappa=kappa,pe=pe,caps_relaxed=relax,sha256=hashlib.sha256(src.encode()).hexdigest()))\n add('identity','A0',0,20,1,.5)\n for k in [.5,1.]:\n  for pe in [.25,.5,.75]:add(f'T_k{k}_p{pe}','A1-T',.5,20,k,pe)\n add('T_small','A1-T',.25,10,1,.5)\n add('T_full','A1-T',1,40,1,.5)\n add('D3','A1-T-D3',.5,20,1,.5,relax=True)\n add('D1','D1',.5,20,linear=True)\n add('A3','A3',.5,20,1,.5,share=True)\n (ROOT/'arms.json').write_text(json.dumps(arms,indent=2))\n print(json.dumps(fit));print('arms',len(arms))\n","harness_python":"import argparse,hashlib,json,math\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\n\n\ndef configs(start,n):\n    configs=[]\n    for seed in range(start,start+n):\n        rng=np.random.default_rng(seed)\n        size=rng.uniform(19.,21.)\n        rate=rng.uniform(.6,1.)\n        sigma=rng.uniform(.000882,.001008)\n        configs.append(sim.SimulationConfig(n_steps=10000,initial_price=100.,\n            initial_x=100.,initial_y=10000.,gbm_mu=0.,gbm_sigma=sigma,gbm_dt=1.,\n            retail_arrival_rate=rate,retail_mean_size=size,retail_size_sigma=1.2,\n            retail_buy_prob=.5,seed=seed))\n    return configs\n\n\ndef decomposition(r,initial_fee=.0004):\n    # Fees are outside reserves, so k stays fixed up to floating-point roundoff.\n    # The arb acts before retail, using the preceding step's final spot and fees.\n    steps=r.steps\n    fair=np.array([s.fair_price for s in steps])\n    spots=np.array([r.initial_fair_price]+[s.spot_prices['submission'] for s in steps[:-1]])\n    bids=np.array([initial_fee]+[s.fees['submission'][0] for s in steps[:-1]])\n    asks=np.array([initial_fee]+[s.fees['submission'][1] for s in steps[:-1]])\n    x0,y0=r.initial_reserves['submission'];k=x0*y0\n    x=np.sqrt(k/spots);y=np.sqrt(k*spots)\n    ga=1-asks;gb=1-bids\n    out=np.minimum(np.maximum(x-np.sqrt(k/(ga*fair)),0),.99*x)\n    paid=(k/(x-out)-y)/ga\n    buyprofit=np.where(out>0,np.maximum(out*fair-paid,0),0)\n    gross=np.maximum((np.sqrt(k*gb/fair)-x)/gb,0)\n    received=y-k/(x+gb*gross)\n    sellprofit=np.where(gross>0,np.maximum(received-gross*fair,0),0)\n    arb=-float(np.sum(np.where(spots<fair,buyprofit,sellprofit)))\n    return arb,r.edges['submission']-arb\n\n\ndef aggregate(chunks):\n    out={}\n    for chunk in chunks:\n        for row in chunk['raw']:\n            key=(row['role'],row['callback'])\n            dest=out.setdefault(key,{'role':row['role'],'callback':row['callback']})\n            for k,v in row.items():\n                if k in ['role','callback']:continue\n                dest[k]=max(dest.get(k,0),v) if k=='max_ok_gas' else dest.get(k,0)+v\n    return list(out.values())\n\n\ndef run(source,start,n,vanilla,compiler):\n    compiled=compiler.compile(source)\n    assert compiled.success,compiled.errors\n    rows=[];chunks=[]\n    for first in range(start,start+n,20):\n        count=min(20,start+n-first)\n        sim.gas_stats_reset()\n        batch=sim.run_batch(list(compiled.bytecode),list(vanilla),configs(first,count),8)\n        results=batch.results\n        assert sorted(r.seed for r in results)==list(range(first,first+count))\n        for r in results:\n            arb,retail=decomposition(r)\n            rows.append({'seed':r.seed,'edge':r.edges['submission'],'arb':arb,'retail':retail})\n        chunks.append({'start':first,'raw':sim.gas_stats()})\n        del results,batch\n    return {'sha256':hashlib.sha256(source.encode()).hexdigest(),'rows':rows,\n            'raw_counters':aggregate(chunks),'chunks':chunks}\n\n\ndef stats(d):\n    d=np.asarray(d,dtype=float)\n    return {'mean':float(d.mean()),'se':float(d.std(ddof=1)/np.sqrt(len(d)))}\n\n\ndef compare(candidate,stack):\n    a={r['seed']:r for r in candidate['rows']};b={r['seed']:r for r in stack['rows']}\n    assert a.keys()==b.keys()\n    seeds=sorted(a)\n    d=np.array([a[s]['edge']-b[s]['edge'] for s in seeds])\n    arb=np.array([a[s]['arb']-b[s]['arb'] for s in seeds])\n    retail=np.array([a[s]['retail']-b[s]['retail'] for s in seeds])\n    assert np.max(np.abs(d-arb-retail))<1e-8\n    summary=stats(d)\n    return {'paired':{'n':len(d),'mean_diff':summary['mean'],'se':summary['se'],\n                'worst':[{'seed':seeds[i],'d':float(d[i])} for i in np.argsort(d)[:5]]},\n            'retail_edge_delta':stats(retail),'arb_edge_delta':stats(arb),\n            'reconciliation_max_abs':float(np.max(np.abs(d-arb-retail)))}\n\n\n","experiment_python":"import json,time,hashlib,sys\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.validator import SolidityValidator\nfrom harness import configs,decomposition,aggregate,compare\nR=Path('scratch');compiler=SolidityCompiler()\nv=compiler.compile(Path('contracts/src/VanillaStrategy.sol').read_text(),'VanillaStrategy');assert v.success,v.errors\nvanilla=v.bytecode\n\ndef gas(raw):\n return dict(max_ok=max((r.get('max_ok_gas',0) for r in raw if r['role'].lower()=='submission' and r['callback']=='afterSwap'),default=0),init_max_ok=max((r.get('max_ok_gas',0) for r in raw if r['role'].lower()=='submission' and r['callback']=='afterInitialize'),default=0),oog=sum(r.get('oog',0) for r in raw if r['role'].lower()=='submission'),errors=sum(sum(r.get(k,0) for k in ['revert','other_halt','tx_error','bad_return']) for r in raw if r['role'].lower()=='submission'),raw=raw)\n\ndef run(name,start,n):\n out=R/f'{name}_{start}_{n}.json'\n if out.exists():\n  cached=json.loads(out.read_text());cached['gas']=gas(cached['raw_counters']);out.write_text(json.dumps(cached));return cached\n source=(R/('code.txt' if name=='V10' else name+'.sol')).read_text()\n validation=SolidityValidator().validate(source);assert validation.valid,validation.errors\n c=compiler.compile(source);assert c.success,(name,c.errors)\n print('START',name,start,n,'runtime_bytes',len(c.deployed_bytecode),flush=True)\n rows=[];chunks=[];t=time.time()\n for first in range(start,start+n,16):\n  count=min(16,start+n-first);sim.gas_stats_reset()\n  batch=sim.run_batch(list(c.bytecode),list(vanilla),configs(first,count),8)\n  results=batch.results\n  assert sorted(r.seed for r in results)==list(range(first,first+count))\n  for r in results:\n   arb,retail=decomposition(r)\n   rows.append(dict(seed=r.seed,edge=r.edges['submission'],arb=arb,retail=retail,retail_volume=r.retail_volume_y['submission']))\n  raw=sim.gas_stats();chunks.append(dict(start=first,raw=raw))\n  del results,batch\n  if (first-start)%64==0:print('PROGRESS',name,first-start+count,round(time.time()-t,1),flush=True)\n raw=aggregate(chunks);gg=gas(raw)\n result=dict(name=name,sha256=hashlib.sha256(source.encode()).hexdigest(),rows=rows,gas=gg,raw_counters=raw,elapsed=time.time()-t,validation=True)\n out.write_text(json.dumps(result,allow_nan=False))\n print('DONE',name,'edge',np.mean([r['edge'] for r in rows]),'gas',gg,'seconds',result['elapsed'],flush=True)\n return result\n\ndef summary(a,b):\n c=compare(a,b);p=c.pop('paired');c.update(p);c.update(name=a['name'],sha256=a['sha256'],gas=a['gas'])\n c['valid']=a['gas']['max_ok']<235000 and a['gas']['init_max_ok']<245000 and a['gas']['oog']==0 and a['gas']['errors']==0\n return c\n\n","V10_url":"https://api.imdnotdead.fun/artifacts/33f54e81f3372088e9eced52c0174f310ac348af98ef5727b73785c088679194","V10_sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","ablation_sha256":"fb0e67fe05d800acaa941bc558a150c5ebcd8379e5f8edfd46f9af23048d9dd1","derivation":"Use build_python source with the reported name, eta, Dmax_bps, table(kappa, pe), linear=(family==D1), relax=caps_relaxed; A3 table uses share=True. V10 code.txt is the hash-checked code field at V10_url. Matched ablations use their reported params and names."},"notes":{"decision":"identity retained; DAR not selected","selection":{"name":"identity","params":{"name":"identity","family":"A0","eta":0,"Dmax_bps":20,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259"},"sha256":"9016d1ea81a401231e97d772cf74006d4c195b12fdeffded46a61b6219093259","ablation_name":"T_small","ablation_params":{"name":"T_small","family":"A1-T","eta":0.25,"Dmax_bps":10,"kappa":1,"pe":0.5,"caps_relaxed":false,"sha256":"fb0e67fe05d800acaa941bc558a150c5ebcd8379e5f8edfd46f9af23048d9dd1"},"ablation_role":"enable the strongest screen DAR residual; eta/Dmax reported explicitly (Dmax has no effect at eta=0). A3 held control matches enabled DAR eta/Dmax and prior.","screen_finalists":["identity","best_D1"],"seeds":[785000,785511],"selection":"maximum valid re-check mean with identity fallback","held_out_accessed":false,"held_controls":{"D1":"best_D1","A3":"best_A3"}},"calibration":{"n":1000,"mean":525.5258821780834,"expected":525.5258821780834,"absolute_error":0.0},"protocol":"Each candidate alone vs VanillaStrategy, run_batch(..., 8), 10000 steps; default_rng(seed) draws size, rate, sigma in MatchRunner order; price seed=seed, retail seed=seed+1. SE is sample SD/sqrt(n). Every evaluation seed retained. Arb reconstructed from preceding final spot/fees; retail is total minus arb.","screen_seeds":[780000,780255],"offline_fit_seeds":[780000,783999],"recheck_seeds":[784000,784255],"held_out_seeds":[785000,785511],"fresh_confirmation_from_5000000":"not run: this item explicitly forbids those seeds","table_model":"J_q exact routed edge minus one-step hinge arb charge, 7 lognormal nodes, 5 interior normalizer-price nodes plus 2 edge atoms; grid u=-60..60 step5 bp, other fee=0..80 step10 bp, fee objective grid0..100 step1 bp. A3 maximizes fee times routed input at mean size. D1 q0=40bp beta=1.","own_observables":"The overlay reads post-trade spot and V10 fastHat only, plus the unmodified V10 candidate fee pair. Table fitting uses offline screen configuration means. No hidden fair price, other pool spot, or simulation identifier is read on chain.","caps":"Primary residual is relative to capped V10 fees, then existing 30/36bp caps are reapplied. D3 removes only these two cap blocks. Tail compression, estimators, and initialization remain unchanged.","gas_scope":"Measured maxima are sample maxima, not a universal gas bound; invalid arms cannot be selected. Top-level gas covers the frozen hash across its measured full-length runs.","prior":"pe is a screened model parameter; no hidden normalizer traces were used to fit it.","grid":"eta/Dmax were screened as joint pairs (0.25,10bp), (0.5,20bp), (1,40bp); six kappa/pe tables use the center pair. Controls are also matched to the strongest active DAR setting.","board_claim":null}}