{"variant": "UN (FA + raw_size, step_trade_count, steps_since_arb_like_print, router_implied_vanilla_spot_dev; 23-8-2 head)", "blocked": null, "gates": {"A": {"passed": true, "number": 4.06e-05, "unit": "max |fee diff| bps, FA port vs FA code on EVM", "sequences": 50, "swap_callbacks": 100000, "seeds": [310000, 310049], "threshold_bps": 0.01}, "B": {"passed": true, "number": 1.7050245300047933, "se": 0.04995197116469658, "n": 512, "seeds": [7004000, 7004511], "real_reference": 1.65, "abs_diff": 0.055, "tolerance": 0.15}, "C": {"passed": true, "number": 4.17e-05, "unit": "max |fee diff| bps, frozen port vs frozen Solidity", "sequences": 56, "swap_callbacks": 112000, "seeds": [310000, 310055], "threshold_bps": 0.1}, "zero_weight_equality": {"passed": true, "number": 0.0, "unit": "max |fee diff| bps, UN code (new weights 0) vs FA code on EVM (UN port vs FA code <=3.9e-05)", "sequences": 9, "swap_callbacks": 18000, "seeds": [320000, 320002, 320010, 320012, 320020, 320022]}}, "sim_markets_per_s": 268.2, "sim_speed": {"note": "8 cores, 10000-step markets, numba prange; mode-1 (23-input head) holdout run 8192 markets; search generation (16 candidates x 512 markets + T) took 17.4 s = ~500 markets/s incl. T"}, "search_minutes": 42.87, "generations": 146, "search_setup": "sep-CMA-ES (cma CMA_diagonal=True), seed 312, popsize 16, start = FA weights with the 4x8 new W1 columns at 0, 512 new replica markets per generation from seed 610000000 up (gen g uses 610000000+512g..), fitness = mean edge minus T on same markets, sigma0 0.05, sigma capped at 0.05*0.5^(minutes/30) after each tell; CMA mean scored on monitor seeds 30000000..30002047 every 5 minutes and at each of 6 segment ends (no command over 8 min); best monitor kept.", "curve": [[0.0, 1.7285938423048703, 0.02408296098809692], [5.09, 1.741777417515649, 0.02397990034834238], [7.21, 1.7703663920903034, 0.02621180544869895], [10.09, 1.7547494161244392, 0.02331916029118137], [14.47, 1.7695467012075419, 0.023596721349191104], [15.05, 1.7702040895767253, 0.023589769411198697], [20.01, 1.7808528273730506, 0.023818067814572436], [21.51, 1.7887454354475512, 0.024003442920168018], [25.23, 1.7853389370568944, 0.023494501261349204], [28.78, 1.7873952872626377, 0.023819036397314863], [30.21, 1.7881597095412332, 0.023815399384086847], [35.18, 1.7842928354086967, 0.023574628017204037], [35.84, 1.7907472210814195, 0.023790277117640667], [40.21, 1.8001195338532765, 0.02369797221551205], [42.87, 1.8061432793106984, 0.02369003411464597]], "curve_columns": "[minutes, monitor gain over T, se]", "holdout": {"seeds": [40000000, 40008191], "n": 8192, "gain_over_T": 1.7567189220396775, "gain_over_FA": 0.07561954175760781, "se": 0.011618418123215579, "se_gain_over_FA": 0.004304894885293775, "FA_gain_over_T": 1.6810993802820697}, "real": {"seeds": [7380000, 7380511], "runs_per_seed_per_arm": 1, "vs_FA": {"n": 512, "mean_diff": 0.11209640416092681, "se": 0.017097784125455272, "worst5": [{"seed": 7380036, "diff": -1.2117722283060175}, {"seed": 7380266, "diff": -1.128753048472504}, {"seed": 7380000, "diff": -0.9183323481472598}, {"seed": 7380410, "diff": -0.8318790243031344}, {"seed": 7380282, "diff": -0.8246796757678112}], "sum": 57.39335893039453, "sumsq": 82.91757632929404}, "vs_HA": {"n": 512, "mean_diff": 0.6478896045255005, "se": 0.032943716119490894, "worst5": [{"seed": 7380109, "diff": -9.129678761587456}, {"seed": 7380139, "diff": -1.3762283301539355}, {"seed": 7380308, "diff": -1.2324486864641813}, {"seed": 7380498, "diff": -1.1015500753434253}, {"seed": 7380396, "diff": -0.9512177012875327}], "sum": 331.71947751705625, "sumsq": 498.8637840805833}, "arm_mean_edge": {"candidate": 527.5770849746729, "FA": 527.4649885705119, "HA": 526.9291953701473}, "candidate_vs_FA_note": "FA and HA arms both run (HA arm not dropped).", "retail_delta": null, "arb_delta": null, "retail_delta_note": "amm_sim_rs exposes only total edge per strategy plus retail_volume_y/arb_volume_y; no retail/arb edge split, so edge deltas are not reported (null) rather than guessed. Volume deltas candidate-minus-FA/HA are given below.", "retail_volume_y_delta_vs_FA": {"mean": -133.4570656027376, "se": 2.768229598202696}, "arb_volume_y_delta_vs_FA": {"mean": -95.02325276413208, "se": 2.7534819009236995}, "retail_volume_y_delta_vs_HA": {"mean": 246.50458379340674, "se": 10.591410793436243}, "arb_volume_y_delta_vs_HA": {"mean": 278.40154306604217, "se": 6.622379461106862}}, "gas": {"candidate": {"afterSwap_max": 239583, "init_max": 243260, "oog": 0, "other_failures": 0, "afterSwap_calls": 5466864}, "FA": {"afterSwap_max": 236702, "init_max": 243227, "oog": 0, "other_failures": 0, "afterSwap_calls": 5480082}, "HA": {"afterSwap_max": 233603, "init_max": 243147, "oog": 0, "other_failures": 0, "afterSwap_calls": 5432775}, "probe_eps_weights": {"seeds": [7382000, 7382015], "afterSwap_max": 213710, "init_max": 243260, "oog": 0, "note": "all 8x4 new weights 1e-6; peak < 243,000 so no input dropped"}}, "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[23] 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[21] = 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] = int256(bidFee)*200/1e12-1000000;\n                nx[14] = int256(askFee)*200/1e12-1000000;\n                nx[15] = int256(prevBidFee)*200/1e12-1000000;\n                nx[16] = int256(prevAskFee)*200/1e12-1000000;\n                nx[17] = (int256(spot)-int256(pHat))*500000000/int256(pHat);\n                nx[18] = int256(uint256(uint80(slots[15])))*2/1e12-1000000;\n                nx[19] = trade.reserveY > 0 ? int256(wdiv(trade.amountY, trade.reserveY)) : int256(0);\n                nx[20] = int256(stepTradeCount * WAD);\n                nx[22] = (int256(trade.isBuy ? wdiv(wmul(spot, gamma), WAD - 30 * BPS) : wdiv(wmul(spot, WAD - 30 * BPS), gamma)) - int256(nh)) * 1e18 / int256(nh);\n                nx[19] = nx[19] * 647054817 / 1e18 + (-618293);\n                nx[20] = nx[20] * 1395287 / 1e18 + (-2037262);\n                nx[21] = nx[21] * 412565 / 1e18 + (-823811);\n                nx[22] = nx[22] * 274335453 / 1e18 + (1772);\n                for (uint256 ni=0;ni<23;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[23] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            b = 414519000000; a = 2620480000000;\n            int256 z;\n            z = 2209627 + ((607396 * x[0]) + (2490536 * x[1]) + (-744816 * x[2]) + (2532698 * x[3]) + (-2817526 * x[4]) + (284175 * x[5]) + (-3289180 * x[6]) + (-272822 * x[7]) + (-4170841 * x[8]) + (149581 * x[9]) + (-577073 * x[10]) + (1065337 * x[11]) + (341284 * x[12]) + (862676 * x[13]) + (1227020 * x[14]) + (248592 * x[15]) + (-168713 * x[16]) + (185663 * x[17]) + (801665 * x[18]) + (-28154 * x[19]) + (-125689 * x[20]) + (-5923 * x[21]) + (155066 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (612307 * z); a += (632530 * z);\n            z = -2616992 + ((780038 * x[0]) + (1568214 * x[1]) + (1276848 * x[2]) + (3885620 * x[3]) + (2094817 * x[4]) + (432396 * x[5]) + (471975 * x[6]) + (-277606 * x[7]) + (146539 * x[8]) + (12628 * x[9]) + (-272570 * x[10]) + (-156046 * x[11]) + (556480 * x[12]) + (-1024245 * x[13]) + (744469 * x[14]) + (243136 * x[15]) + (483181 * x[16]) + (173312 * x[17]) + (-590637 * x[18]) + (-225417 * x[19]) + (10365 * x[20]) + (-91882 * x[21]) + (-34395 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-1964392 * z); a += (-1582963 * z);\n            z = -3165213 + ((2026631 * x[0]) + (2107845 * x[1]) + (-1415185 * x[2]) + (1541243 * x[3]) + (2606601 * x[4]) + (3459353 * x[5]) + (-371759 * x[6]) + (2327213 * x[7]) + (1755086 * x[8]) + (-1167289 * x[9]) + (-298368 * x[10]) + (-1678373 * x[11]) + (-962510 * x[12]) + (134255 * x[13]) + (-2349788 * x[14]) + (1190921 * x[15]) + (-295523 * x[16]) + (-932459 * x[17]) + (478500 * x[18]) + (66341 * x[19]) + (50933 * x[20]) + (-261155 * x[21]) + (68150 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-30206 * z); a += (-1301681 * z);\n            z = -101719 + ((-543218 * x[0]) + (-200230 * x[1]) + (547814 * x[2]) + (267296 * x[3]) + (-836670 * x[4]) + (2109686 * x[5]) + (314327 * x[6]) + (1263204 * x[7]) + (-893668 * x[8]) + (895593 * x[9]) + (451824 * x[10]) + (-894174 * x[11]) + (-2160493 * x[12]) + (213919 * x[13]) + (426363 * x[14]) + (280877 * x[15]) + (2664460 * x[16]) + (-223642 * x[17]) + (-409024 * x[18]) + (-95100 * x[19]) + (-68641 * x[20]) + (-44995 * x[21]) + (-202319 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-607062 * z); a += (2578230 * z);\n            z = 354216 + ((549256 * x[0]) + (-1518133 * x[1]) + (3460628 * x[2]) + (-877256 * x[3]) + (-3004956 * x[4]) + (-1597247 * x[5]) + (-1703790 * x[6]) + (-831300 * x[7]) + (237033 * x[8]) + (-249799 * x[9]) + (160727 * x[10]) + (-3058747 * x[11]) + (-59305 * x[12]) + (745282 * x[13]) + (497002 * x[14]) + (-392219 * x[15]) + (1708522 * x[16]) + (835308 * x[17]) + (822345 * x[18]) + (-221440 * x[19]) + (-17949 * x[20]) + (-113464 * x[21]) + (95921 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-3785962 * z); a += (359352 * z);\n            z = -1760103 + ((1386154 * x[0]) + (-205148 * x[1]) + (1072834 * x[2]) + (-600185 * x[3]) + (2731837 * x[4]) + (1445429 * x[5]) + (435205 * x[6]) + (48357 * x[7]) + (-1839523 * x[8]) + (892453 * x[9]) + (125164 * x[10]) + (3431515 * x[11]) + (1003320 * x[12]) + (-386637 * x[13]) + (-101634 * x[14]) + (763347 * x[15]) + (-735785 * x[16]) + (-408410 * x[17]) + (282368 * x[18]) + (-228474 * x[19]) + (-5945 * x[20]) + (240113 * x[21]) + (-83493 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-420370 * z); a += (-1187015 * z);\n            z = -1674833 + ((-1551571 * x[0]) + (1199901 * x[1]) + (1089684 * x[2]) + (-2976854 * x[3]) + (968659 * x[4]) + (-154657 * x[5]) + (419456 * x[6]) + (475448 * x[7]) + (1343699 * x[8]) + (153618 * x[9]) + (-168847 * x[10]) + (558922 * x[11]) + (-1392482 * x[12]) + (1619974 * x[13]) + (-498917 * x[14]) + (706493 * x[15]) + (827456 * x[16]) + (-20988 * x[17]) + (972410 * x[18]) + (69495 * x[19]) + (-76351 * x[20]) + (118862 * x[21]) + (-101572 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-588546 * z); a += (-107002 * z);\n            z = -730037 + ((-981815 * x[0]) + (-2733169 * x[1]) + (2592432 * x[2]) + (2494020 * x[3]) + (-1406985 * x[4]) + (-1449671 * x[5]) + (-676368 * x[6]) + (1492891 * x[7]) + (1726224 * x[8]) + (-1632427 * x[9]) + (2114324 * x[10]) + (-1483319 * x[11]) + (777668 * x[12]) + (453078 * x[13]) + (303534 * x[14]) + (1676800 * x[15]) + (-8362 * x[16]) + (-524978 * x[17]) + (435558 * x[18]) + (156873 * x[19]) + (196790 * x[20]) + (-216080 * x[21]) + (-48782 * x[22]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (1413507 * z); a += (373458 * 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 \"union_fu_b\"; }\n}\n", "sha256": "64664c77c560218d085c340ec2d9da2d9f54a4d90ed02fb0c2be464f14507a12", "params": {"architecture": "23-8-2 ReLU head (z clipped [0,4], inputs clipped [-4,4]); output in bps added to T-path fees then clamped [0,MAX_FEE]; weights rounded to 1e-6; Solidity signed 1e6 fixed point", "float": {"W1": [[0.607396, 2.490536, -0.744816, 2.532698, -2.817526, 0.284175, -3.28918, -0.272822, -4.170841, 0.149581, -0.577073, 1.065337, 0.341284, 0.862676, 1.22702, 0.248592, -0.168713, 0.185663, 0.801665, -0.028154, -0.125689, -0.005923, 0.155066], [0.780038, 1.568214, 1.276848, 3.88562, 2.094817, 0.432396, 0.471975, -0.277606, 0.146539, 0.012628, -0.27257, -0.156046, 0.55648, -1.024245, 0.744469, 0.243136, 0.483181, 0.173312, -0.590637, -0.225417, 0.010365, -0.091882, -0.034395], [2.026631, 2.107845, -1.415185, 1.541243, 2.606601, 3.459353, -0.371759, 2.327213, 1.755086, -1.167289, -0.298368, -1.678373, -0.96251, 0.134255, -2.349788, 1.190921, -0.295523, -0.932459, 0.4785, 0.066341, 0.050933, -0.261155, 0.06815], [-0.543218, -0.20023, 0.547814, 0.267296, -0.83667, 2.109686, 0.314327, 1.263204, -0.893668, 0.895593, 0.451824, -0.894174, -2.160493, 0.213919, 0.426363, 0.280877, 2.66446, -0.223642, -0.409024, -0.0951, -0.068641, -0.044995, -0.202319], [0.549256, -1.518133, 3.460628, -0.877256, -3.004956, -1.597247, -1.70379, -0.8313, 0.237033, -0.249799, 0.160727, -3.058747, -0.059305, 0.745282, 0.497002, -0.392219, 1.708522, 0.835308, 0.822345, -0.22144, -0.017949, -0.113464, 0.095921], [1.386154, -0.205148, 1.072834, -0.600185, 2.731837, 1.445429, 0.435205, 0.048357, -1.839523, 0.892453, 0.125164, 3.431515, 1.00332, -0.386637, -0.101634, 0.763347, -0.735785, -0.40841, 0.282368, -0.228474, -0.005945, 0.240113, -0.083493], [-1.551571, 1.199901, 1.089684, -2.976854, 0.968659, -0.154657, 0.419456, 0.475448, 1.343699, 0.153618, -0.168847, 0.558922, -1.392482, 1.619974, -0.498917, 0.706493, 0.827456, -0.020988, 0.97241, 0.069495, -0.076351, 0.118862, -0.101572], [-0.981815, -2.733169, 2.592432, 2.49402, -1.406985, -1.449671, -0.676368, 1.492891, 1.726224, -1.632427, 2.114324, -1.483319, 0.777668, 0.453078, 0.303534, 1.6768, -0.008362, -0.524978, 0.435558, 0.156873, 0.19679, -0.21608, -0.048782]], "b1": [2.209627, -2.616992, -3.165213, -0.101719, 0.354216, -1.760103, -1.674833, -0.730037], "W2": [[0.612307, -1.964392, -0.030206, -0.607062, -3.785962, -0.42037, -0.588546, 1.413507], [0.63253, -1.582963, -1.301681, 2.57823, 0.359352, -1.187015, -0.107002, 0.373458]], "b2": [0.414519, 2.62048]}, "input_order": ["sigmaHat", "lambdaHat", "sizeHat", "toxEma", "actEma", "direction", "(spot-staleHat)/staleHat", "signed_trade_ratio", "arb_probability", "first_in_step(+1/-1)", "uncertainty", "min(silent,8)/8", "anchor_mean", "T_bid_fee", "T_ask_fee", "prev_bid_fee", "prev_ask_fee", "(spot-pHat)/pHat", "retail_flow_rate", "raw_size", "step_trade_count", "steps_since_arb_like_print", "router_implied_vanilla_spot_dev"], "feature_multipliers": [1000.0, 2.0, 500.0, 500.0, 500.0, 1.0, 500.0, 500.0, 2.0, 1.0, 1000000.0, 1.0, 500.0, 200.0, 200.0, 200.0, 200.0, 500.0, 2.0, 647.054817, 1.395287, 0.412565, 274.335453], "feature_offsets": [-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, -1.0, 0.0, -1.0, 0.0, -1.0, -1.0, -1.0, -1.0, -1.0, 0.0, -1.0, -0.618293, -2.037262, -0.823811, 0.001772], "clip": [-4, 4], "new_input_scaling": "from IA artifact df0ddfdf: raw_size mult 647.054817 off -0.618293; step_trade_count 1.395287/-2.037262; steps_since_arb_like_print 0.412565/-0.823811; router_implied_vanilla_spot_dev 274.335453/0.001772", "toxicity_anchor": "unchanged from FA/T"}, "port_zb64": "eNqdfW1z4rjS6Hf/Ct/ZqhsMhvgNMJkhdbMzzCZ1MklOktl5zknxUAacxBPALIYk5Nb977e79W5MZs8ztevIrVZLanW3pFbLfPjw4essT9adyF7mq7XdsOfJ6ild26t0OcsmiX2fr+z7NIVceN3a3y/s2maR5QvnyL61a9c3ARRZ56/ZJFtv7WQxecxXjrWcbQo7sYOwGTcD+zo9/440mpN8tUonayhtP6bJ1K59PTkobL9nZ4vlZl0ApTMErJKXUZG9pa5drNPlaL1Kpulokm8WawYpIHcxSUfJajyaZU/paLnKMG+Vb9bpapTNoeXpdPScLLLZLBkVy3w9mqbPTsv+kq6y53Rq36/yuf31hHU5iMLEi+7TFjT0r022Sgt7sZkvty7+GSct6zyHtiaLqV1AB9Ijy7ahCiz5s8gXrv02y8auPU6KtBN9tLF4n3JawNdpLV+mi9oBQDezdQvBB44DFBj4Pk3WJyOk1VpuD9yDl/GB03pZZeu0hlRb03SSz5dQuKgx+q1xJ0LgNK0B9O4Ai47eAHgwdIgub5kibCeFffXRvriCVl1Rk0bLZJXMC06A0gfDu4N7FAMgY9u/2S9p9vAIA5LcA0NtP212kLmLabZ4gDrmMAwpkXtIskXt4gpYnywe0lrksX+ujanY7wUOkROyhOh2/gwkb117mQCrpzbIQvGYYKpI02kB5Ff5S0HUV5vFaJ4stlQD5br2HLre94Gq+vcbAW0PytwyBNvHNIgTSpn1FXixwWF5HWUAn8yyZQ1FLKt/HZzcjr59P7/Lhg1KX379CmnXbkbQBQfE0ibwxcm3wY2dr6bp6qP9JmiMfajhh2+/ujb22Plo1abjbOra06R4cgCrNkbl+BHYb04deBjZyXQK/Vzn9i1I+X22SGaoFtCr9WO6AKLJfMny74Cg1/KHLRTSrIBa7o5cv3c0BKpeC3qUFofQo3T1DN0C5gGHgRbo5RqJZfO0WAMt0iSmMR/tG9DfKeooqEr6AEMA452vWOlFvrbT+WaWrNNpy/rGDAAKGdYNbbPTOOkmQXIvR7L2CmUfs/s1kIe651Dtt2Q9ebzeLBZAe5Iv7rMHewr1Fw4O9SqZzdJZVkD3XrL1o70kgWlZHz58sLjIzpP1o0iT/qHkLpYW6SppohDuxc8MtJ2RsCzrN/t30A2sE3q9AKkFhZmk0Hg0TulivcrSomVfJHOonL9Sr9PnZLbBLhP3msg9oKXI0HhD7niLPMhWdpFvVpPUzieTDdgxsEAt+/zTLFukx6OLT4CNA3osqgBS2eIZXvLV1h78Obj+F3YC7M/EnoF+A0PsGlix2QaVyi5mOQ7dMpk84Ssam6z4a7VGGQRKOAaPSfEIrcFOrdNXYABI5ywFwwuUuGgCGjBCVav3FoYCCImq58kDdHczReHD0QfJzNAuQ9Z6s0jGs5QGbZ4COjDvZr3aTECJIDsDKzCh7lEjmTA1k9lDDmbrcS5qEGK5BpVHgwuzSAJdXbPqVmj9ga9kc4oWEGPDo+oURiGZrPKi0HjOCK/BwLsoIGxkFlCqQPGYbVuWdXvKNRZU8ODHyZcD1z74dvJfo6+DASXPLkTy96sb/DM4P7m6GXwZfT65wtfzeHThYeLm7I+Lk/PR7en14Ob08pwInfd45pez69GXweeTfxHU9zj45POtDvYlqX8PdHjA4beX/6WDQ1XztxM9I+IZ5yfffv9i5LT1Gn4/H1x80XM7Wj07mV2tzTuZgglXp2ABT87hD4P3duCj68Htydk5ZQfebvYNDAbLFNy4RoW4HX1n0EDj6Nm3K2wNGOVblik48sfJ7WDE2KIyBVdwSBGBQQVHbq9PvgxG1PPLyxteRDDk5vbkfDA6uQUkqO8rPFl+VzbxVspDEGtclMCeUc31ye3ZpcwMPXO8JFzKw+3gavT58vuFqiUUfPj95GYgJPQ8NEXi8+XgK4OXJEJliO5/Pb/8MSKpUHm6OChoV4P+8/vJFy0r1kREQXUdkNDI06BGBZFvMN0sFRj9M8uJvqN4jf5xwVkSRTr45vzyajC6ur68HXxmYxy1d/P5QLN8wYV/D64vGUR0iFI+pi4vBhIQUKotxxRThPT15Pz895PP/4Dqzz4PZB7HF70+uzi7PQM7Qj2UWb5MBToSG06ZF8pUZJL690DmtFkqKFV3LRQCc3yZCmQqlCmiDSz8PLi5Gf15ci0zFOmOTHVZqiu50ZXku5J8LHNjmRvLXMnudk/mSj53JJ87gs/nnVDCpNx3xDCfdyM9RSWgE8qcS4KxJBj7EiYLx5Jg3JEp2dSeLNGTub2uFF4wn58Hoz9kpT3JgZ7ggEBSRrYnqfueZyR9nhSV3v645JCgVCVI9uDiO1qfC47RVpR6RpITlZMPJDsq2TWSHDdQzQo8AxrwpKKgbOfl91tlwfxQtSJUrZBGAZKBUVDMtL7Uf5b0FcrF4IeCByoZ8qSqMVI1tlWNSgH9tqqkHalk20gS7tX3m1M5vr4SU1/KKVk2iaAId0JZnZJavxsYSY7Q7er2m6ZlPiEr9Fihx6oWJb++EmA/7hpJUSxWUCGfVCFaDdUHJfSU1NAGIHVK5nqB3ujyeoqyfZXkA9aL9EKfL6+vwYIDydG3yy+DKjgY8LM/uVAp/fKlgn07u7k5u/hDTSC+VDCZJWZvpW+B0rfAixS0YyR9lQz4+gBnF8YuUV/gdXcmX9EZyIwVRdFkTsacpik74EkpyoGvmqy0LpDrEDa53mDFPwZnf5yKBVRo5H89ubndyeedi1QFUvV4A2kFpbinVClQqhR0VKs6imWdroIKARTrLkmwq6ruquHoqmq6qppuqKChAQ1UMuRJNaBybmBJgdtWCG2F0FYIqlNd1SmpVTjRwGBfXnO4GmOpV7BUlKobSFW4QoaWNSXoqb71VN96qhc91Qs5+8ByM1BJKTChEpjQ983xvLg8u+ELTLnpgGRbJQXxy9/VkiCU08GXwcXN2e2/RjefQah0wNXlj4FAVo0KRK8vv3y5UYUgQ1Z+cv3HQK1rwiAyMqicXPhTrq+SAU+29bnxdqdQWxVqq0JyxEK5av92AusgNaqhXLazJCei1IWSAqr4r1aMoVwy4maSd1EpUaiUKJQrQliBoqIqaKiStGD75+gz9FJwu624rRZ8oVzx/RPmzBMNNVTJSCXbDPXb2RcF66hkVyVjnlTCo2ZPSrK54vK7qFOJllo6hmrtGKpFYdjxjSRHUPNpqObTUK0Hw66WbBtJjttVFau5Mux5RpLjKkUMlfaFSvsoGagk52dPo6sq7ilxw6TA7SjcjsLtKNyOwlVN7yme9boKt6twlUTLqZElA5UUuIrrvZ7C7SncnsCN1JQZqSmTkgFP+gohUMlQJSOVbKtkRyWpmw66cP48Of9OPpzFspWsVsm2due3mF8UH5TyPA9eYnyJBQQWdHHUUU/X7rQ5erft2t1WO234XXxth67dboV7XntAudfyxWunB4RaPZnbw1z5GgcxNiGIBcBr+0gNi3cIP25jgVhWHsAzaHUlPmB1BLIfuLbfCmQef0Ty0W0F9ACMmDKh6aEoHUJNYG+oCHCszZ4SNYjbXVhxyycisyoCbLGR8qFj7MmKd6h29iTuR7xBVEQ12KMeBCwniiN4wycvho0VzcPWQVvpDbgdR5DZwz+iCqQrWAAs9T3+0kGGwkPkwVtb5BEzxUsPKaphxWKxkgHBW18+qOa2yvD0Px3Z8x6OZ9vT/7GRIQSUBlZFbHTE2yng86qQk6xEJVaH/QkZn7ygnTY9wO1BysCLSq3HRyC7pXI7srExJ4l9VCT8UNIwHh4fhJ0G7oLef/j7HjrzAkPc+DsXIy7yFaMYVL37WlF89UWHSBolPNSeIDvIYW34yfb4OqTcQm2Y/Kjc7aCtK3FQ7tEuf6CXEazKO91ez++FEWz2cCBLII0JTJhiXWSY5dBwqsQrNB9o3ph94wZO1/vK4VAPvweiFXpx7MH0Bfv9iAxIr2PAoM0B617pH1qjEpC3fQ9YtbGy72GnE8bIw54PazSweEioBOtqsqaLThyHATS3Hfuwae3FUQUsZGZxz5C8N1JiRgIlFNAqgSZb2sEOsW6VRdQUVxBmwA0Z1s6zZBDYOP5ts8BKg9WJDWUv6b4muZ4+MTNqZWNVBdzTuR7U3EHsvUYmaJFRhOYFJsVYdlGlkFcRO6auoMhnqIosMd/5XslelRgV7MxY/l476e/RRzWfhBUPGAoUPTVldYNSkh5RW60c2sokenLE/dKYVS03SpLj73RzRwa8SsNeMQEEsQKw9I6V4YIaqKenkrpieCppLAn1gY/M7u0o/d95DF17ut4u0z6sTO9Z8IyDx9Bn8/lmTWen/JD0ozrQtPGwOaXzynmRzujcfvaSbAt7ks9TFpBye9qyfpx8wTN+i59XQtq3+IElpANLcxjAe2SVjygB2LHk0SS8xZY8kURinqVOIvE9sOQJJL4SQXHyiICOpZ84IiS2yieN2DDPKp0wIjCwSieLCIwsdTSI7x1r5yQRwbFVOkEEYOhZ4uQQ3wKrdGKIwMgqnRQisGOJE0J8i63SySByEhizcyKI8MDiJ4H4Eln8BBBfOlbp5A+BsaVO/OC9jWT1kz6EBZY44cM3wXL0/uG75LgAxJZ5kodDzNgt3tggypM7BEWWOLHDNyYS4i229BM6gHRF5zWsbmCZJ3IIg/6Lkzh87Vi7J3AIj63dkzcURc/CEzdMBdblBZKI25Z5hoawnmWcmAGoF1jm+RjC2pZ+GoaQ2NLPvkjcfUs71iJIx+JnQyT+Hcs4ukFY2LWMkxrSC2D4j0tKta2KkxfK6Vry4INUx7PkeQa9ty15eEHvIOL8RAFfuz2LHx+QlgWW8v8ToGcZ/nmE9QRMOONJE3lJ01IEXmRVudkpK7aqPe2U2bN0tzqCwGho7nSCRFbZH07671umH5yAoVV2ehO4Y+04sBEOWr7juCa4rFK6pgkM9k75lsnetC3poyV7E1pl1yuBY0t3jSII5Jg7P8kggbnRnZ4EiyzD70mwtqWcnARAmyCcmwjoeVbJqUnQwCq7LQkMtkt6I8kG+hb5ECnds7iXEN/80BIuQXrtWMzpR7bSs8itR2kQhcvvBA59y/o/GE9lTdN7e7TMX2q3p659n0zW+cq109elg/GOts0CGDGs7vQOqhwS8OUxg8kOkOxjhKNyDxk6/svuMTyohjTs/237KkOjV+/zumQme63IwGr6FCXWotA1JGwfYr2gmUOHt3K9WS04caNnMCsvptS3xLXHrv3C+wWNHNvHfTtRzeNEErth18bNxKm/WAa4adeS5hjBRgUJpz/fuPaza89y137MeC2/qfA7HnaHwV21Z7sO67iw42DMX7IQ0VQ8HhB6MUlmsFAYbwHLj1tEqpgiFzZQkljB6LDeJx4bHxoHBvF3IEEZgqFZPzGYjMVwdh1jBH/an+zQHDoahk2zhpxHQRw2fzp1aBZgQ7uO7Z2MdFakXG5QVIdqSCGjinaj9rMpiSAJifPCWi/EfMia2AdJZrXUKBOFXmUFNvUQUpGOBMqgcHyJ09abO3QcWfU0w7jACQa+zvLmEosugTmznBNdNh8zBjyGgZdUiNGKCkaPCkqHjGnwVOpjlpPFMMx5lj3m+VSp4GGNJxrwFxV6WH+rvzkar0CJVEEJBzFp9O0X9e7Te32pugqVJOMCujTfOIfzjUINGOq0zsjNEdE/TDxLLzbXixXpJF9QTiDwuCZRGDFmNoEcMYKhHtv4LvggbfewZKkKWFVnYAY0ncvHBdBc5hQdmo5YikJyk+IJrFq2KjCEHIwWhouPN1t8eUuVKQD57fcrTBnCibBAfIaRNxqncJ/ZCGntpgHMASwaVRcj14TGsQF7zLR8ObJNjCQWdVLzDeVkPWHSg+gUkimIVNpkpnXJEgNxQdOyRU1wA3DL06ImtqxjDeqZtqAa1mucWlMojFGExgUq2mcdrfdoMwkbUQzpjOwCQZ4V5Nlgza97L4i5OpF32wa0MV61xHq8D9FHwaLpY7NlwgpjpQ8OIlEj5KKwNA6LfDVPZlywlEhAOUcJgFHeMeozi5mIhwa58sybTTdUMSora0VZ0Vn7MgrzR8raymjYEBTqImEUe8KBOaw9N6h8uW7SfG02Rp6zJrj2kwP8Vz3C1x1DKGwHGyojO+U9Aiugd2edr5PZCKXwGQ0lX9GxImiN03p6yHGYFUsXBU7UfbUc2jG4b4eQMlaDQ9ZYYzXIlSGfTvE+A6dbRxpyfTg8VLM4b4QUPDRNTILU8lETISJb76t8uWwcWnvsQ2Xh8qJzqC0zyiuMl2y6fsSw6sesOcsli82pEYwlM6Xa5AjrBTY70gqhenp8I01E6nKCxGHks/88KZCL1ILDGv1p8LUfLBAcbWyITJ39kcyk4mSz1WpatwyMupmtRu+wTxgEWK7yMaAiXFWKb6yuJ7yWRCqgC9WcQ0uSTxMWlWCF5ymsAk0sabKIhEvVM+Rxun5J04WYdDG7KdDl0Dwnq4wPDZas6/pF9TbkO1GuC8vYIPRSJq9S/JWzoajkWMx8OHtoU6JqhJZvrAWg467EY72kqx1N+Lf/ohmZfLpKlr6uUb/yBZWwTi4+n16KzXSnG7UE5B+j8zPcJndh69/reH4Ue91O24v9ziGusRUaelPIQ9BrB5HXbYcx7Bx9r9PmiBdEBjazF6fkZfuN7lxtVul/fM3I0u4Y4Y2FInuYJ6fJ+sA9mCXz8ZSn0RywFHBhME8gARsklphm/F4dpGs4LzRBgWaIDvrDUwcuMByJL9Ipv1O3SqAM0lmNR8jxZJzNgLsAoQlvlC1GeHuo1vAPm74D4A0MzgqvdBCStnyIncMYCdGwjHA0WXW3I5glRzAHQebtCGZInoZp+lnLoleVy7qwpOYvWZ+ZUI5g9/SCzU4ZeXFTENlTuirIQdV3BZHg+5cFD/iwwLCZIQjo4HaDlouHzdrD118CevfTjgQHFQ+B2om6La8dxX4X0EMQt7jreq3ID9qdthuA7IZhO2qHQ94iEB6jRU2oo+p/j/7jKe1PBR4lvVbHj4Ne6DaDlhd2g06AsDgIY9936Ryq2w2gERdXwpFxcVoHLWhcnDaCOj4sWppvFniLqXZxxZfVP/z+xdXdEUMetmDN8Jgs09rFqQvvzkc777MsZtMIOT/KgeoQ8hqQyagEIgPrUmQC9+LUIUSE6yblh++OffcHIPByQ9Y+ap3MHAfSwUGlgK+wCZmAhC3g/9od8rlgnIYyO27/1ip5Tmc1x9XwxhV4rrEMKv3T6wj+Zh0VeDA2+g6J6yKbSoR9nW1SXGcdKcsNEPR/IMKOCwSBjRrhNDHt1J/4Emm2TtBWIbBJ+SJLK9lkaFALS3xi0xvN/F5Lb2sBeovWJlvXbnAZ5dqvnmtvPd7OmztvyKYO4Tcfcri/Bx4OS56qm7s2grbe4auHLYJnxZ7bdEWLkh1OzHBKi8xuKZO5p0VuvFP036rt7VImuk5lB8L3SorMnd0S5EWYh93Vh0NnkWsybGcY6M6vGAe8eYs3al07K0a0YU7maF1HrzK11W6cuja/lYr5Irnlw/jhwwd2UffIvm3xe7p4iZwui+MNR35dXFwNt1/QC6auvmaF/ZaucqeFl0bZSoxNItRhb6hgMJMQzOd77wTmsnVBoGDIV6ziInqfxIX5xiZreo04qcdkrfOS5mUCdATdOb12Rf5bSu/xkG88XkcpL9FjIJqZWNN4e++hbQzAa9WmWAYPBXVay/cVs5uiXyDPEghiLcC7nqRF+kITuk5FFZAbXo51ZJU8BiO8TlzRAKvas6CVIpmr9izMN7PSVkueXoKochqOvrFWY3fc393ZlEdXrNBrEihdFXWo+x1f5DiFxQZaObEGlhTMkntqbLLyuGOnxCfppal28aH01U1OyJPbKk6QuJUKqLPdqhJCIEuF5AHwHn4zodXMJS66dZHY52jKFiTbKAtE47AsEeqotOQ3YpoFz7rCYk1sIFHD62FkKzKmHmEbNIir70NUGaGepn+cfEt9kVnKJV9TX9m6Q2kAkXXqpTzboHERCscMTZXfkZsg6Xlkjidp9/CEhcwyp8ltH6E+JHOyPZofSHil3pNEQOElq9rDV8t6k0y9MRHqjFSpmeThpBxl2GCFTocdpWnbcO3t92Y8GL5Mod+u9G6I092hUz5IINaYGqSd/AKJB03h2FwRDA0XbDWjBL4cZhIvNCaFvqdm4+g0lCehKQbRcQ65e6MsDZp3ACGuPcHjLM0uVPKzqXVOO7geqtMt7kjgQ9hE2rD9wjqFjL57TJHMAIevS2TkxlANoSixE+0xNM8JpL+VBl3XOikWRTLHnn1NgCRz0iyXeZGtTaA8UVDDssGpT8jocWl4pj6bcM0BBuj/2jvCrB01LClb6GB6szQQtfZh97CcIUTwblKuZCaFwQz3HAdQw9Vwk9KZHZUjIIXqIaEmzZPXGi1u0NqWomeYFonoGa5ArHUwjRiypkhW5pA5XNuf+oSzY+Pwj1INqsFp8B7U6VVQkcxE+SDnNAsJGlZORPuUBvjls87J8vtOWphuoIGBFC9yW7InYnEo+ajFUaHH3Jyz9MzdgwbqWMXxAcGZSa3qqXmeQHjvnSOUTfLeowRlqsvDJREvz78MG6x+BbwY/OCbkOSFuZrQwvBNg5wnt/o8uX3fxOBi2bWNeVy4rtgaUj8TrEDm4iTOCMmYu3I6deUEunNUKDY/sieOsRXTKjG2YdgEzgHWe5IhQYMtvswQMiUNrMgxm5PMGD9dujfFo6QLBep8/awFxTEhF5FGQ2Npx/q1f/GMdOV7AyuTK3ST1u7qWSejlt7UXnMNz/qwf03cx2edr4a1WELQKuqxLrZllNJquU9/6mKh/AtiOzg71NiaAz9UZpx+wjqbz6XMj/kfTqSsONKGlFyhK36rfSVP1TmK0R/IM3pTRnB4YErJpX5krzaLBX6DiJw1+b3NvM0uTlLLWcon5EmyxE9VQVeUp51JOn6zi51igBbwjfKCO6PYAqotpzAJ/6SR0QyayG70bb9lkgdQjXe/KYDOoSghtJBcNyJbuFbI72JgIqFZRicvhtdMlHQFp11bP0ZQw/HXJpn+R6XxdMExXAJyl9Qwlq9G8Kg4UFxlD/itqZHcJplgTdaF9WGOCV+xHr1dMr6weuYkX7vyWISR0kvs1kj6O8LQWDGx6vatmXhjKv1e4qxOUd9HRW9ApZdsry+jtDFVnTzUIiGMSMvhzhk2oDHDpu8czEhMGL5SdEU5KFOPLdIYg3/qso7SdlfCzaLGSO0YUfYxP20nIOfMnbW5XGEzyaSvNcJ+XVJgCZ3BomOlsNIhH7rquNLyYGZFgRaHj0hKFloPOhWLUBlzWhqSvS1V6x9eh1Ml3Y3+DgUVeJUmqwVrnG5NS4Pt1EvFdPnUT3MF2LX5EkDQd/SFPFkoFAQNGLIVhWy1nkWLEElbX7fimZkuWCqWQwbqDsv4mvnQR1gG8Q51tWSiI+vWKpDRvVoUG9krjR8AcPVmuiW7tDPjamU5G1WbqwsTx3hpdChJDt3jFzVLxwcNuTanhtdpNd/QPFUEBTINgysMLGti5OfkmKZaGmIOJzw+2wigDNtnOTiVyESDr2lYNqyDFOkGD97QQ/R5g0UNmpNanzJ0Z7UxZwgHelHgMXa/0tHKz3+ejVWdtueUxXWTojynrO6nlLtfxH2DYR1INjhA9QaAdT53Sl8Zp68sCDsAQJ40kLBaO9IhAMKbVCEaO2TcMat/d91lrmFVcZOsqu5vkqXz95G5a9qJdB82cK+gsrRgd52KWhrK1aUkz0/6R7S73Vk0so91MpkxrnqAzAjSbG+/Xq/YspuKqCbpF2NUhBGF2vVVJ81xaXAqJa7CsynqASIIPJYV/52B2aHLRgWeOt0xDct+usmMgiHQtPPNMLkZeZdo2Y5hwTXcmJcRPrF8wQdOSut9nhec36XLRsM6mX5jlWLs/FnRYy3uTt5wKE2cWiU7mL/a5vHhIRLvbOM4txUaBm0Us3zJTefuBaBqM7B7IYiPQfG0h5xA+xU5Ua0M5894PLW8qjQsGwsjs1FDsTFATl32Ug4wyegeqkyqS1RRyEtUZWct1RZUZnTAkQOCu9rI78Le2DVA4XejekQJclT8okRl2DDrC1ZP4ib4tS9OVfJMIWgCo/QMqCI9yal99CS3SvT2U9Ju9FRxXc+2ZKv29LKaluzjDi3cj+BRNV4SUPivLAQnnS/X29qF2ApSDgtWoIn4I7xRiALMupgOhnxdhS+0aOOzG77T+g4MFaZpAWhOmow2bWj3G34Ns8vXkFledvY1TfvzyqIUxKZAg/cQ7rdK24Qm34ozHN+rcoDxPOq7vg2KW85hbBQPdnboPIPYA8NCPGS8KZ7ohZgjnHYE6UiIHoMNGV3FLuWF0RHinZX24lHM016ry2ZlrxXqZXqsDPfiaTkB8cJcnQNUckEdnN9gzXSFWQuB50eJuvfWbzXpOvoeh63MLvlooVLia41oNhePzuHi0YhNl5ON3Ase4xdwTEW94fyR7VabJ5gWM3VnCBXALPp6l4leRy2XThiamED4vnhIbT+cy+gyCXpEFy+GcjVCDABT8ESHN/yh0UjtYtPFaamNb6Lgz6G5m/5V51jhBpX+SSFw0Cns2Q55vf8e/H0r7fmhUw3eCGj7z2H9zcxOZDZF2BkIO9NH43FMn5nHu+xVc0HlDNJ4TN4txGOvgLweciXU7IaZNFNAyK2uHxHzeCzTnt1Ig6cHaEn95GFXZEb1UCuxf+GxVXLbcsOslb5buOHGSSkkj4YSN4Iwvnjwih+0z9Z4ZT9dwt4Sj5j5N+3tIuf7S/Yle3uSLHCpNs+fUwpYWq6yCX4off2InzAXn8TvRHX2kfsbIL3+lr12Ivr1ArzBmFCM8kf79/y1+W0zm6UrfmxTfLT/sdhAoas8K/DHI4DgLX3O/THhtV1vQGcxNH6VjTfIR/7tdoQfFPbV5KETHf47e3jYgGGCTkI/0r829M30lh4YiG2p4YOL9RubyzZgvTsRy2iod++1l4bdbm/c695HSXfitx1Zqvb237W342OFHHqO49T1wuP7dhx1O1N/kkZpe9x7p3DQLRfuRVMv6o3Hfhj6vp+OVeGdin3HuAH6hlbuDU9uNXoOs50K4psRk5tFBro/r4Eor8WlMErb/91nCb1KP3AqMD590jrUdn5BA7rMXLcbsvyYbTAgaEft+6jnR/edyXTqT4XT/hIklW6Lrp6TmZ0859m0sGf5A/Txo90OcPDx+xIgvy/56qlAY4YSdLVdP8Ju/j6ZzcbJ5Kmlc4wqd2sUTFqD9pS66jRabecwanthu9frBN2wCyPTMaI4R0ySd9nn4u25Ene13Oc9uUbD1FWUZtCq0xv2dwMSQy+TvKiJjGVWf3ZKtwVJqRh18r2JBs6yebYWV11AQWtNNIzki2p5Qqhggpza8gxiQR/oUPefKfeYUVITxfs9l1TrsHhSaw866djt/KLpo61a5vmMfh3lqDLMkq46YgQ9GTdMoBHB3wpBLyMYkVn214YuIbto2TbLKaxfFg+2/CGRTQGPfDHb2ot0zX6TxzAc6Ws62azT2pVr/ywHhLpk8igY1LVLwaOc1a8uRmLBlOl6Qxf/8LmaBTUhIBiW1zkIDYdGQBNOXn7L5VMqLIHwhpvaiFNrMMrAa+HmnZWi1yPBVBYZbwSKlHfIyas8q1ajw0JkXuvmYmuBvXqtbw9rrw1A0eZazNg2F1tj77X9RWPwn8EjpA67ydcm1IxddbfNZKu2OYztR2at1S3fllv+Klq+LbWcMpqLV6Plr/+TlkOr3S00Hxtdl3cRSx6dCmazCo+Bwrv1acyHmpxSjxfb5tY8DVr/jT4QBwG1tKiGxo+4dCEvm4Dxd7qtikkZpXvmnrb5dClyxIi+Bv0B9aHQa65oQDHZusw+rx3XqNIxWhIwcChW4C1faMvYcVwTkpjzJqvkdrVJzbsEK5hRVsmD0H1a+PwPVJ1vcbaHr4YDsd9nFLVhYfnMEvS5T44hGcYA1L/2nuVwzKBGaRbYyq0sC3utgRj2mpqGQOj4Lo1oOc3X8i6sZI3K9WgmglsPhs2oGtPEfcZljmMoPpQUaa4dJr82jcYe1oguKwti8Fpv9XrOf9zYmlA2JtLN7U58kGyu1lZhsTQDyEaBcCtrZJKY43ZFm3h+Sm1gsw5prrt2dYUxBLrJ68C4saequycjugiGck2Xx1Yj+VmAX4s59dxnYnh157khheJLMqy6QJu+AoHrv4tLNNXoIWlvyOTCr+Ob0HgiqCP6EjGo45svY0bWLDSMH+qVK0b4oRIrHKeArBSMiwiAJhoVUrfiH4EIVCQl3Upl7W2seHu0c+V8RcupqoZ4yt7q1R4GLXaRaMFaxa8Vr+rUZ6I4bPB+UwGHBoRlOIfTdLFDlwXYAKowhZTBzWE6fYCFaT7bUIAnzRJVH0sJnArlYxVIO8+aSjU1KatC545t+rJqyU+6RwNwz6fJKtcEDVKlDsYnXahZ6P3Jn3Y9G9h1bm1emfZWjZPIE5ptfChC8I3ncVXUeKorIPuVP/zJuZp54wh3ouUjcwSjSwB2vhTXUYgrYmwPi/eDilrk7V6OEx53l3lAjBtnUK1Pdzjp64UM9Up38NYCN3L20GTK6TKtpD8B+0PTr0a3NPFi3PfOZIxh35yqz6j6jKrPqPq7VOlrlfhgOxW2YVixLWdf3+y7Kt3wxb4mo0vZSM/SIgBopNAzWKEGQhNg9zWiz6LIvRh2Qo0W7Z6arXbdbwX4P9+5khPjIV2kOJjs2tfLYw67KPoJO3uMPyJoj1PQs5R+zxM2KPTzc2kyx73KY7pKOaWssPHnOmEDnC7WR/aEb2oLWLrhL0zST8yBtk4eUVPtFJbJAOU/bnp98YfS57XSZ1OoNIaiz0Hsb5c7+zjkYl3fQ0K32Uk8CyBgae3TPIK3uN8zFleey+acfSpsIPu/QF7x3SMLVGI7YA5bGT1ALjxpXCj5O1e7PFiVeKAHRQouMAlp4Pi/OVUEjc1xFUXuGxAzNH5RotV2Sbze73lJlpHNqVVhohriGzLyw2GyTEPK/ztKwW4UM6EasR+91D1rHz58GLzi2bP225gtsKHZbMqxC/IscuFHiwz0EvwwGo1EIa86rpg5Aug0n7c40mi1eKjhJ9aoSmPZw7YJq5bgrt9ruYHfAotTzmnhJfUqOP6CaxygaQHzEDvCoVITP+bZx12Cw9dQYMPHs3zyVGHCC9ee3D9Ig+2is4vzR3ra2W95Uj+KFl3svvOGmhTCILgJCcO7s0VBX1WA2u4ytJ485csURnsLFVdnDZs1offTjzztD/srkQ6G/USkw2H/2bJGn7/+AQ35v/+Pus6HkTWdt/gp3fbluBTYExdsFEeROxLAIvctdB9JGie0iI5A57gTHVF2a4KRYjXNEgDwDmgM++pTACVBdIjB5P2jus2P5EkCljYNV/3YruRZ32c/7nt72r/IF6kS8mv8xd470gtjCpF2ToKZ2gztJYg7VnJEMwDNxunD1k5mQNd+LuzQs8fLwv6TfZVBqgG1q6/dg59lBWezNj+T01I6VvtqGlejAPM5QzBEV/zmBEW94QSD3RQxBy67pw/MXWcPm3zDWwDs2r3tTx8+JJOkdMAQFIYhZJHphD448M6GRf/B5qXi+PKIf+Sw4hec2eHDD9++i4d3QQgyP6a0iz9FfBcMKTmmpLIvrFr6NsLy7uCHfzB04e+Y//0R8Hf467CGyZ9+5v3DOLeSWFyxX3gWvxlMlpj9BPS9+Dnxiyv+e9B2jd0Nd/AHoUkm8G4V0T6y+ecLitQpSYI2/Gw/1NfFmLXMd+6OXH7belyR77F8Cj/AiEBj2BHCQt76SXO8a2GnLWxaDeynBBTraW06ze/7vnMIMkEbMxS8Kf5A9/8HWLoFlw==", "port_sha256": "84c99cee069088931ed676447efffd380b9b79690243ce190f806a8df2daa78e", "notes": ["Inputs verified by sha256: FA code aa2c4a56, FA port 243a04fe, RS2 port 9eac3553, HA code 99e3a2ec. IA artifact fetched for formulas/scaling only.", "Gate A max 4.06e-5 bps over 50x2000 callbacks; gate C 56x2000 callbacks, 4.2e-5 bps. With the 4 new weight columns at 0, UN code fees equal FA code fees exactly on EVM.", "Gate B: replica FA-minus-T = 1.705 (se 0.050) on seeds 7004000..7004511 vs real +1.650 (within 0.15).", "Gas: eps probe afterSwap peak 213,710 (<243,000) so all four inputs kept; frozen candidate afterSwap peak 239583 on 512 real seeds (FA 236702, HA 233603), 0 OOG, under 245,000. afterInitialize ~243.2k (same as FA).", "Real result: candidate vs FA +0.112 (se 0.017), vs HA +0.648 (se 0.033). Replica holdout predicted +0.076 over FA. Top-10 needs about +3.1 over HA; not reached.", "Inputs that earned weight (sum |W1| over 8 hidden units per new input): {\"raw_size\": 1.091, \"step_trade_count\": 0.553, \"steps_since_arb_like_print\": 1.092, \"router_implied_vanilla_spot_dev\": 0.79}; old inputs range ~3-17. All four got modest weights; replica gain attributable is ~0.08 over FA, within noise on the real engine.", "Search was monitor-selected (best monitor 1.806 se 0.024 gain over T vs 1.729 at start); curve still rising slowly at the end; 146 generations in 42.9 min. Diagonal (sep) CMA used because full-covariance adaptation in 210 dims with popsize 16 is too slow for ~150 generations.", "Retail/arb edge split is not available from the engine API; null reported. Real seeds 7382000-7382015 used only for the gas probe; 7380000-7380511 once per arm."]}