{"status":"complete","blocked":null,"gates":{"C":{"passed":true,"sequences":50,"swap_callbacks":100000,"initialization_callbacks":50,"fee_comparisons":200100,"max_fee_diff_bps":0.00013732518049352355,"threshold_bps":0.1,"fees_over_threshold":0,"seed_start":310000,"seed_end":310049}},"seeds":{"start":8039936,"end_inclusive":8040959,"n":1024,"chunk_size":64,"evaluations_per_seed_per_arm":1},"paired":{"n":1024,"mean_diff":0.07632082510605132,"se":0.020595318954213505,"sum":78.15252490859655,"sumsq":450.30182493762305,"worst5":[[8040863,-4.211309613119283],[8040324,-2.102318192491566],[8040616,-1.9684036634520226],[8040884,-1.7245687414781514],[8040094,-1.6603282570002875]]},"means_per_64_seeds":[0.1412191156960274,0.2370150141401437,0.014181809604785656,0.18697035281561902,0.049608746801345305,0.13631859202396157,-0.06119704521901248,0.10072171422779341,0.08544763217325357,0.015067932258911121,0.02935271050494581,0.055778986134919606,0.17101872944273389,0.03160617215453598,-0.028513615456930985,0.05653635439378846],"by_quartile":{"q1":{"n":256,"mean_diff":0.12877378974593912,"se":0.04290576525795243,"seeds":[8040289,8040570,8040657,8040753,8040106,8040634,8040685,8040865,8040838,8040586,8040102,8039974,8040364,8040762,8039952,8040453,8040018,8040441,8040500,8040019,8040699,8040837,8040465,8040907,8040397,8040150,8039972,8040639,8040923,8040682,8040596,8040783,8040742,8040318,8040911,8040372,8040217,8040760,8040411,8040724,8040808,8040856,8040594,8040750,8040451,8040644,8040705,8040052,8040061,8040402,8040320,8040072,8040658,8040405,8040426,8040926,8040379,8040935,8040060,8040577,8040160,8040013,8040887,8040693,8040957,8040769,8040876,8040068,8040709,8040556,8040142,8040468,8040931,8040008,8039937,8040202,8040706,8040339,8040421,8040851,8040445,8040246,8040458,8040835,8039940,8040610,8040589,8040534,8040489,8039936,8040815,8040584,8040630,8040825,8040819,8040571,8040284,8040352,8040620,8040041,8040070,8040047,8040350,8040641,8040159,8040076,8040918,8040915,8040809,8040232,8040698,8040645,8040591,8040529,8040736,8040264,8040388,8040179,8040261,8040873,8040316,8040252,8040006,8040929,8040224,8040940,8040628,8040410,8040090,8040912,8040898,8040127,8040879,8040824,8040764,8040077,8040137,8040676,8040737,8040010,8040133,8040636,8040161,8040513,8040567,8040672,8039970,8040002,8040593,8040761,8040853,8039959,8040288,8040457,8040839,8040928,8040177,8040652,8040678,8040183,8040078,8040766,8040703,8040710,8040130,8040175,8040126,8040759,8040435,8040858,8039969,8040017,8040583,8040000,8040688,8040168,8040727,8040449,8040951,8040095,8040196,8040799,8039980,8040516,8040939,8040123,8040198,8040523,8040157,8040414,8040786,8040326,8040212,8040062,8040147,8040547,8040497,8040550,8040151,8040455,8040563,8040239,8040752,8040174,8040337,8040046,8040213,8040199,8040541,8040690,8040789,8040574,8040248,8040024,8040958,8040728,8040952,8040757,8040140,8040314,8040375,8040283,8040870,8040859,8040301,8040189,8040026,8040029,8040390,8040056,8040518,8040023,8040058,8040509,8040543,8040308,8040260,8040697,8040756,8040108,8040373,8040906,8040846,8040335,8039994,8040640,8039967,8040099,8040959,8040722,8040528,8040744,8039938,8040049,8040659,8040723],"arms":{"IB":{"mean_edge":422.16402095930164,"mean_retail_volume_y":65043.569777286604},"CAND":{"mean_edge":422.29279474904763,"mean_retail_volume_y":64829.48853207051}}},"q2":{"n":256,"mean_diff":0.09162839034166348,"se":0.04188726006638565,"seeds":[8040125,8040055,8040211,8040502,8040112,8040535,8040171,8040896,8040800,8040132,8040461,8040057,8040844,8040941,8040309,8040608,8039950,8040186,8040944,8040167,8040084,8040921,8040407,8040480,8040568,8040170,8040741,8040810,8040621,8040914,8040903,8040745,8040016,8040558,8040361,8040818,8040601,8040901,8040913,8040294,8040732,8040864,8040649,8040908,8040184,8040203,8040909,8040874,8040834,8040073,8040765,8040463,8040205,8040689,8040855,8040784,8040333,8040347,8039985,8040270,8040081,8040588,8040633,8040012,8040495,8040482,8040507,8040948,8040519,8040044,8040501,8040341,8040782,8040228,8040001,8040551,8040307,8040153,8040331,8040943,8040393,8040281,8040642,8039996,8040542,8040629,8040880,8040635,8040714,8040532,8040470,8040162,8040007,8039997,8040612,8040816,8040802,8040306,8040796,8040338,8040536,8040452,8040773,8040305,8040200,8039988,8040154,8040367,8040391,8040332,8040194,8040891,8040862,8040201,8040169,8040257,8039955,8040751,8040357,8040603,8040474,8040872,8040166,8040852,8040129,8040841,8040882,8040604,8040680,8040293,8040771,8040080,8040606,8040315,8040042,8040292,8040900,8040854,8040234,8040165,8039978,8039977,8040025,8040779,8040515,8040729,8040355,8040946,8039947,8040450,8040356,8039954,8040950,8040287,8040344,8040934,8040638,8040537,8040428,8040437,8040479,8040353,8040471,8040615,8040778,8039982,8040093,8040256,8040860,8040598,8040614,8039962,8040661,8040221,8040559,8040843,8040266,8040578,8040790,8040015,8039984,8040148,8040336,8039958,8040088,8040949,8040712,8040932,8040247,8040004,8040660,8040924,8040933,8040074,8040637,8040557,8040565,8040233,8040250,8040890,8040738,8040255,8040677,8040030,8040920,8040823,8040399,8040366,8040128,8040545,8040145,8040312,8040704,8040670,8040553,8040694,8040387,8039986,8040506,8040035,8040774,8040268,8040863,8040692,8040181,8040427,8040702,8040483,8040210,8040498,8039999,8040631,8040302,8040100,8040371,8040707,8040040,8040434,8040667,8040111,8040488,8040124,8040143,8040229,8040119,8040085,8040048,8040464,8039976,8040770,8040242,8040599,8040136,8040097,8040459,8040850],"arms":{"IB":{"mean_edge":494.96181928236814,"mean_retail_volume_y":74016.57924110949},"CAND":{"mean_edge":495.0534476727098,"mean_retail_volume_y":73822.32536583814}}},"q3":{"n":256,"mean_diff":0.08340297651065454,"se":0.03723577190966101,"seeds":[8040378,8040592,8040575,8040376,8040404,8040726,8040643,8040190,8040681,8040663,8040275,8040927,8039939,8040478,8040857,8040671,8040401,8040520,8040717,8040955,8039968,8040059,8040772,8040905,8040443,8040813,8040504,8040219,8040627,8040432,8039983,8040675,8039965,8040554,8040828,8040930,8040114,8040840,8040051,8040259,8040323,8040118,8040517,8040231,8040651,8040089,8040849,8040484,8040382,8040109,8040096,8039957,8040207,8040245,8040684,8040098,8040075,8040290,8040899,8040530,8040758,8040321,8040103,8040656,8040032,8040538,8040647,8040243,8040003,8040938,8040263,8040330,8039975,8040362,8040317,8040230,8040655,8040814,8040131,8040904,8040262,8040178,8040180,8040172,8040885,8040139,8040342,8039961,8040120,8040875,8040473,8040460,8040817,8040836,8040822,8040146,8040329,8040713,8040582,8040282,8040527,8039963,8040193,8040894,8040618,8040861,8040792,8040225,8040408,8040295,8040053,8040695,8040313,8040579,8040806,8040107,8040346,8040848,8040510,8040763,8040508,8040185,8040673,8040028,8039945,8040374,8040611,8040798,8040223,8040395,8040867,8040795,8040208,8040566,8040936,8040240,8040195,8039956,8040063,8040327,8040826,8040300,8040197,8040215,8040033,8040277,8040889,8040472,8040549,8040363,8040533,8040448,8040348,8040827,8040297,8040683,8040209,8040812,8040954,8040422,8040481,8040368,8040204,8040619,8040625,8040576,8040005,8040748,8040942,8040444,8040304,8040888,8040014,8040121,8040739,8040632,8039973,8040776,8040155,8040310,8040134,8040216,8040365,8039990,8040064,8040415,8040101,8040164,8040505,8040797,8040616,8040429,8040067,8039995,8040646,8040322,8040050,8040456,8040187,8040138,8040319,8040149,8040079,8040383,8040214,8040384,8040420,8040780,8040788,8040206,8040273,8040467,8040425,8040358,8040686,8040191,8040087,8040144,8040725,8040278,8040878,8040811,8040021,8040487,8040847,8040754,8040490,8039987,8040687,8040141,8040045,8040469,8040696,8040192,8040755,8040218,8040910,8040733,8040842,8040747,8039953,8040253,8040454,8040442,8040602,8040830,8040298,8040269,8040650,8040572,8040701,8040082,8040743,8040485,8040438,8040424],"arms":{"IB":{"mean_edge":558.5527489419758,"mean_retail_volume_y":82389.799054648},"CAND":{"mean_edge":558.6361519184865,"mean_retail_volume_y":82217.44161919065}}},"q4":{"n":256,"mean_diff":0.0014781438259481305,"se":0.04231801044953382,"seeds":[8039942,8040669,8040389,8040871,8040020,8040869,8040721,8040351,8040715,8040590,8040116,8040188,8040749,8040833,8040719,8040022,8040897,8040648,8040803,8040793,8040585,8040886,8040829,8040521,8040494,8040531,8040674,8040241,8040580,8040666,8039946,8040569,8040285,8040475,8039949,8040511,8040708,8040244,8040439,8040299,8040227,8040807,8040027,8040653,8040267,8040296,8040431,8040110,8040254,8040522,8040775,8040359,8040054,8040092,8040622,8040768,8040881,8040476,8040413,8040937,8040587,8040524,8040265,8040423,8040311,8040349,8040369,8040785,8040893,8040525,8040418,8040781,8040104,8040446,8040552,8040691,8040386,8040280,8040113,8040794,8040380,8040597,8040325,8040066,8040711,8040436,8040831,8040716,8039998,8040665,8040412,8040492,8040560,8040499,8040562,8040065,8040945,8040173,8040883,8040291,8040613,8040777,8039966,8039981,8040370,8040902,8040624,8040617,8040034,8040385,8040039,8040271,8040609,8040581,8040573,8040801,8040730,8040466,8040540,8039951,8040238,8040409,8040158,8040163,8040787,8040718,8040086,8040122,8040746,8040043,8040892,8040091,8040539,8040279,8040340,8040226,8040805,8039991,8040334,8040236,8040720,8040605,8040662,8040916,8040491,8040303,8040324,8040430,8039941,8040176,8040607,8040220,8040917,8040156,8040377,8040071,8040866,8040135,8040740,8040182,8040496,8040734,8040115,8040595,8040258,8039943,8040623,8040105,8040947,8039992,8040477,8040237,8040895,8040953,8040548,8040821,8039989,8040152,8040804,8040503,8040433,8040037,8039960,8040094,8040664,8040398,8040011,8040832,8040343,8040419,8040036,8039993,8039948,8040919,8040820,8040117,8040417,8040462,8040009,8040654,8040546,8040416,8040544,8040486,8040791,8040925,8039964,8040392,8040276,8040868,8040512,8040626,8039944,8040381,8040235,8039979,8040877,8040767,8040700,8040038,8040354,8040493,8040406,8040031,8040274,8040249,8040956,8040360,8040286,8040600,8040731,8040564,8040884,8040735,8040083,8040514,8040394,8040679,8040251,8040561,8040526,8040403,8040345,8039971,8040069,8040447,8040845,8040440,8040272,8040922,8040555,8040668,8040328,8040400,8040396,8040222],"arms":{"IB":{"mean_edge":632.5638649848161,"mean_retail_volume_y":91616.4994062637},"CAND":{"mean_edge":632.5653431286421,"mean_retail_volume_y":91487.69193550493}}}},"retail_delta":-177.37500667589072,"arb_delta":-232.88503024191732,"mean_edge":{"IB":527.0606135421154,"CAND":527.1369343672216},"gas":{"IB":{"afterSwap_peak":237009,"oog":0,"other_failures":0,"gas_stats":[{"role":"Baseline","callback":"afterInitialize","calls":1024,"ok":1024,"max_ok_gas":21796,"sum_ok_gas":22319104,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"afterSwap","calls":10997639,"ok":10997639,"max_ok_gas":22592,"sum_ok_gas":248137529692,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"getName","calls":1024,"ok":1024,"max_ok_gas":21526,"sum_ok_gas":22042624,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterInitialize","calls":1024,"ok":1024,"max_ok_gas":243227,"sum_ok_gas":249064448,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterSwap","calls":11041762,"ok":11041762,"max_ok_gas":237009,"sum_ok_gas":1493041240894,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"getName","calls":1024,"ok":1024,"max_ok_gas":21735,"sum_ok_gas":22256640,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}]},"CAND":{"afterSwap_peak":237727,"oog":0,"other_failures":0,"gas_stats":[{"role":"Baseline","callback":"afterInitialize","calls":1024,"ok":1024,"max_ok_gas":21796,"sum_ok_gas":22319104,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"afterSwap","calls":10991819,"ok":10991819,"max_ok_gas":22592,"sum_ok_gas":248006335876,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"getName","calls":1024,"ok":1024,"max_ok_gas":21526,"sum_ok_gas":22042624,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterInitialize","calls":1024,"ok":1024,"max_ok_gas":243237,"sum_ok_gas":249074688,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterSwap","calls":11002849,"ok":11002849,"max_ok_gas":237727,"sum_ok_gas":1492160704243,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"getName","calls":1024,"ok":1024,"max_ok_gas":21745,"sum_ok_gas":22266880,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":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 = WAD / 650;\n    uint256 constant DIR_DECAY = 750000000000000000;\n    uint256 constant ACT_DECAY = 530000000000000000;\n    uint256 constant SIZE_DECAY = 530000000000000000;\n    uint256 constant TOX_DECAY = 910000000000000000;\n    uint256 constant SIGMA_DECAY = 690000000000000000;\n    uint256 constant LAMBDA_DECAY = 990000000000000000;\n    uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n    uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n    uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n    uint256 constant PHAT_ALPHA = 270000000000000000;\n    uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n    uint256 constant PHAT_ALPHA_SAME = 120000000000000000;\n    uint256 constant REVERT_U = 0;\n    uint256 constant DIR_IMPACT_MULT = 4;\n    uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n    uint256 constant MIN_GATE = 30000000000000000;\n    uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n    uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n    uint256 constant RET_CAP = WAD / 35;\n    uint256 constant TOX_CAP = WAD / 5;\n    uint256 constant TRADE_RATIO_CAP = WAD / 5;\n    uint256 constant LAMBDA_CAP = 1820000000000000000;\n    uint256 constant STEP_COUNT_CAP = 64;\n    uint256 constant BASE_FEE = 4 * BPS;\n    uint256 constant SIGMA_COEF = 200000000000000000;\n    uint256 constant LAMBDA_COEF = 12 * BPS;\n    uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n    uint256 constant TOX_COEF = 300 * BPS;\n    uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n    uint256 constant ACT_COEF = 91843 * BPS;\n    uint256 constant DIR_COEF = 20 * BPS;\n    uint256 constant DIR_TOX_COEF = 100 * BPS;\n    uint256 constant STALE_DIR_COEF = 6850 * BPS;\n    uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n    uint256 constant TAIL_KNEE = 600 * BPS;\n    uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n    uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n    function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n        slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[3] = WAD; \n        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n        slots[15] = 400000000000000000 | (uint256(2000000000000000) << 160); slots[13] = 902500000000; slots[14] = slots[5]; \n        return (BASE_FEE, BASE_FEE);\n    }\n\n    function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n        uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = uint64(slots[2]);\n        uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n        uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n        uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n        uint256 sigmaForFast = sigmaHat;\n        uint256 fastHat = slots[14];\n        uint256 uncertainty = slots[13];\n        uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\n        bool isNewStep = trade.timestamp > lastTs;\n        if (isNewStep) {\n            uint256 elapsedRaw = trade.timestamp - lastTs;\n            uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n            dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n            actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n            sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n            toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n            if (stepTradeCount > 0 && elapsedRaw > 0) {\n                uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n                if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n                lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n            }\n            // Process variance is propagated inside the censored update.\n            if (uncertainty > 100000000000000) uncertainty = 100000000000000;\n            stepTradeCount = 0;\n        }\n\n        bool firstInStep = stepTradeCount == 0;\n        uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n        if (pHat == 0) pHat = spot;\n\n        uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n        uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n        uint256 pImplied;\n        if (gamma == 0) { pImplied = spot; }\n        else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n        // S: infer a no-trade interval center from the last post-trade spot.\n        uint256 silenceScale = WAD;\n        if (firstInStep && silent > 1) {\n            uint256 g = silent - 1;\n            if (g > 1) g = 1;\n            uint256 w = WAD - _powWad(800000000000000000, g);\n            uint256 s = slots[2] >> 64;\n            if (s == 0) s = pHat;\n            uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n            if (c >= pHat) pHat += wmul(w, c - pHat);\n            else pHat -= wmul(w, pHat - c);\n            silenceScale = WAD - wmul(300000000000000000, w);\n        }\n\n        {\n            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n            uint256 prePhat = pHat;\n            bool secondPrint = !firstInStep && stepTradeCount == 1;\n            bool sameDir = false; bool oppDir = false;\n            if (secondPrint) {\n                bool up2 = pImplied >= pHat;\n                uint256 d1 = slots[12];\n                if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n                if (sameDir) alpha = PHAT_ALPHA_SAME;\n            }\n            if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n            alpha = wmul(alpha, silenceScale);\n            adaptiveGate = wmul(adaptiveGate, silenceScale);\n            if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n            if (oppDir && REVERT_U > 0) {\n                uint256 pre = slots[11];\n                if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n                else pHat = pHat - wmul(pHat - pre, REVERT_U);\n            }\n            if (firstInStep) {\n                if (ret > RET_CAP) ret = RET_CAP;\n                sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n            }\n        }\n\n        // Interior retail routing equalizes fee-adjusted marginal prices.\n        // Subsequent trades in a step cannot be the initial arbitrage trade.\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalSpot = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n        }\n\n        // Censored assumed-density posterior. No external or future inputs.\n        uint256 arbProbability;\n        (fastHat, uncertainty, arbProbability) = _posterior(PosteriorInput(\n            fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n            prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n            trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n        ));\n        slots[13] = uncertainty;\n        slots[14] = fastHat;\n        uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n        if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n        if (tradeRatio > SIGNAL_THRESHOLD) {\n            uint256 push = tradeRatio * DIR_IMPACT_MULT;\n            if (push > WAD / 4) push = WAD / 4;\n            if (trade.isBuy) {\n                dirState = dirState + push;\n                if (dirState > 2 * WAD) dirState = 2 * WAD;\n            } else {\n                dirState = dirState > push ? dirState - push : 0;\n            }\n            actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n            sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n            if (sizeHat > WAD) sizeHat = WAD;\n        }\n\n        uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n        if (tox > TOX_CAP) tox = TOX_CAP;\n        toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n        uint256 toxSignal = toxEma;\n        uint256 toxLinear;\n        uint256 toxQuadratic;\n        {\n            uint256 packedAnchor = slots[16];\n            uint256 runMean = uint64(packedAnchor);\n            uint256 sampleCount = packedAnchor >> 64;\n            if (sampleCount < 674) sampleCount++;\n            if (toxEma >= runMean) runMean += (toxEma-runMean)/sampleCount;\n            else runMean -= (runMean-toxEma)/sampleCount;\n            slots[16] = runMean | (sampleCount << 64);\n            toxLinear = _anchorBlend(runMean, toxEma, 712696014807650816);\n            toxQuadratic = _anchorBlend(runMean, toxEma, 1295240753826310656);\n        }\n\n\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n        uint256 originalLambda = lambdaHat; uint256 originalSize = sizeHat;\n        int256[19] memory nx;\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            {\n                uint256 la = packedFlow >> 240;\n                uint256 sn = trade.timestamp - la; if (sn > 32) sn = 32;\n                nx[17] = int256(sn * WAD);\n                if (firstInStep && arbProbability > 500000000000000000) la = trade.timestamp;\n                slots[15]=rate | (count << 80) | (meanSize << 160) | (la << 240);\n            }\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            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                nx[13] = trade.reserveY > 0 ? int256(wdiv(trade.amountY, trade.reserveY)) : int256(0);\n                nx[14] = int256(stepTradeCount * WAD);\n                nx[15] = int256(prevBidFee);\n                nx[16] = int256(prevAskFee);\n                nx[18] = (int256(trade.isBuy ? wdiv(wmul(spot, gamma), WAD - 30 * BPS) : wdiv(wmul(spot, WAD - 30 * BPS), gamma)) - int256(nh)) * 1e18 / int256(nh);\n                nx[13] = nx[13] * 647054817 / 1e18 + (-618293);\n                nx[14] = nx[14] * 1395287 / 1e18 + (-2037262);\n                nx[15] = nx[15] * 220617911 / 1e18 + (-803057);\n                nx[16] = nx[16] * 228148131 / 1e18 + (-808615);\n                nx[17] = nx[17] * 412565 / 1e18 + (-823811);\n                nx[18] = nx[18] * 274335453 / 1e18 + (1772);\n                for (uint256 ni=0;ni<19;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[19] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            b = 1595387000000; a = 1497519000000;\n            int256 z;\n            z = 1280885 + ((-107366 * x[0]) + (75470 * x[1]) + (-1434737 * x[2]) + (2611701 * x[3]) + (-1968127 * x[4]) + (498956 * x[5]) + (-1826966 * x[6]) + (1169187 * x[7]) + (-3245196 * x[8]) + (-1148729 * x[9]) + (-921570 * x[10]) + (109265 * x[11]) + (1433103 * x[12]) + (-229669 * x[13]) + (219742 * x[14]) + (375225 * x[15]) + (-1261360 * x[16]) + (-412549 * x[17]) + (961910 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (316442 * z); a += (782082 * z);\n            z = -2095320 + ((659660 * x[0]) + (1413691 * x[1]) + (1959144 * x[2]) + (3721413 * x[3]) + (1073255 * x[4]) + (864274 * x[5]) + (-128000 * x[6]) + (354071 * x[7]) + (-617812 * x[8]) + (374823 * x[9]) + (-224917 * x[10]) + (-1628505 * x[11]) + (149379 * x[12]) + (-824564 * x[13]) + (-262341 * x[14]) + (1450166 * x[15]) + (832583 * x[16]) + (163182 * x[17]) + (703949 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-2084422 * z); a += (-1384243 * z);\n            z = -4427272 + ((2236348 * x[0]) + (3596225 * x[1]) + (-282380 * x[2]) + (1577020 * x[3]) + (2179799 * x[4]) + (3492623 * x[5]) + (-1216393 * x[6]) + (2129282 * x[7]) + (1826186 * x[8]) + (-1991732 * x[9]) + (-106575 * x[10]) + (-2125703 * x[11]) + (-218213 * x[12]) + (915236 * x[13]) + (-702987 * x[14]) + (326939 * x[15]) + (-2528810 * x[16]) + (-188777 * x[17]) + (-3388530 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (85561 * z); a += (-1214412 * z);\n            z = -1190453 + ((-407281 * x[0]) + (-383487 * x[1]) + (-533969 * x[2]) + (-212304 * x[3]) + (-895500 * x[4]) + (419660 * x[5]) + (387993 * x[6]) + (1229205 * x[7]) + (548195 * x[8]) + (367481 * x[9]) + (432121 * x[10]) + (-1574003 * x[11]) + (-1801549 * x[12]) + (297405 * x[13]) + (-44733 * x[14]) + (-146692 * x[15]) + (2815005 * x[16]) + (-590774 * x[17]) + (-652007 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-899612 * z); a += (3608110 * z);\n            z = -1382536 + ((812911 * x[0]) + (26044 * x[1]) + (3454762 * x[2]) + (-404110 * x[3]) + (-1843245 * x[4]) + (-1187833 * x[5]) + (-988 * x[6]) + (-522881 * x[7]) + (-207291 * x[8]) + (151312 * x[9]) + (122121 * x[10]) + (-2803461 * x[11]) + (348749 * x[12]) + (-862821 * x[13]) + (52674 * x[14]) + (-534659 * x[15]) + (2149968 * x[16]) + (-238333 * x[17]) + (164932 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-3254410 * z); a += (382447 * z);\n            z = -1484339 + ((1370578 * x[0]) + (-702090 * x[1]) + (1563338 * x[2]) + (-2230662 * x[3]) + (3394238 * x[4]) + (819582 * x[5]) + (1432933 * x[6]) + (1171562 * x[7]) + (-1001541 * x[8]) + (-380503 * x[9]) + (-189448 * x[10]) + (2912018 * x[11]) + (839022 * x[12]) + (-220126 * x[13]) + (-176391 * x[14]) + (715838 * x[15]) + (-2277359 * x[16]) + (-691458 * x[17]) + (432585 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-145995 * z); a += (-1285247 * z);\n            z = -2224689 + ((-2761832 * x[0]) + (1720287 * x[1]) + (-278947 * x[2]) + (-1743280 * x[3]) + (2604551 * x[4]) + (1715275 * x[5]) + (-784839 * x[6]) + (1502785 * x[7]) + (1066705 * x[8]) + (-791044 * x[9]) + (330669 * x[10]) + (2069919 * x[11]) + (1359621 * x[12]) + (565807 * x[13]) + (406291 * x[14]) + (-1041393 * x[15]) + (282381 * x[16]) + (-195238 * x[17]) + (1776864 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-1053863 * z); a += (-446914 * z);\n            z = 983789 + ((-2740477 * x[0]) + (-3109628 * x[1]) + (3026844 * x[2]) + (4093007 * x[3]) + (-466828 * x[4]) + (-1923312 * x[5]) + (-1562971 * x[6]) + (1904283 * x[7]) + (1705855 * x[8]) + (-853388 * x[9]) + (2858356 * x[10]) + (-2179155 * x[11]) + (1037620 * x[12]) + (969714 * x[13]) + (684221 * x[14]) + (2683307 * x[15]) + (450194 * x[16]) + (-1083447 * x[17]) + (316701 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (1186115 * z); a += (67917 * 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","code_sha256":"01e3b53a569a906c27123fc77739256608870037426db7a283393951345bbd1b","notes":["Measured fixed frozen candidate; no search and no replica. CAND minus IB throughout.","Setup completed at commit 6b6921f8d463314aa7c96234e1be25a25245f704; required wheel SHA256 verified and StarterStrategy validation passed. Artifact JSON and decoded Solidity/port SHA256 hashes verified.","Gate C adapts RS2 differential_test_source: 50 sequences of 2000 swaps plus initialization, canonical WAD inputs, EVM/port alternating quote-driven fills; W = [1] + feature_multipliers + feature_offsets + flatten(W1) + b1 + flatten(W2) + b2 (217 entries).","Engine: amm_sim_rs.run_batch(strategy_bytecode, VanillaStrategy_bytecode, configs, 8), each arm alone. Configs follow MatchRunner._build_configs with RNG and config seed equal to the requested seed; draw retail_mean_size U(19,21), arrival_rate U(0.6,1), sigma U(0.000882,0.001008), in that order; 10000 steps.","retail_delta and arb_delta are mean paired VOLUME deltas in Y, not edge attribution; engine result exposes retail_volume_y and arb_volume_y but no retail/arb edge split.","SE is sample standard deviation (ddof=1) divided by sqrt(n). Quartiles sort IB retail_volume_y ascending, ties by seed, exactly 256 seeds each. worst5 lists [seed, edge difference].","gas_stats collected after reset per arm per 64-seed chunk; counts and gas sums added, peak gas maximized. All six role/callback rows included; afterSwap_peak uses Submission.","Sources supply frozen inputs and engine configuration; reported gate and comparison statistics are local measurements."]}