{"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[2] = 0; slots[3] = WAD; slots[4] = 0;\n        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n        slots[13] = 902500000000; slots[14] = slots[5]; slots[15] = 0; slots[9] = 0; slots[10] = 0; slots[11] = 0; slots[12] = 0;\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 = 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            uncertainty += wmul(sigmaForFast, sigmaForFast) * elapsedRaw;\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[16];\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[11] = pHat; 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        {\n            uint256 ret = fastHat > 0 ? wdiv(absDiff(pImplied, fastHat), fastHat) : 0;\n            uint256 alpha;\n            if (firstInStep) {\n                uint256 processSigma = sigmaForFast;\n                uint256 obsVar = uncertainty + wmul(processSigma, processSigma);\n                uint256 probArb;\n                uint256 z2 = wdiv(wmul(ret, ret), obsVar);\n                uint256 density = _powWad(wdiv(WAD, WAD + z2 / 16), 8);\n                uint256 sigmaObs = sqrt(obsVar * WAD);\n                uint256 odds = wmul(density, wdiv(6700000000000000, sigmaObs));\n                bool arbFlag = ret <= wmul(sigmaForFast, 1220000000000000000);\n                uint256 prior = arbFlag ? 650000000000000000 : 400000000000000000;\n                uint256 tr = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n                if (tr > 3000000000000000) prior = wmul(prior, 6 * WAD / 10);\n                if (silent > 1) prior = wmul(prior, 8 * WAD / 10);\n                odds = wmul(odds, wdiv(prior, WAD - prior));\n                probArb = wdiv(odds, WAD + odds);\n                alpha = wmul(probArb, 600000000000000000) + wmul(WAD - probArb, 80000000000000000);\n                slots[15] = pImplied >= fastHat ? 1 : 2;\n                uncertainty = wmul(uncertainty, WAD - alpha);\n            } else {\n                if ((slots[15] == 1) == (pImplied >= fastHat)) alpha = PHAT_ALPHA_RETAIL;\n            }\n            uint256 gate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (gate < MIN_GATE) gate = MIN_GATE;\n            if (ret <= gate) fastHat = wmul(fastHat, WAD - alpha) + wmul(pImplied, alpha);\n            slots[13] = uncertainty;\n        }\n\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalObs = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            if ((slots[15] == 1) == (normalObs >= fastHat)) {\n                fastHat = wmul(fastHat, 9 * WAD / 10) + wmul(normalObs, WAD / 10);\n            }\n        }\n        slots[14] = fastHat;\n        uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n        if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n        if (tradeRatio > SIGNAL_THRESHOLD) {\n            uint256 push = tradeRatio * DIR_IMPACT_MULT;\n            if (push > WAD / 4) push = WAD / 4;\n            if (trade.isBuy) {\n                dirState = dirState + push;\n                if (dirState > 2 * WAD) dirState = 2 * WAD;\n            } else {\n                dirState = dirState > push ? dirState - push : 0;\n            }\n            actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n            sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n            if (sizeHat > WAD) sizeHat = WAD;\n        }\n\n        uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n        if (tox > TOX_CAP) tox = TOX_CAP;\n        toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n        uint256 toxSignal = toxEma;\n\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n        // Policy mixture: continuing retail flow versus a new-step arbitrage.\n        // The next event is unobserved; gate only on the history available now.\n        uint256 retailWeight = 30 * WAD / 100;\n        if (stepTradeCount >= 2) retailWeight = retailWeight * 65 / 100;\n        if (stepTradeCount >= 3) retailWeight = retailWeight * 65 / 100;\n        bool aligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n        if (aligned) retailWeight = retailWeight * 80 / 100;\n        if (silent > 1) retailWeight = retailWeight * 80 / 100;\n\n        uint256 flowSize = wmul(lambdaHat, sizeHat);\n        uint256 retailMid = 14 * BPS + wmul(500000000000000000, flowSize);\n        uint256 arbMid = BASE_FEE + wmul(600000000000000000, sigmaHat)\n            + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize)\n            + wmul(ACT_COEF, actEma) + wmul(TOX_COEF, toxSignal);\n        uint256 mid = wmul(retailWeight, retailMid) + wmul(WAD - retailWeight, arbMid);\n        uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n        uint256 deviation = wdiv(absDiff(spot, staleHat), staleHat);\n        if (deviation > TOX_CAP) deviation = TOX_CAP;\n        uint256 shiftCoef = wmul(retailWeight, 85 * WAD / 100)\n            + wmul(WAD - retailWeight, 60 * WAD / 100);\n        uint256 shift = wmul(deviation, shiftCoef);\n        uint256 bidFee; uint256 askFee;\n        if (spot >= staleHat) {\n            bidFee = mid + shift;\n            askFee = mid > shift ? mid - shift : 0;\n        } else {\n            askFee = mid + shift;\n            bidFee = mid > shift ? mid - shift : 0;\n        }\n        // Only the arb component pays the price-impact protection premium.\n        if (aligned) {\n            uint256 boost = wmul(WAD - retailWeight, wmul(TRADE_TOX_BOOST, tradeRatio));\n            if (trade.isBuy) bidFee += boost; else askFee += boost;\n        }\n        bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n        askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n\n        slots[0] = bidFee; slots[1] = askFee; slots[2] = trade.timestamp;\n        slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;\n        slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;\n        slots[16] = spot;\n        slots[9] = toxEma; slots[10] = stepTradeCount;\n\n        return (bidFee, askFee);\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    function getName() external pure override returns (string memory) { return \"phase_mixture_00\"; }\n}\n","sha256":"55da243087ca8e6e2fa9bf278001034bdd507c826b0a31cad9ac1b41334ddbef","paired":{"n":0,"mean_diff":null,"se":null,"worst":[]},"gas":{"max_ok":243612,"oog":8,"reverts":0,"other_halts":0,"transact_errors":0,"successful_afterSwap":931342,"successful_init":128,"max_init":236383,"max_name":21551,"max_deployment":1542237,"creation_bytecode_keccak256":"fb4a764fd2568fb4a0dbca900ee034ce1554ed60c9245c6a69b316830d304051","oog_afterSwap_confirmed":4,"oog_stage_unclassified_first_instrumentation":4},"baseline_gas":{"max_ok":243554,"oog":8,"reverts":0,"other_halts":0,"transact_errors":0,"successful_afterSwap":1305204,"successful_init":128,"max_init":236377,"max_name":21545,"max_deployment":1560600,"creation_bytecode_keccak256":"369eada8e43393968ef8975d4e4570434e3308edfd7da9c50d901de7c2ff71a2","oog_afterSwap_confirmed":4,"oog_stage_unclassified_first_instrumentation":4},"valid":false,"blocked":{"step":"250000-gas validity check on tuning seeds 10000..10063","error":"The exact SHA-verified V2 baseline produced 4 afterSwap OutOfGas(Basic) halts in the initial 64-seed batch and the same 4 in a diagnostic replay. The phase00 mixture likewise produced 4 plus 4 on replay. Raw EVM results were recorded before CFMM silently retained old fees on failure. Both codes/results are invalid under the brief. No valid paired statistic or confirmation is reported."},"decision":"Reject this candidate; no board-gain claim. Method failure terminates the experiment, rather than changing V2, raising gas, or excluding failing seeds.","baseline_sha256":"28417e116f57f1029fdd1803832e852574902c1ae7253c05657f317db76da4ab","tuning":{"variants_generated":12,"variants_executed":1,"executed_variant":"phase00","parameters":{"weight":30,"retailbase":14,"retailshift":85,"arbshift":60},"policy":"Retail midpoint = 14bps + 0.5*lambdaHat*sizeHat. Arb midpoint = 4bps + 0.6*sigmaHat + 12bps*lambdaHat + 0.4842*lambdaHat*sizeHat + 9.1843*actEma + 0.03*toxEma. Blend weight is 0.30 retail, multiplied by 0.65 at count>=2 and again at count>=3, by 0.80 when the observed direction aligns with the spot-versus-pHat predicate in the code, and by 0.80 when the observed quiet gap exceeds one. Blend stale-price shifts at coefficients 0.85 retail and 0.60 arb. Only the arb component uses trade-size protection. Original V2 estimator updates are retained; the original fee mapping is replaced.","inputs":"Only completed TradeInfo fields, V2 state, within-step count, and the observed timestamp gap. Future event type/time and true simulated price are not read.","screening_status":"Invalid; gas failure stops selection. No top-two stage and no frozen confirmation candidate.","observed_screen_edges_invalid":{"phase00_mean":491.1885088105845,"v2_mean":507.20132095534615,"n_unique_seeds":64,"warning":"Fallback-contaminated diagnostics only; not valid performance evidence."}},"seeds":{"tuning_screen":{"start":10000,"end":10063,"n":64,"n_steps":10000,"passes_per_code":2,"second_pass":"Gas failure diagnosis only; same code and same seeds."},"top_two":{"start":11000,"end":11255,"used":false},"confirmation":{"start":4010000,"end":4011999,"n":2000,"used":false},"coverage_probes":{"start":10000,"n":1,"n_steps":10,"separate_code_hashes":true}},"reproduce":{"repository":"https://github.com/benedictbrady/amm-challenge","commit":"6b6921f8d463314aa7c96234e1be25a25245f704","baseline_artifact_url":"https://api.imd.fun/artifacts/1f4f14f040b309e004904672ec6e2bb051f97b8d1195602d36b35a54c05d6c0f","baseline_transform":[{"from":"if (g > 4) g = 4;","to":"if (g > 1) g = 1;"},{"from":"_powWad(925000000000000000, g)","to":"_powWad(800000000000000000, g)"}],"setup_sh":"set -eu;R=$PWD/scratch;mkdir -p $R/tmp $R/bin $R/solcx\necho \"export TMPDIR=$R/tmp XDG_CACHE_HOME=$R/xc UV_CACHE_DIR=$R/uvc UV_PYTHON_INSTALL_DIR=$R/uvpy RUSTUP_HOME=$R/rustup CARGO_HOME=$R/cargo SOLCX_BINARY_PATH=$R/solcx VIRTUAL_ENV=$PWD/.venv PATH=$PWD/.venv/bin:$R/bin:$R/cargo/bin:\\$PATH\" >$R/env.sh;. $R/env.sh\ncommand -v uv >/dev/null||{ curl -LsSf https://github.com/astral-sh/uv/releases/latest/download/uv-x86_64-unknown-linux-gnu.tar.gz|tar --no-same-owner -xz -C $R/tmp;cp $R/tmp/uv-*/uv $R/bin/;}\ncc --version >/dev/null 2>&1||{ curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest -o $R/tmp/mm.tbz;python3 -c \"import sys,tarfile;tarfile.open(sys.argv[1]).extract('bin/micromamba',sys.argv[2])\" $R/tmp/mm.tbz $R;MAMBA_ROOT_PREFIX=$R/mamba $R/bin/micromamba create -yq -p $R/cenv -c conda-forge gcc;ln -sf $(ls $R/cenv/bin/*gcc|head -n1) $R/bin/cc;}\ncommand -v cargo >/dev/null||{ curl -sSf https://sh.rustup.rs|sh -s -- -y --profile minimal --no-modify-path;}\nuv venv --python 3.12 .venv;uv pip install -e . maturin\nmaturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml\namm-match validate contracts/src/StarterStrategy.sol\n","patch":"diff --git a/amm_sim_rs/src/evm/strategy.rs b/amm_sim_rs/src/evm/strategy.rs\nindex 1d06af1..8a5c17c 100644\n--- a/amm_sim_rs/src/evm/strategy.rs\n+++ b/amm_sim_rs/src/evm/strategy.rs\n@@ -8,6 +8,33 @@ use revm::{\n     Evm, InMemoryDB,\n };\n use thiserror::Error;\n+use std::sync::{Arc, Mutex, OnceLock};\n+use std::sync::atomic::{AtomicU64, Ordering};\n+use std::collections::HashMap;\n+// Per creation-bytecode keccak256. Counters are cumulative for this process.\n+// 0 swap max, 1 init max, 2 name max, 3 deploy max,\n+// 4 OOG (all categories), 5 reverts, 6 other halts, 7 transact errors,\n+// 8 successful swaps, 9 successful init, 10 successful name, 11 successful deploy.\n+// 12..15 OOG by category (swap, init, name, deploy); 16..19 reverts by category.\n+static GAS: OnceLock<Mutex<HashMap<String, Arc<[AtomicU64;20]>>>> = OnceLock::new();\n+pub fn gas_stats() -> HashMap<String, Vec<u64>> {\n+    GAS.get_or_init(Default::default).lock().unwrap().iter()\n+        .map(|(k,v)| (k.clone(), v.iter().map(|x| x.load(Ordering::Relaxed)).collect())).collect()\n+}\n+fn record(c: &[AtomicU64;20], r: &ExecutionResult, category: usize) {\n+    match r {\n+        ExecutionResult::Success { gas_used, .. } => {\n+            c[category].fetch_max(*gas_used, Ordering::Relaxed);\n+            c[8+category].fetch_add(1, Ordering::Relaxed);\n+        },\n+        ExecutionResult::Revert { .. } => { c[5].fetch_add(1, Ordering::Relaxed); c[16+category].fetch_add(1, Ordering::Relaxed); },\n+        ExecutionResult::Halt { reason, .. } => {\n+            let i = if matches!(reason, revm::primitives::HaltReason::OutOfGas(_)) {4} else {6};\n+            c[i].fetch_add(1, Ordering::Relaxed);\n+            if i == 4 { c[12+category].fetch_add(1, Ordering::Relaxed); }\n+        }\n+    }\n+}\n \n use crate::types::trade_info::{encode_after_initialize, decode_fee_pair, TradeInfo, SELECTOR_GET_NAME};\n use crate::types::wad::Wad;\n@@ -50,6 +77,7 @@ const CALLER_ADDRESS: Address = Address::new([\n pub struct EVMStrategy {\n     /// Strategy name (cached after first call)\n     name: String,\n+    counters: Arc<[AtomicU64;20]>,\n     /// Compiled bytecode (for reset)\n     bytecode: Vec<u8>,\n     /// In-memory database for EVM state\n@@ -61,7 +89,11 @@ pub struct EVMStrategy {\n impl EVMStrategy {\n     /// Create a new EVM strategy from compiled bytecode.\n     pub fn new(bytecode: Vec<u8>, default_name: String) -> Result<Self, EVMError> {\n+        let key = format!(\"{:x}\", revm::primitives::keccak256(&bytecode));\n+        let counters = GAS.get_or_init(Default::default).lock().unwrap()\n+            .entry(key).or_insert_with(|| Arc::new(std::array::from_fn(|_| AtomicU64::new(0)))).clone();\n         let mut strategy = Self {\n+            counters,\n             name: default_name,\n             bytecode: bytecode.clone(),\n             db: InMemoryDB::default(),\n@@ -102,7 +134,8 @@ impl EVMStrategy {\n                 .build();\n \n             let result = evm.transact_commit()\n-                .map_err(|e| EVMError::DeploymentFailed(format!(\"{:?}\", e)))?;\n+                .map_err(|e| { self.counters[7].fetch_add(1, Ordering::Relaxed); EVMError::DeploymentFailed(format!(\"{:?}\", e)) })?;\n+            record(&self.counters, &result, 3);\n \n             match result {\n                 ExecutionResult::Success { output, .. } => {\n@@ -207,7 +240,12 @@ impl EVMStrategy {\n             .build();\n \n         let result = evm.transact_commit()\n-            .map_err(|e| EVMError::ExecutionFailed(format!(\"{:?}\", e)))?;\n+            .map_err(|e| { self.counters[7].fetch_add(1, Ordering::Relaxed); EVMError::ExecutionFailed(format!(\"{:?}\", e)) })?;\n+        let category = if calldata == SELECTOR_GET_NAME {2} else if calldata.len() == 196 {0} else {1};\n+        record(&self.counters, &result, category);\n+        if matches!(result, ExecutionResult::Halt {..}) {\n+            eprintln!(\"PHASE_HALT category={} calldata={:x} result={:?}\", category, Bytes::copy_from_slice(calldata), result);\n+        }\n \n         match result {\n             ExecutionResult::Success { output, .. } => {\ndiff --git a/amm_sim_rs/src/lib.rs b/amm_sim_rs/src/lib.rs\nindex 35d9e59..7037dc2 100644\n--- a/amm_sim_rs/src/lib.rs\n+++ b/amm_sim_rs/src/lib.rs\n@@ -65,10 +65,16 @@ fn run_single(\n         .map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))\n }\n \n+#[pyfunction]\n+fn gas_stats() -> std::collections::HashMap<String, Vec<u64>> {\n+    crate::evm::strategy::gas_stats()\n+}\n+\n /// Python module definition\n #[pymodule]\n fn amm_sim_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {\n     m.add_function(wrap_pyfunction!(run_batch, m)?)?;\n+    m.add_function(wrap_pyfunction!(gas_stats, m)?)?;\n     m.add_function(wrap_pyfunction!(run_single, m)?)?;\n     m.add_class::<SimulationConfig>()?;\n     m.add_class::<LightweightSimResult>()?;\ndiff --git a/amm_sim_rs/src/simulation/engine.rs b/amm_sim_rs/src/simulation/engine.rs\nindex 6834c43..cd02548 100644\n--- a/amm_sim_rs/src/simulation/engine.rs\n+++ b/amm_sim_rs/src/simulation/engine.rs\n@@ -177,7 +177,7 @@ impl SimulationEngine {\n                     *cumulative_ask_fees.get_mut(name).unwrap() += ask_fee;\n                 }\n             }\n-            steps.push(step);\n+            if std::env::var_os(\"AMM_KEEP_STEPS\").is_some() { steps.push(step); }\n         }\n \n         // Calculate final PnL (reserves + accumulated fees)\n","experiment_py":"import json, hashlib, time, sys\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.validator import SolidityValidator\nfrom amm_competition.competition.config import build_config\nROOT=Path('scratch'); compiler=SolidityCompiler()\ndef compiled(path,contract='Strategy'):\n s=Path(path).read_text(); h=hashlib.sha256(s.encode()).hexdigest(); cache=ROOT/(h+'.bin')\n if not cache.exists():\n  r=compiler.compile(s,contract); assert r.success, r.errors\n  cache.write_bytes(r.bytecode)\n return cache.read_bytes()\ndef configs(start,n,steps=10000):\n out=[]\n for seed in range(start,start+n):\n  r=np.random.default_rng(seed)\n  c=build_config(seed=seed,retail_mean_size=r.uniform(19,21),retail_arrival_rate=r.uniform(.6,1),gbm_sigma=r.uniform(.000882,.001008))\n  if steps!=10000: c.n_steps=steps\n  out.append(c)\n return out\nvanilla=compiled('contracts/src/VanillaStrategy.sol','VanillaStrategy')\ndef run(path,start,n,label,steps=10000):\n code=compiled(path); t=time.monotonic()\n b=amm_sim_rs.run_batch(list(code),list(vanilla),configs(start,n,steps),8)\n out={'label':label,'sha256':hashlib.sha256(Path(path).read_bytes()).hexdigest(),'edges':{str(x.seed):x.edges['submission'] for x in b.results},'gas_raw':amm_sim_rs.gas_stats(),'seconds':time.monotonic()-t}\n (ROOT/(label+'.json')).write_text(json.dumps(out)); print(label, out['seconds'],np.mean(list(out['edges'].values())),out['gas_raw'],flush=True)\n return out\nif __name__=='__main__':\n run(sys.argv[1],int(sys.argv[2]),int(sys.argv[3]),sys.argv[4],int(sys.argv[5]) if len(sys.argv)>5 else 10000)\n","coverage_py":"import os,json\nfrom pathlib import Path\nfrom experiment import compiled,configs,vanilla\nimport amm_sim_rs\nfrom amm_competition.evm.validator import SolidityValidator\np=Path('scratch/phase00.sol');v=SolidityValidator().validate(p.read_text());assert v.valid,v.errors\nbase=Path('contracts/src/VanillaStrategy.sol').read_text().replace('contract VanillaStrategy','contract Strategy').replace('TradeInfo calldata)','TradeInfo calldata trade)')\n# Intentional failures for the instrumentation, separate hashes from the experiment.\nfor kind,body in [('oog','uint256 k; for (uint256 i; i < trade.timestamp + 1000000; ++i) k += i; return (k, k);'),('revert','revert(\"counter probe\");')]:\n src=base.replace('function afterSwap(TradeInfo calldata trade) external pure override returns (uint256 bidFee, uint256 askFee) {\\n        return (FEE, FEE);','function afterSwap(TradeInfo calldata trade) external pure override returns (uint256 bidFee, uint256 askFee) {\\n        '+body)\n path=Path('scratch/probe_'+kind+'.sol');path.write_text(src)\n b=amm_sim_rs.run_batch(list(compiled(path)),list(vanilla),configs(10000,1,10),8)\n print(kind,amm_sim_rs.gas_stats(),flush=True)\n# Telemetry retention must not affect market results.\na=amm_sim_rs.run_batch(list(vanilla),list(vanilla),configs(10000,1,10),8).results[0]\nos.environ['AMM_KEEP_STEPS']='1'\nb=amm_sim_rs.run_batch(list(vanilla),list(vanilla),configs(10000,1,10),8).results[0]\nassert a.edges==b.edges\nassert len(a.steps)==0 and len(b.steps)==10\nprint('telemetry_edges_equal',a.edges,'steps',len(a.steps),len(b.steps),flush=True)\nPath('scratch/coverage.json').write_text(json.dumps({'static_validation':v.valid,'telemetry_edges_equal':a.edges==b.edges,'stats':amm_sim_rs.gas_stats()}))\n","commands":["Clone and checkout the pinned repository under test/scratch in the workspace. Save setup_sh as scratch/setup.sh and run sh scratch/setup.sh once from checkout root.","Save patch to scratch/instrument.patch; apply with git apply scratch/instrument.patch.",". scratch/env.sh && maturin develop --release --uv --manifest-path amm_sim_rs/Cargo.toml","Fetch baseline_artifact_url JSON, transform its code using baseline_transform, save scratch/V2.sol and verify baseline_sha256. Save result.code to scratch/phase00.sol. Save experiment_py and coverage_py under scratch/.",". scratch/env.sh && python scratch/experiment.py scratch/V2.sol 10000 64 v2_screen",". scratch/env.sh && python scratch/experiment.py scratch/phase00.sol 10000 64 phase00_screen","Repeat the previous two batches with labels v2_recheck and phase00_recheck to reproduce cumulative OOG=8 per code. The final patch classifies all 8 as swap OOG; the original first-pass patch only counted total OOG.",". scratch/env.sh && python scratch/coverage.py"],"configuration":"MatchRunner defaults: initial price100, reserves100X/10000Y, mu0, dt1, retail_buy_prob0.5, retail_size_sigma1.2. For each seed, default_rng(seed) draws size uniform19..21, rate uniform0.6..1.0, sigma uniform0.000882..0.001008 in that order. Price seed=seed, retail seed=seed+1. Full10000 steps; 8 workers. Each strategy is measured separately against VanillaStrategy.","gas_coverage":"Counters attach by keccak256 of creation bytecode and record every revm transact_commit outcome for deployment, name, init, and swap before caller error handling. OOG catches every OutOfGas subtype; reverts, other halts and transact errors are separate. Strategies cannot use external CALL/CREATE opcodes under compiler validation, so no internal subcall OOG is hidden. max_ok is the highest successful method-call gas (including transaction overhead), excluding deployment which has its own 10M limit. Swap/init limits remain 250000; name remains50000. Counters are cumulative across all recorded runs of each source hash, including the diagnostic replay. Initial first-pass counters lack stage breakdown; second-pass traces prove four swap OOG per code. No init OOG/revert.","telemetry_patch":"Only suppresses storing step objects unless AMM_KEEP_STEPS is set. It preserves all10000 simulation iterations, routing, edges, and fee accumulation. Ten-step Vanilla equality test passed; production batches use full10000 steps.","counter_vector_schema":["max_swap","max_init","max_name","max_deploy","oog_all","revert_all","other_halt_all","transact_error_all","swap_successes","init_successes","name_successes","deploy_successes","swap_oog","init_oog","name_oog","deploy_oog","swap_revert","init_revert","name_revert","deploy_revert"],"runs":[{"label":"v2_screen","sha256":"28417e116f57f1029fdd1803832e852574902c1ae7253c05657f317db76da4ab","edges":{"10000":489.4875846678468,"10001":552.3376592263003,"10002":443.04632640588295,"10003":651.7063161382114,"10004":484.2388697905094,"10005":457.33261468435177,"10006":537.3889706173123,"10007":377.5880580514884,"10008":547.6205686765301,"10009":530.3844696555415,"10010":386.9915858804041,"10011":624.8827325769018,"10012":386.1637045730268,"10013":513.3808098131996,"10014":582.5607905342006,"10015":512.4676158443093,"10016":459.3616151834102,"10017":487.6150401351785,"10018":467.5687107678776,"10019":561.9885255499795,"10020":578.7775715709229,"10021":494.8256247738197,"10022":638.5508016262252,"10023":613.3806812748771,"10024":523.4514513515137,"10025":695.7786982598221,"10026":382.26831773404274,"10027":402.8122474470081,"10028":633.2460054247881,"10029":625.1944880210727,"10030":423.0443899803179,"10031":459.7872608073037,"10032":460.18241706247323,"10033":525.0423232741383,"10034":509.66458013511846,"10035":455.6608938547329,"10036":441.4674432925074,"10037":380.0480351718999,"10038":605.4554051716743,"10039":413.92969037273326,"10040":598.9924417927327,"10041":414.329343167078,"10042":485.5646832498663,"10043":541.9818525891465,"10044":581.4717821322387,"10045":666.6030868590738,"10046":342.1733495265246,"10047":417.537143768049,"10048":447.2622656863229,"10049":577.5332468642747,"10050":505.61167333792514,"10051":483.3747656130455,"10052":525.5503336959321,"10053":675.8198357609583,"10054":510.53554563519504,"10055":388.2951247359226,"10056":448.7263457807222,"10057":441.4116335628231,"10058":431.834634692024,"10059":620.8216515551558,"10060":642.5347407308922,"10061":493.8653531277287,"10062":500.55356300437916,"10063":401.8192488946894},"gas_raw":{"369eada8e43393968ef8975d4e4570434e3308edfd7da9c50d901de7c2ff71a2":[243554,236377,21545,1560600,4,0,0,0,652602,64,64,64],"50ebcba4f67d87148ce66cd0830ec11d4fd863db01141bdaddbbc69bf02e592f":[22592,21796,21526,191464,0,0,0,0,673205,64,64,64]},"seconds":9.077734854072332},{"label":"phase00_screen","sha256":"55da243087ca8e6e2fa9bf278001034bdd507c826b0a31cad9ac1b41334ddbef","edges":{"10000":473.02771569738337,"10001":527.6035233407418,"10002":426.83502525422824,"10003":635.0161919015155,"10004":466.96625673004985,"10005":442.22691670912513,"10006":519.0419204508986,"10007":363.4542757915909,"10008":534.1829844088045,"10009":513.872938876895,"10010":371.10245284055776,"10011":602.2236264002869,"10012":372.6272774420794,"10013":496.8045967964026,"10014":565.7609093191626,"10015":497.40610027225546,"10016":445.6282618554795,"10017":471.9315015387086,"10018":453.4556784781646,"10019":541.9572670111972,"10020":557.2610597140753,"10021":483.46262206909057,"10022":623.883634022139,"10023":597.4968569252228,"10024":508.78151009262433,"10025":675.7196396404373,"10026":370.7976974597943,"10027":391.7106978267579,"10028":613.7227946274793,"10029":600.6368602992286,"10030":408.3951818215286,"10031":442.576310646391,"10032":447.90854841236336,"10033":505.0966574446999,"10034":488.4630176757056,"10035":442.76783915152316,"10036":425.493733115263,"10037":369.85494188863095,"10038":590.1609991795374,"10039":400.86059684264995,"10040":580.9643802374944,"10041":403.8824102232486,"10042":467.3324015137881,"10043":523.0795064413725,"10044":565.1224984271362,"10045":649.3052563576958,"10046":330.2548499536503,"10047":407.7135507438371,"10048":436.39071420690084,"10049":560.8152080493879,"10050":489.8409050634447,"10051":469.5109068234592,"10052":507.8228842590351,"10053":653.4496764329571,"10054":498.1657848209681,"10055":375.4098577724244,"10056":435.9039397825681,"10057":425.5334351620368,"10058":418.51696514718515,"10059":597.5926487584301,"10060":623.1601473920606,"10061":480.5026313339713,"10062":483.2091073777464,"10063":386.40827762594046},"gas_raw":{"50ebcba4f67d87148ce66cd0830ec11d4fd863db01141bdaddbbc69bf02e592f":[22592,21796,21526,191464,0,0,0,0,725512,64,64,64],"fb4a764fd2568fb4a0dbca900ee034ce1554ed60c9245c6a69b316830d304051":[243612,236383,21551,1542237,4,0,0,0,465671,64,64,64]},"seconds":8.345076009165496},{"label":"v2_recheck","sha256":"28417e116f57f1029fdd1803832e852574902c1ae7253c05657f317db76da4ab","edges":{"10000":489.4875846678468,"10001":552.3376592263003,"10002":443.04632640588295,"10003":651.7063161382114,"10004":484.2388697905094,"10005":457.33261468435177,"10006":537.3889706173123,"10007":377.5880580514884,"10008":547.6205686765301,"10009":530.3844696555415,"10010":386.9915858804041,"10011":624.8827325769018,"10012":386.1637045730268,"10013":513.3808098131996,"10014":582.5607905342006,"10015":512.4676158443093,"10016":459.3616151834102,"10017":487.6150401351785,"10018":467.5687107678776,"10019":561.9885255499795,"10020":578.7775715709229,"10021":494.8256247738197,"10022":638.5508016262252,"10023":613.3806812748771,"10024":523.4514513515137,"10025":695.7786982598221,"10026":382.26831773404274,"10027":402.8122474470081,"10028":633.2460054247881,"10029":625.1944880210727,"10030":423.0443899803179,"10031":459.7872608073037,"10032":460.18241706247323,"10033":525.0423232741383,"10034":509.66458013511846,"10035":455.6608938547329,"10036":441.4674432925074,"10037":380.0480351718999,"10038":605.4554051716743,"10039":413.92969037273326,"10040":598.9924417927327,"10041":414.329343167078,"10042":485.5646832498663,"10043":541.9818525891465,"10044":581.4717821322387,"10045":666.6030868590738,"10046":342.1733495265246,"10047":417.537143768049,"10048":447.2622656863229,"10049":577.5332468642747,"10050":505.61167333792514,"10051":483.3747656130455,"10052":525.5503336959321,"10053":675.8198357609583,"10054":510.53554563519504,"10055":388.2951247359226,"10056":448.7263457807222,"10057":441.4116335628231,"10058":431.834634692024,"10059":620.8216515551558,"10060":642.5347407308922,"10061":493.8653531277287,"10062":500.55356300437916,"10063":401.8192488946894},"gas_raw":{"50ebcba4f67d87148ce66cd0830ec11d4fd863db01141bdaddbbc69bf02e592f":[22592,21796,21526,191464,0,0,0,0,673205,64,64,64,0,0,0,0,0,0,0,0],"369eada8e43393968ef8975d4e4570434e3308edfd7da9c50d901de7c2ff71a2":[243554,236377,21545,1560600,4,0,0,0,652602,64,64,64,4,0,0,0,0,0,0,0]},"seconds":9.19326695613563},{"label":"phase00_recheck","sha256":"55da243087ca8e6e2fa9bf278001034bdd507c826b0a31cad9ac1b41334ddbef","edges":{"10000":473.02771569738337,"10001":527.6035233407418,"10002":426.83502525422824,"10003":635.0161919015155,"10004":466.96625673004985,"10005":442.22691670912513,"10006":519.0419204508986,"10007":363.4542757915909,"10008":534.1829844088045,"10009":513.872938876895,"10010":371.10245284055776,"10011":602.2236264002869,"10012":372.6272774420794,"10013":496.8045967964026,"10014":565.7609093191626,"10015":497.40610027225546,"10016":445.6282618554795,"10017":471.9315015387086,"10018":453.4556784781646,"10019":541.9572670111972,"10020":557.2610597140753,"10021":483.46262206909057,"10022":623.883634022139,"10023":597.4968569252228,"10024":508.78151009262433,"10025":675.7196396404373,"10026":370.7976974597943,"10027":391.7106978267579,"10028":613.7227946274793,"10029":600.6368602992286,"10030":408.3951818215286,"10031":442.576310646391,"10032":447.90854841236336,"10033":505.0966574446999,"10034":488.4630176757056,"10035":442.76783915152316,"10036":425.493733115263,"10037":369.85494188863095,"10038":590.1609991795374,"10039":400.86059684264995,"10040":580.9643802374944,"10041":403.8824102232486,"10042":467.3324015137881,"10043":523.0795064413725,"10044":565.1224984271362,"10045":649.3052563576958,"10046":330.2548499536503,"10047":407.7135507438371,"10048":436.39071420690084,"10049":560.8152080493879,"10050":489.8409050634447,"10051":469.5109068234592,"10052":507.8228842590351,"10053":653.4496764329571,"10054":498.1657848209681,"10055":375.4098577724244,"10056":435.9039397825681,"10057":425.5334351620368,"10058":418.51696514718515,"10059":597.5926487584301,"10060":623.1601473920606,"10061":480.5026313339713,"10062":483.2091073777464,"10063":386.40827762594046},"gas_raw":{"fb4a764fd2568fb4a0dbca900ee034ce1554ed60c9245c6a69b316830d304051":[243612,236383,21551,1542237,4,0,0,0,465671,64,64,64,4,0,0,0,0,0,0,0],"50ebcba4f67d87148ce66cd0830ec11d4fd863db01141bdaddbbc69bf02e592f":[22592,21796,21526,191464,0,0,0,0,725512,64,64,64,0,0,0,0,0,0,0,0]},"seconds":7.4965602601878345}],"halt_traces":{"v2_recheck":["PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026ab1ba6e5374e0000000000000000000000000000000000000000000000000f232285acddb88000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000005695cac72f4bc800000000000000000000000000000000000000000000000021f0bfa251023a00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039f7c1b715eae800000000000000000000000000000000000000000000000016b64750b1ce7100000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000056827e211f1b1400000000000000000000000000000000000000000000000021f852008a89ee00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000032441566e2805600000000000000000000000000000000000000000000000013af7d20fe207900000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000056b4bd10d4e65800000000000000000000000000000000000000000000000021e4a283698bce00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000023b9c44a4fa9fc0000000000000000000000000000000000000000000000000ded66e24275e080000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000056e02bfe99b6e800000000000000000000000000000000000000000000000021d3b0a5b968ae00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }"],"phase00_recheck":["PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039f7c1b715eae800000000000000000000000000000000000000000000000016b64750b1ce7100000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000056827e211f1b1400000000000000000000000000000000000000000000000021f852008a89ee00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000032441566e2805600000000000000000000000000000000000000000000000013af7d20fe207900000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000056b4bd10d4e65800000000000000000000000000000000000000000000000021e4a283698bce00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000023b9c44a4fa9fc0000000000000000000000000000000000000000000000000ded66e24275e080000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000056e02bfe99b6e800000000000000000000000000000000000000000000000021d3b0a5b968ae00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }","PHASE_HALT category=0 calldata=0xc2babb570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026ab1ba6e5374e0000000000000000000000000000000000000000000000000f232285acddb88000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000005695cac72f4bc800000000000000000000000000000000000000000000000021f0bfa251023a00000 result=Halt { reason: OutOfGas(Basic), gas_used: 250000 }"]},"coverage":{"static_validation":true,"telemetry_edges_equal":true,"stats":{"af788fec842e6e940ef065a22c386ea0ae4a51c97e058778676796eee4ca1da5":[0,21803,21534,207952,10,0,0,0,0,1,1,1,10,0,0,0,0,0,0,0],"50ebcba4f67d87148ce66cd0830ec11d4fd863db01141bdaddbbc69bf02e592f":[22568,21796,21526,191464,0,0,0,0,60,6,6,6,0,0,0,0,0,0,0,0],"f9662aced8739f5f44b4a3b2cac66201ec2d3c351ef8f8d82556c740cfc0fc24":[0,21796,21526,197784,0,10,0,0,0,1,1,1,0,0,0,0,10,0,0,0]}},"coverage_results":"Static Solidity validation passed for phase00. Intentional heavy-loop probe recorded10 swap OOG despite simulator fallback, and intentional revert probe recorded10 swap reverts. Probe hashes are disjoint from both experimental hashes. Telemetry on/off returned identical edges on a ten-step Vanilla smoke check."}}