{"key":"head-c","blocked":null,"gates":{"A":{"pass":true,"sequences":50,"callbacks_per_sequence":2000,"max_fee_diff_bps":1.2216616607219066e-09,"seed_start":310000,"seed_end":310049},"B":{"n":4096,"mean":0.2420270811033297,"se":0.01692058854320023,"pass":true,"seconds":23.48381452400281,"markets_per_s":348.83600326629033},"C":{"pass":true,"sequences":20,"callbacks_per_sequence":2000,"max_fee_diff_bps":1.3181677971374484e-08,"seed_start":310000,"seed_end":310019}},"setup":{"commit":"6b6921f8d463314aa7c96234e1be25a25245f704","passed":true,"source_hashes_passed":true,"source_hashes":{"T":"ebd9de9bf6af6e55d5e308fd15dbb88edec11fd684891d02a30aec185acd19b3","RS2":"f24b6ca198b744c380842c3a17964a6dc21f311bb04984b26733afa3fee8eaf2","replica":"1e4c44b4bffbdeed65872ee15d46dbde209bf5aa11014329d13d100507b4040c","port":"9eac3553357528b06eeae3ed8d18283d83401e1968145ceba16be356a147e271"},"CH":{"n":1000,"mean":525.5258821780834,"expected":525.5258821780834,"pass":true,"seconds":243.8996942449994}},"sim_markets_per_s":348.83600326629033,"curve":[[10,-0.2412403529398201,0.014721108714057535],[20,0.07353769838122631,0.019163370378782005],[30,0.07353769838122631,0.019163370378782005],[40,0.26811560892111996,0.015054084930679256],[50,0.26811560892111996,0.015054084930679256],[60,0.26811560892111996,0.015054084930679256],[70,0.26811560892111996,0.015054084930679256],[80,0.26811560892111996,0.015054084930679256],[90,0.26811560892111996,0.015054084930679256],[100,0.31610119609413356,0.01928649022403174],[110,0.31610119609413356,0.01928649022403174],[120,0.31610119609413356,0.01928649022403174],[130,0.31610119609413356,0.01928649022403174],[140,0.31610119609413356,0.01928649022403174],[150,0.44335045735193407,0.018143920317832487],[160,0.48063759770294345,0.01710652745176222],[170,0.48063759770294345,0.01710652745176222],[180,0.48063759770294345,0.01710652745176222],[190,0.48063759770294345,0.01710652745176222],[200,0.48063759770294345,0.01710652745176222],[210,0.3888267412541091,0.01832222087076739]],"best_monitor":{"gain":0.48063759770294345,"se":0.01710652745176222,"generation":160},"params":{"hidden":16,"features":["sigmaHat*1000","lambdaHat","sizeHat*1000","toxEma*1000","actEma*1000","(direction-1)*20","(spot-staleHat)/staleHat*1000","signed_trade_ratio*1000","arb_probability","first_in_step","uncertainty*1000000","min(silent,8)/8","anchor_mean*1000"],"feature_clip":[-4,4],"activation":"min(4,max(0,z))","coefficient_fixed_scale":1000000000,"output_units":"basis points","W1":[[0.702139175,0.284618128,0.27388461,-0.070488684,0.288851329,-1.915731525,0.496530935,1.113875417,0.191575697,-1.636973951,0.49139003,-0.678762704,-0.52456912],[0.984536825,0.628811996,-1.950565199,-0.017135733,-0.334392495,0.702002662,-1.105868495,-0.582760688,-1.857038664,-0.332542007,-0.406291359,-1.037767522,-0.582672638],[1.34863651,0.134533132,1.14754461,-1.127304376,1.123083003,-0.014965747,-0.221856774,-0.660959119,1.038468797,-0.949525787,-0.658006887,-0.439704089,-1.149603875],[0.038382027,-0.562160393,-0.060536278,-0.055152815,1.821505895,1.024509264,-0.142653986,-2.488394539,-0.867268701,0.028336924,-3.157501289,-0.58625314,-1.276219178],[-0.212251188,0.753585413,-1.873796915,-1.750649634,-1.293230001,0.626162728,0.029121779,-0.015140436,-1.27764635,1.614805654,1.118967263,-1.461754477,1.836119815],[1.156620811,-2.663507722,0.323435162,-1.256517473,1.354156433,-1.737168108,1.082610623,-0.266037146,-3.139186351,0.507614872,-0.913280451,-0.400882586,-2.048025391],[-1.604535865,-1.473480475,1.631936575,-0.519081843,-0.195991615,0.074553363,1.369901983,-0.420661552,-0.504324189,0.721285467,1.414721101,0.868973344,-0.931276199],[0.593279128,1.705972336,0.3356342,-0.906659218,-2.67438763,0.711624318,-0.237395415,0.850482282,1.582794557,-1.736992038,-2.433953641,1.270209234,-0.120075514],[0.18356221,-1.033385723,0.388702521,0.612237144,-1.865866359,-1.084285347,0.972217827,-0.127370418,-0.656151164,1.978606124,1.038946839,2.407143875,-1.270536907],[-0.921594696,-2.121469039,-2.216366282,0.5457537,0.55385349,-0.667982804,-1.779197525,-0.999685799,-0.036008962,-0.064205298,0.919727682,-1.57378344,1.107936887],[-0.151375636,1.008521252,-1.046031565,0.30517438,1.055975408,0.583956854,-0.493183122,-0.238453438,1.66920646,-0.3878543,0.415563834,-0.797116282,-0.756994798],[-1.806065424,0.94837243,-1.682493069,-2.398553285,-1.333632686,-0.063749413,-1.695384159,-0.719784397,0.103809201,-0.176760277,0.291037708,0.527006035,1.026518149],[0.909102471,0.221883348,0.939387547,-1.597654066,-0.462369588,-0.202589175,-0.781354246,0.277620111,-1.250952833,1.009828866,0.319113999,-1.40975886,-2.112977843],[0.341137658,-0.778308356,1.647376338,-0.411805185,0.25309572,-2.024226538,0.656217641,0.497337731,1.305008547,-0.816004425,-0.882102616,0.194949631,-1.183410624],[-0.010778829,0.294092151,-1.532530732,0.161020895,-0.609350687,-1.849674684,0.584807078,-0.217100092,-0.480593028,1.036707071,-1.195978471,0.090286765,-1.075896593],[-0.799320025,0.183879879,0.789168652,-0.506664177,-0.345913129,-0.525415102,0.006066867,-1.076373458,0.80749717,0.149047445,0.027111785,2.176388258,-1.867115664]],"b1":[-1.076477538,-1.703043068,-1.4931399,-2.126554739,-1.352782939,-0.474967533,1.165015372,0.618279045,1.061522103,-0.642794038,0.45251213,-0.805587871,-0.339839136,-1.729282841,-1.396064188,0.186861941],"W2":[[0.128672098,-0.165976336,1.382015704,1.259070747,0.658215688,1.949723815,-1.276574628,0.256972782,-0.202292752,-0.167223209,-0.799271041,0.722003667,-0.634359216,-1.64990582,2.074546747,0.005239586],[-1.092193354,-1.127658026,-1.594637452,1.068493899,0.56798643,1.07899248,-0.666551868,-0.019165625,-0.597364676,0.32964528,-0.528654632,3.104607987,-1.510930538,-0.1441428,0.353471523,-2.644082575]],"b2":[-1.230709157,0.639562529],"T_linear_anchor_k":0.7126960148076508,"T_quadratic_anchor_k":1.2952407538263107,"T_anchor_count_cap":674,"T_linear_anchor_k_wad":"712696014807650816","T_quadratic_anchor_k_wad":"1295240753826310656","baseline_TH_names":["WAD","MAX_FEE","MIN_FEE","BPS","ELAPSED_CAP","L8_N0","SIGNAL_THRESHOLD","L9_N0","DIR_DECAY","L10_N0","ACT_DECAY","L11_N0","SIZE_DECAY","L12_N0","TOX_DECAY","L13_N0","SIGMA_DECAY","L14_N0","LAMBDA_DECAY","L15_N0","SIZE_BLEND_DECAY","L16_N0","TOX_BLEND_DECAY","L17_N0","ACT_BLEND_DECAY","L18_N0","PHAT_ALPHA","L19_N0","PHAT_ALPHA_RETAIL","L20_N0","PHAT_ALPHA_SAME","L21_N0","REVERT_U","L22_N0","DIR_IMPACT_MULT","L23_N0","GATE_SIGMA_MULT","L24_N0","MIN_GATE","L25_N0","TRADE_TOX_BOOST","L26_N0","STALE_ATTRACT_FRAC","L27_N0","RET_CAP","L28_N0","TOX_CAP","L29_N0","TRADE_RATIO_CAP","L30_N0","LAMBDA_CAP","L31_N0","STEP_COUNT_CAP","L32_N0","BASE_FEE","L33_N0","SIGMA_COEF","L34_N0","LAMBDA_COEF","L35_N0","FLOW_SIZE_COEF","L36_N0","TOX_COEF","L37_N0","TOX_QUAD_COEF","L38_N0","ACT_COEF","L39_N0","DIR_COEF","L40_N0","DIR_TOX_COEF","L41_N0","STALE_DIR_COEF","L42_N0","SIGMA_TOX_COEF","L43_N0","TAIL_KNEE","L44_N0","TAIL_SLOPE_PROTECT","L45_N0","TAIL_SLOPE_ATTRACT","L46_N0","ZERO","L49_N0","L49_N1","ONE","L49_N2","L50_N0","L50_N1","FALLBACK_PRICE","L50_N2","L51_N0","INITIAL_SIGMA","L51_N1","L51_N2","INITIAL_LAMBDA","L51_N3","L51_N4","INITIAL_SIZE","L51_N5","L52_N0","INITIAL_RATE","L52_N1","L52_N2","L52_N3","L52_N4","PROCESS_VAR","L52_N5","L52_N6","L52_N7","L57_N0","L57_N1","L57_N2","L58_N0","L58_N1","L58_N2","L59_N0","L59_N1","L59_N2","L60_N0","L60_N1","L63_N0","L64_N0","L65_N0","L74_N0","L74_N1","VAR_CAP","L80_N0","L80_N1","L81_N0","L84_N0","L85_N0","L86_N0","L89_N0","L91_N0","L96_N0","L97_N0","SILENCE_G_CAP","L98_N0","L98_N1","SILENCE_DECAY","L99_N0","L100_N0","L100_N1","L101_N0","TWO","L102_N0","SILENCE_ATTENUATION","L105_N0","L109_N0","L109_N1","L112_N0","L116_N0","L117_N0","L117_N1","L120_N0","L120_N1","L120_N2","L126_N0","L127_N0","ROUTE_FEE","L139_N0","L139_N1","L141_N0","L142_N0","ROUTE_OLD","L143_N0","L143_N1","ROUTE_NEW","L143_N2","L143_N3","L149_N0","L149_N1","L151_N0","L151_N1","L153_N0","L154_N0","L155_N0","L155_N1","PUSH_CAP","L160_N0","L160_N1","DIR_CAP","L163_N0","L163_N1","L165_N0","L172_N0","L172_N1","L177_N0","FLOW_BLEND","L182_N0","L182_N1","L183_N0","L185_N0","L186_N0","L187_N0","L187_N1","L188_N0","L188_N1","FLOW_RATE_CAP","L191_N0","L191_N1","FLOW_RETENTION","L192_N0","FLOW_ELAPSED_CAP","L192_N1","L192_N2","L194_N0","FLOW_CORRECTION_MODE","FLOW_CORRECTION_ACTIVE","L198_N0","L198_N1","MISSING_COEF","L199_N0","MISSING_CAP","L200_N0","L200_N1","L204_N0","L206_N0","L206_N1","L206_N2","RETAIL_RATE_COEF","L207_N0","FLOW_SIZE_MODE","L208_N0","L208_N1","RETAIL_SIZE_COEF","L208_N2","L209_N0","L210_N0","L226_N0","L229_N0","STALE_SLOW_WEIGHT","L233_N0","STALE_FAST_WEIGHT","L233_N1","L240_N0","L243_N0","RETAIL_BOOST_CAP","L251_N0","L251_N1","L266_N0","L266_N1","L267_N0","L267_N1","ATTRACT_CAP","L270_N0","L270_N1","L271_N0","L271_N1","L273_N0","L273_N1","L273_N2","L273_N3","L274_N0","L274_N1","L274_N2","L275_N0","L275_N1","L275_N2","L276_N0","L276_N1","L287_N0","VAR_FLOOR","L288_N0","L288_N1","L292_N0","L292_N1","POST_ELAPSED_CAP","L293_N0","L293_N1","L294_N0","L294_N1","L297_N0","L302_N0","L309_N0","L310_N0","L311_N0","RETAIL_NOISE","L313_N0","L315_N0","L317_N0","OBS_VAR","L320_N0","DENSITY_SCALE","DENSITY_POWER","L322_N0","L322_N1","ODDS_SCALE","L323_N0","LARGE_SIZE","L324_N0","LARGE_ODDS_MULT","L324_N1","L324_N2","L325_N0","SILENT_ODDS_MULT","L325_N1","L325_N2","L328_N0","L330_N0","MASS_FLOOR","L331_N0","L331_N1","L340_N0","L340_N1","L349_N0","L350_N0","L350_N1","THREE","L351_N0","L351_N1","L351_N2","ONE_WEI","L351_N3","L351_N4","Q_CENTER","L352_N0","L352_N1","L352_N2","Q_NEAR","L352_N3","L352_N4","L352_N5","Q_MID","L352_N6","L352_N7","L352_N8","L353_N0","L354_N0","L354_N1","FOUR","L355_N0","L357_N0","L357_N1","L359_N0","L361_N0","L361_N1","L363_N0","L363_N1","L364_N0","L374_N0","L375_N0","L375_N1","L377_N0","L385_N0","L390_N0","L390_N1","L393_N0","L394_N0","L394_N1","L394_N2","L394_N3","L395_N0","L395_N1","L395_N2","L395_N3","L396_N0","L396_N1","L396_N2","L396_N3","L397_N0","L397_N1","L397_N2","L397_N3","L398_N0","L398_N1","L398_N2","L398_N3","L399_N0","L399_N1","L399_N2","L399_N3","L400_N0","L400_N1","L400_N2","L401_N0","L402_N0","L403_N0","L404_N0","L405_N0","L406_N0","L407_N0"],"baseline_TH_values":[1.0,0.1,0.0,0.0001,8.0,8.0,0.001538461538461538,650.0,0.75,7.5e+17,0.53,5.3e+17,0.53,5.3e+17,0.91,9.1e+17,0.69,6.9e+17,0.99,9.9e+17,0.828,8.28e+17,0.051,5.1e+16,0.985,9.85e+17,0.27,2.7e+17,0.06,6e+16,0.12,1.2e+17,0.0,0.0,4.0,4.0,7.2,7.2e+18,0.03,3e+16,0.35,3500.0,1.05,1.05e+18,0.02857142857142857,35.0,0.2,5.0,0.2,5.0,1.82,1.82e+18,64.0,64.0,0.0004,4.0,0.2,2e+17,0.0012,12.0,0.4842,4842.0,0.03,300.0,1.5,15000.0,9.1843,91843.0,0.002,20.0,0.01,100.0,0.685,6850.0,0.05,500.0,0.06,600.0,0.93,9.3e+17,0.85,8.5e+17,0.0,0.0,1.0,1.0,3.0,5.0,0.0,100.0,100.0,6.0,0.00095,950000000000000.0,7.0,0.8,8e+17,8.0,0.002,2000000000000000.0,15.0,0.4,4e+17,2000000000000000.0,160.0,13.0,9.025e-07,902500000000.0,14.0,5.0,0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,14.0,13.0,0.0,0.0,0.0,0.0001,100000000000000.0,100000000000000.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.8,8e+17,2.0,64.0,0.0,2.0,2.0,0.3,3e+17,0.0,0.0,1.0,12.0,0.0,1.0,12.0,1.0,2.0,0.0,11.0,0.003,30.0,0.0,30.0,30.0,0.9,90.0,100.0,0.1,10.0,100.0,2.0,64.0,0.0,0.0,13.0,14.0,0.0,0.0,0.25,4.0,4.0,2.0,2.0,2.0,0.0,0.0,0.0,1.0,0.3424067991934183,3.424067991934183e+17,0.0,15.0,80.0,160.0,0.0,4e+17,0.0,2000000000000000.0,3.0,3.0,3.0,0.999,9.99e+17,64.0,64.0,64.0,0.0,2.0,2.0,2.0,2.0,196.03088039613942,1.9603088039613943e+20,0.33333333333333337,3.333333333333334e+17,3.333333333333334e+17,9.99e+17,15.0,80.0,160.0,0.36638342491340714,3.6638342491340717e+17,2.0,2.0,0.0,1.8832961581192984,1.8832961581192983e+18,3.424067991934183e+17,3.424067991934183e+17,0.0,0.0,0.7,7e+17,0.3,3e+17,0.0,0.0,0.0016,16.0,16.0,30.0,30.0,30.0,30.0,0.0036,36.0,36.0,36.0,36.0,0.0,1.0,2.0,64.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,0.0,1e-08,10000000000.0,10000000000.0,1.0,0.0,8.0,8.0,8.0,902500000000.0,1.0,902500000000.0,0.0,30.0,30.0,30.0,9e-06,9000000000000.0,0.0,0.0,2.25e-08,22500000000.0,8.0,4.0,8.0,4.0,0.004,4000000000000000.0,0.003,3000000000000000.0,0.4,4.0,10.0,1.0,0.8,8.0,10.0,0.0,2.0,0.01,100.0,100.0,100000000000000.0,100000000000000.0,3.0,0.0,7.0,3.0,3.0,3.0,3.0,1e-18,1.0,3.0,72.0,3.0,72.0,2.0,45.0,4.0,45.0,1.0,10.0,5.0,10.0,1.0,0.0,0.0,0.0,4.0,4.0,0.0,1.0,2.0,1.0,0.0,2.0,0.0,10000000000.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,1.0,128.0,0.0,128.0,64.0,64.0,0.0,64.0,32.0,32.0,0.0,32.0,16.0,16.0,0.0,16.0,8.0,8.0,0.0,8.0,4.0,4.0,0.0,4.0,2.0,2.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0]},"code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {AMMStrategyBase} from \"./AMMStrategyBase.sol\";\nimport {TradeInfo} from \"./IAMMStrategy.sol\";\n\ncontract Strategy is AMMStrategyBase {\n uint256 constant ELAPSED_CAP = 8;\n uint256 constant SIGNAL_THRESHOLD = WAD / 650;\n uint256 constant DIR_DECAY = 750000000000000000;\n uint256 constant ACT_DECAY = 530000000000000000;\n uint256 constant SIZE_DECAY = 530000000000000000;\n uint256 constant TOX_DECAY = 910000000000000000;\n uint256 constant SIGMA_DECAY = 690000000000000000;\n uint256 constant LAMBDA_DECAY = 990000000000000000;\n uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n uint256 constant PHAT_ALPHA = 270000000000000000;\n uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n uint256 constant PHAT_ALPHA_SAME = 120000000000000000;\n uint256 constant REVERT_U = 0;\n uint256 constant DIR_IMPACT_MULT = 4;\n uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n uint256 constant MIN_GATE = 30000000000000000;\n uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n uint256 constant RET_CAP = WAD / 35;\n uint256 constant TOX_CAP = WAD / 5;\n uint256 constant TRADE_RATIO_CAP = WAD / 5;\n uint256 constant LAMBDA_CAP = 1820000000000000000;\n uint256 constant STEP_COUNT_CAP = 64;\n uint256 constant BASE_FEE = 4 * BPS;\n uint256 constant SIGMA_COEF = 200000000000000000;\n uint256 constant LAMBDA_COEF = 12 * BPS;\n uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n uint256 constant TOX_COEF = 300 * BPS;\n uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n uint256 constant ACT_COEF = 91843 * BPS;\n uint256 constant DIR_COEF = 20 * BPS;\n uint256 constant DIR_TOX_COEF = 100 * BPS;\n uint256 constant STALE_DIR_COEF = 6850 * BPS;\n uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n uint256 constant TAIL_KNEE = 600 * BPS;\n uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[3] = WAD; \n slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n slots[15] = 400000000000000000 | (uint256(2000000000000000) << 160); slots[13] = 902500000000; slots[14] = slots[5]; \n return (BASE_FEE, BASE_FEE);\n }\n\n function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = uint64(slots[2]);\n uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n uint256 sigmaForFast = sigmaHat;\n uint256 fastHat = slots[14];\n uint256 uncertainty = slots[13];\n uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\n bool isNewStep = trade.timestamp > lastTs;\n if (isNewStep) {\n uint256 elapsedRaw = trade.timestamp - lastTs;\n uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n if (stepTradeCount > 0 && elapsedRaw > 0) {\n uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n }\n // Process variance is propagated inside the censored update.\n if (uncertainty > 100000000000000) uncertainty = 100000000000000;\n stepTradeCount = 0;\n }\n\n bool firstInStep = stepTradeCount == 0;\n uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n if (pHat == 0) pHat = spot;\n\n uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n uint256 pImplied;\n if (gamma == 0) { pImplied = spot; }\n else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n // S: infer a no-trade interval center from the last post-trade spot.\n uint256 silenceScale = WAD;\n if (firstInStep && silent > 1) {\n uint256 g = silent - 1;\n if (g > 1) g = 1;\n uint256 w = WAD - _powWad(800000000000000000, g);\n uint256 s = slots[2] >> 64;\n if (s == 0) s = pHat;\n uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n if (c >= pHat) pHat += wmul(w, c - pHat);\n else pHat -= wmul(w, pHat - c);\n silenceScale = WAD - wmul(300000000000000000, w);\n }\n\n {\n uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n uint256 prePhat = pHat;\n bool secondPrint = !firstInStep && stepTradeCount == 1;\n bool sameDir = false; bool oppDir = false;\n if (secondPrint) {\n bool up2 = pImplied >= pHat;\n uint256 d1 = slots[12];\n if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n if (sameDir) alpha = PHAT_ALPHA_SAME;\n }\n if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n alpha = wmul(alpha, silenceScale);\n adaptiveGate = wmul(adaptiveGate, silenceScale);\n if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n if (oppDir && REVERT_U > 0) {\n uint256 pre = slots[11];\n if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n else pHat = pHat - wmul(pHat - pre, REVERT_U);\n }\n if (firstInStep) {\n if (ret > RET_CAP) ret = RET_CAP;\n sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n }\n }\n\n // Interior retail routing equalizes fee-adjusted marginal prices.\n // Subsequent trades in a step cannot be the initial arbitrage trade.\n if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n uint256 normalSpot = trade.isBuy\n ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n }\n\n // Censored assumed-density posterior. No external or future inputs.\n uint256 arbProbability;\n (fastHat, uncertainty, arbProbability) = _posterior(PosteriorInput(\n fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n ));\n slots[13] = uncertainty;\n slots[14] = fastHat;\n uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n if (tradeRatio > SIGNAL_THRESHOLD) {\n uint256 push = tradeRatio * DIR_IMPACT_MULT;\n if (push > WAD / 4) push = WAD / 4;\n if (trade.isBuy) {\n dirState = dirState + push;\n if (dirState > 2 * WAD) dirState = 2 * WAD;\n } else {\n dirState = dirState > push ? dirState - push : 0;\n }\n actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n if (sizeHat > WAD) sizeHat = WAD;\n }\n\n uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n if (tox > TOX_CAP) tox = TOX_CAP;\n toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n uint256 toxSignal = toxEma;\n uint256 toxLinear;\n uint256 toxQuadratic;\n {\n uint256 packedAnchor = slots[16];\n uint256 runMean = uint64(packedAnchor);\n uint256 sampleCount = packedAnchor >> 64;\n if (sampleCount < 674) sampleCount++;\n if (toxEma >= runMean) runMean += (toxEma-runMean)/sampleCount;\n else runMean -= (runMean-toxEma)/sampleCount;\n slots[16] = runMean | (sampleCount << 64);\n toxLinear = _anchorBlend(runMean, toxEma, 712696014807650816);\n toxQuadratic = _anchorBlend(runMean, toxEma, 1295240753826310656);\n }\n\n\n stepTradeCount = stepTradeCount + 1;\n if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n uint256 originalLambda = lambdaHat; uint256 originalSize = sizeHat;\n\n if (342406799193418304 > 0) {\n uint256 packedFlow = slots[15];\n uint256 rate = uint80(packedFlow);\n uint256 count = uint80(packedFlow >> 80);\n uint256 meanSize = uint80(packedFlow >> 160);\n if (rate == 0) rate = 400000000000000000;\n if (meanSize == 0) meanSize = 2000000000000000;\n if (isNewStep) {\n uint256 inst = count / silent;\n if (inst > 3 * WAD) inst = 3 * WAD;\n uint256 retention = _powWad(999000000000000000, silent > 64 ? 64 : silent);\n rate = wmul(rate, retention) + wmul(inst, WAD-retention);\n count = 0;\n }\n uint256 weight = firstInStep ? WAD-arbProbability : WAD;\n uint256 correctedWeight = weight;\n if (2 == 2) {\n uint256 missing = wmul(feeUsed, 196030880396139429888);\n if (missing > 333333333333333376) missing = 333333333333333376;\n correctedWeight = wdiv(weight, WAD-missing);\n }\n count += correctedWeight;\n uint256 learning = wmul(WAD-999000000000000000, weight);\n meanSize = _blend(meanSize, tradeRatio, learning);\n slots[15]=rate | (count << 80) | (meanSize << 160);\n uint256 retailRate = wmul(rate, 366383424913407168);\n uint256 retailSize = 2 == 0 ? sizeHat : wmul(meanSize,1883296158119298304);\n lambdaHat = _blend(lambdaHat,retailRate,342406799193418304);\n sizeHat = _blend(sizeHat,retailSize,342406799193418304);\n }\n uint256 flowSize = wmul(lambdaHat, sizeHat);\n uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n uint256 fMid = fBase + wmul(TOX_COEF, toxLinear) + wmul(TOX_QUAD_COEF, wmul(toxQuadratic, toxQuadratic)) + wmul(ACT_COEF, actEma);\n fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxLinear));\n\n lambdaHat = originalLambda; sizeHat = originalSize;\n uint256 dirDev; bool sellPressure;\n if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }\n else { dirDev = WAD - dirState; sellPressure = false; }\n\n uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n uint256 bidFee; uint256 askFee;\n if (sellPressure) {\n bidFee = fMid + skew;\n askFee = fMid > skew ? fMid - skew : 0;\n } else {\n askFee = fMid + skew;\n bidFee = fMid > skew ? fMid - skew : 0;\n }\n\n {\n uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n uint256 staleTox = wdiv(absDiff(spot, staleHat), staleHat);\n if (staleTox > TOX_CAP) staleTox = TOX_CAP;\n uint256 staleShift = wmul(STALE_DIR_COEF, staleTox);\n uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n if (spot >= staleHat) {\n bidFee = bidFee + staleShift;\n askFee = askFee > attractShift ? askFee - attractShift : 0;\n } else {\n askFee = askFee + staleShift;\n bidFee = bidFee > attractShift ? bidFee - attractShift : 0;\n }\n }\n\n {\n bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n if (tradeAligned) {\n uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);\n if (!firstInStep && tradeBoost > 16 * BPS) tradeBoost = 16 * BPS;\n if (trade.isBuy) { bidFee = bidFee + tradeBoost; }\n else { askFee = askFee + tradeBoost; }\n }\n }\n\n if (sellPressure) {\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));\n } else {\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));\n }\n\n if (firstInStep) {\n if (askFee > bidFee && bidFee > 30 * BPS) bidFee = 30 * BPS;\n else if (bidFee > askFee && askFee > 30 * BPS) askFee = 30 * BPS;\n }\n\n if (bidFee > askFee && askFee > 36 * BPS) askFee = 36 * BPS;\n else if (askFee > bidFee && bidFee > 36 * BPS) bidFee = 36 * BPS;\n\n {\n int256[13] memory x;\n x[0] = int256(sigmaHat / 1000000);\n x[1] = int256(lambdaHat / 1000000000);\n x[2] = int256(sizeHat / 1000000);\n x[3] = int256(toxEma / 1000000);\n x[4] = int256(actEma / 1000000);\n x[5] = (int256(dirState) - 1e18) / 50000000;\n uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n x[6] = (int256(spot) - int256(staleHat)) * 1000000000000 / int256(staleHat);\n x[7] = trade.isBuy ? int256(tradeRatio / 1000000) : -int256(tradeRatio / 1000000);\n x[8] = int256(arbProbability / 1000000000);\n x[9] = firstInStep ? int256(1000000000) : int256(0);\n x[10] = int256(uncertainty / 1000);\n x[11] = int256((silent < 8 ? silent : 8) * 125000000);\n x[12] = int256(uint256(uint64(slots[16])) / 1000000);\n for (uint256 i; i < 13; ++i) {\n if (x[i] > 4000000000) x[i] = 4000000000;\n else if (x[i] < -4000000000) x[i] = -4000000000;\n }\n (int256 hb, int256 ha) = _head(x);\n int256 fb = int256(bidFee) + hb * 100000;\n int256 fa = int256(askFee) + ha * 100000;\n bidFee = fb < 0 ? 0 : (fb > int256(MAX_FEE) ? MAX_FEE : uint256(fb));\n askFee = fa < 0 ? 0 : (fa > int256(MAX_FEE) ? MAX_FEE : uint256(fa));\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 _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.muhi?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=phi?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 function _head(int256[13] memory x) internal pure returns (int256 ob, int256 oa) {\n unchecked {\n ob = -1230709157; oa = 639562529;\n int256 z;\n z = int256(-1076477538) + ((x[0] * int256(702139175)) + (x[1] * int256(284618128)) + (x[2] * int256(273884610)) + (x[3] * int256(-70488684)) + (x[4] * int256(288851329)) + (x[5] * int256(-1915731525)) + (x[6] * int256(496530935)) + (x[7] * int256(1113875417)) + (x[8] * int256(191575697)) + (x[9] * int256(-1636973951)) + (x[10] * int256(491390030)) + (x[11] * int256(-678762704)) + (x[12] * int256(-524569120))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(128672098) / 1000000000;\n oa += z * int256(-1092193354) / 1000000000;\n z = int256(-1703043068) + ((x[0] * int256(984536825)) + (x[1] * int256(628811996)) + (x[2] * int256(-1950565199)) + (x[3] * int256(-17135733)) + (x[4] * int256(-334392495)) + (x[5] * int256(702002662)) + (x[6] * int256(-1105868495)) + (x[7] * int256(-582760688)) + (x[8] * int256(-1857038664)) + (x[9] * int256(-332542007)) + (x[10] * int256(-406291359)) + (x[11] * int256(-1037767522)) + (x[12] * int256(-582672638))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-165976336) / 1000000000;\n oa += z * int256(-1127658026) / 1000000000;\n z = int256(-1493139900) + ((x[0] * int256(1348636510)) + (x[1] * int256(134533132)) + (x[2] * int256(1147544610)) + (x[3] * int256(-1127304376)) + (x[4] * int256(1123083003)) + (x[5] * int256(-14965747)) + (x[6] * int256(-221856774)) + (x[7] * int256(-660959119)) + (x[8] * int256(1038468797)) + (x[9] * int256(-949525787)) + (x[10] * int256(-658006887)) + (x[11] * int256(-439704089)) + (x[12] * int256(-1149603875))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(1382015704) / 1000000000;\n oa += z * int256(-1594637452) / 1000000000;\n z = int256(-2126554739) + ((x[0] * int256(38382027)) + (x[1] * int256(-562160393)) + (x[2] * int256(-60536278)) + (x[3] * int256(-55152815)) + (x[4] * int256(1821505895)) + (x[5] * int256(1024509264)) + (x[6] * int256(-142653986)) + (x[7] * int256(-2488394539)) + (x[8] * int256(-867268701)) + (x[9] * int256(28336924)) + (x[10] * int256(-3157501289)) + (x[11] * int256(-586253140)) + (x[12] * int256(-1276219178))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(1259070747) / 1000000000;\n oa += z * int256(1068493899) / 1000000000;\n z = int256(-1352782939) + ((x[0] * int256(-212251188)) + (x[1] * int256(753585413)) + (x[2] * int256(-1873796915)) + (x[3] * int256(-1750649634)) + (x[4] * int256(-1293230001)) + (x[5] * int256(626162728)) + (x[6] * int256(29121779)) + (x[7] * int256(-15140436)) + (x[8] * int256(-1277646350)) + (x[9] * int256(1614805654)) + (x[10] * int256(1118967263)) + (x[11] * int256(-1461754477)) + (x[12] * int256(1836119815))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(658215688) / 1000000000;\n oa += z * int256(567986430) / 1000000000;\n z = int256(-474967533) + ((x[0] * int256(1156620811)) + (x[1] * int256(-2663507722)) + (x[2] * int256(323435162)) + (x[3] * int256(-1256517473)) + (x[4] * int256(1354156433)) + (x[5] * int256(-1737168108)) + (x[6] * int256(1082610623)) + (x[7] * int256(-266037146)) + (x[8] * int256(-3139186351)) + (x[9] * int256(507614872)) + (x[10] * int256(-913280451)) + (x[11] * int256(-400882586)) + (x[12] * int256(-2048025391))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(1949723815) / 1000000000;\n oa += z * int256(1078992480) / 1000000000;\n z = int256(1165015372) + ((x[0] * int256(-1604535865)) + (x[1] * int256(-1473480475)) + (x[2] * int256(1631936575)) + (x[3] * int256(-519081843)) + (x[4] * int256(-195991615)) + (x[5] * int256(74553363)) + (x[6] * int256(1369901983)) + (x[7] * int256(-420661552)) + (x[8] * int256(-504324189)) + (x[9] * int256(721285467)) + (x[10] * int256(1414721101)) + (x[11] * int256(868973344)) + (x[12] * int256(-931276199))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-1276574628) / 1000000000;\n oa += z * int256(-666551868) / 1000000000;\n z = int256(618279045) + ((x[0] * int256(593279128)) + (x[1] * int256(1705972336)) + (x[2] * int256(335634200)) + (x[3] * int256(-906659218)) + (x[4] * int256(-2674387630)) + (x[5] * int256(711624318)) + (x[6] * int256(-237395415)) + (x[7] * int256(850482282)) + (x[8] * int256(1582794557)) + (x[9] * int256(-1736992038)) + (x[10] * int256(-2433953641)) + (x[11] * int256(1270209234)) + (x[12] * int256(-120075514))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(256972782) / 1000000000;\n oa += z * int256(-19165625) / 1000000000;\n z = int256(1061522103) + ((x[0] * int256(183562210)) + (x[1] * int256(-1033385723)) + (x[2] * int256(388702521)) + (x[3] * int256(612237144)) + (x[4] * int256(-1865866359)) + (x[5] * int256(-1084285347)) + (x[6] * int256(972217827)) + (x[7] * int256(-127370418)) + (x[8] * int256(-656151164)) + (x[9] * int256(1978606124)) + (x[10] * int256(1038946839)) + (x[11] * int256(2407143875)) + (x[12] * int256(-1270536907))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-202292752) / 1000000000;\n oa += z * int256(-597364676) / 1000000000;\n z = int256(-642794038) + ((x[0] * int256(-921594696)) + (x[1] * int256(-2121469039)) + (x[2] * int256(-2216366282)) + (x[3] * int256(545753700)) + (x[4] * int256(553853490)) + (x[5] * int256(-667982804)) + (x[6] * int256(-1779197525)) + (x[7] * int256(-999685799)) + (x[8] * int256(-36008962)) + (x[9] * int256(-64205298)) + (x[10] * int256(919727682)) + (x[11] * int256(-1573783440)) + (x[12] * int256(1107936887))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-167223209) / 1000000000;\n oa += z * int256(329645280) / 1000000000;\n z = int256(452512130) + ((x[0] * int256(-151375636)) + (x[1] * int256(1008521252)) + (x[2] * int256(-1046031565)) + (x[3] * int256(305174380)) + (x[4] * int256(1055975408)) + (x[5] * int256(583956854)) + (x[6] * int256(-493183122)) + (x[7] * int256(-238453438)) + (x[8] * int256(1669206460)) + (x[9] * int256(-387854300)) + (x[10] * int256(415563834)) + (x[11] * int256(-797116282)) + (x[12] * int256(-756994798))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-799271041) / 1000000000;\n oa += z * int256(-528654632) / 1000000000;\n z = int256(-805587871) + ((x[0] * int256(-1806065424)) + (x[1] * int256(948372430)) + (x[2] * int256(-1682493069)) + (x[3] * int256(-2398553285)) + (x[4] * int256(-1333632686)) + (x[5] * int256(-63749413)) + (x[6] * int256(-1695384159)) + (x[7] * int256(-719784397)) + (x[8] * int256(103809201)) + (x[9] * int256(-176760277)) + (x[10] * int256(291037708)) + (x[11] * int256(527006035)) + (x[12] * int256(1026518149))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(722003667) / 1000000000;\n oa += z * int256(3104607987) / 1000000000;\n z = int256(-339839136) + ((x[0] * int256(909102471)) + (x[1] * int256(221883348)) + (x[2] * int256(939387547)) + (x[3] * int256(-1597654066)) + (x[4] * int256(-462369588)) + (x[5] * int256(-202589175)) + (x[6] * int256(-781354246)) + (x[7] * int256(277620111)) + (x[8] * int256(-1250952833)) + (x[9] * int256(1009828866)) + (x[10] * int256(319113999)) + (x[11] * int256(-1409758860)) + (x[12] * int256(-2112977843))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-634359216) / 1000000000;\n oa += z * int256(-1510930538) / 1000000000;\n z = int256(-1729282841) + ((x[0] * int256(341137658)) + (x[1] * int256(-778308356)) + (x[2] * int256(1647376338)) + (x[3] * int256(-411805185)) + (x[4] * int256(253095720)) + (x[5] * int256(-2024226538)) + (x[6] * int256(656217641)) + (x[7] * int256(497337731)) + (x[8] * int256(1305008547)) + (x[9] * int256(-816004425)) + (x[10] * int256(-882102616)) + (x[11] * int256(194949631)) + (x[12] * int256(-1183410624))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(-1649905820) / 1000000000;\n oa += z * int256(-144142800) / 1000000000;\n z = int256(-1396064188) + ((x[0] * int256(-10778829)) + (x[1] * int256(294092151)) + (x[2] * int256(-1532530732)) + (x[3] * int256(161020895)) + (x[4] * int256(-609350687)) + (x[5] * int256(-1849674684)) + (x[6] * int256(584807078)) + (x[7] * int256(-217100092)) + (x[8] * int256(-480593028)) + (x[9] * int256(1036707071)) + (x[10] * int256(-1195978471)) + (x[11] * int256(90286765)) + (x[12] * int256(-1075896593))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(2074546747) / 1000000000;\n oa += z * int256(353471523) / 1000000000;\n z = int256(186861941) + ((x[0] * int256(-799320025)) + (x[1] * int256(183879879)) + (x[2] * int256(789168652)) + (x[3] * int256(-506664177)) + (x[4] * int256(-345913129)) + (x[5] * int256(-525415102)) + (x[6] * int256(6066867)) + (x[7] * int256(-1076373458)) + (x[8] * int256(807497170)) + (x[9] * int256(149047445)) + (x[10] * int256(27111785)) + (x[11] * int256(2176388258)) + (x[12] * int256(-1867115664))) / 1000000000;\n if (z < 0) z = 0; else if (z > 4000000000) z = 4000000000;\n ob += z * int256(5239586) / 1000000000;\n oa += z * int256(-2644082575) / 1000000000;\n }\n }\n}\n","sha256":"7efaaf440a3cf22ad2ac38a9f0ffc495ea4199c7f8b14342949fda322aef77c2","real":{"n":512,"mean_diff":0.48025080026344513,"se":0.03229303805182836,"worst5":[{"seed":6040170,"diff":-2.0135203764012886,"retail":-0.38600048323064584,"arb":-1.6275198931706427},{"seed":6040026,"diff":-1.4394383313774597,"retail":0.5014743994646551,"arb":-1.9409127308420722},{"seed":6040388,"diff":-1.3564811915063046,"retail":1.0616284740847277,"arb":-2.418109665591075},{"seed":6040338,"diff":-1.2688327710625344,"retail":0.3341738656090456,"arb":-1.6030066366716298},{"seed":6040061,"diff":-1.15970518448421,"retail":-0.18757489891368095,"arb":-0.972130285570568}],"retail_delta":1.7237321079067682,"arb_delta":-1.2434813076433247,"seed_start":6040000,"seed_end":6040511,"chunk_size":64,"run_batch_workers":8,"opponent":"VanillaStrategy","reconciliation_max_abs":1.1368683772161603e-13},"gas":{"max_ok":235199,"init_max_ok":243182,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"after_swap_calls":5319377,"initialization_calls":512},"minutes":{"search":43.050382848580675,"real":8.23863188881672},"search":{"seed":23,"population":16,"initial_global_sigma":0.3,"initial_W1_normal_sd":0.35,"initial_b1_W2_b2":0.0,"CMA_stds_W1_b1":1.0,"CMA_stds_W2_b2":1.5,"generations":211,"train_seed_start":24000000,"train_seed_end":24054015,"markets_per_generation":256,"monitor_seed_start":30000000,"monitor_seed_end":30002047,"monitor_every_generations":10,"selection":"best training proposal so far, checked every 10 generations; retained by monitor mean gain, including unchanged T at gain zero","all_weights_optimized":true,"output_initially_zero":true,"round_before_evaluation":true},"notes":["All reported gates and confirmation results were measured locally with the pinned engine wheel; market returns are paired differences between separate candidate-versus-Vanilla and T-versus-Vanilla markets.","Float replica proposes candidates only. Monitor seeds select the frozen candidate; the final real seeds do not select or alter it.","Gas probe of a nonzero 16-unit policy on 16 disjoint markets supported keeping 16 units; final gas uses all confirmation calls.","Search minutes include elapsed search wall time and cold compilation; setup and the prerequisite gates are excluded.","Real minutes count engine evaluation, decomposition, and checkpointing; compilation is excluded.","Baseline TH includes literal inventory entries; these are not independently tuned. The full frozen head coefficient arrays are provided above.","The held-out mean gain is below the brief's approximate +4.3 over T target for the top 10."]}