{
  "blocked": {
    "step": "V2 baseline gas validation on tuning seeds 10000..10255",
    "error": "Instrumented amm_sim_rs.run_batch(V2, VanillaStrategy, configs, 8) completed with 7 OutOfGas halts and 0 other EVM halts/reverts. Highest successful call used 243554 gas. The brief invalidates comparisons containing any OOG call. Tuning was interrupted; no candidate was selected and confirmation was not started."
  },
  "design": {
    "name": "Design A: quote by observed step position",
    "status": "Experimental A1 source; compiles, not a validated or frozen entry",
    "retail_rule": "After first observed print, mid = 15bps + 0.5*sizeHat. Linearized equal-reserve two-pool router: share(f) approximately 1/2+(30bps-f)/(4*size). Maximizing f*share(f)*flow gives 15bps+size. A1 tests half that size premium to account for estimator scale and the chance the step ends immediately. This is an approximation; not an exact router optimizer.",
    "arb_rule": "After later prints, mid = 4bps + 0.7*sigmaHat + 0.4842*lambdaHat*sizeHat. Bid/ask skew = 0.8*abs(spot-estimate)/estimate with estimate=0.7*pHat+0.3*fastHat. This is a heuristic volatility/expected-gap premium, not a proven optimum.",
    "position_inference": "Reuse V2 stepTradeCount and timestamp. Count==0 before increment identifies first observed callback; reset only when timestamp increases. No additional storage. First callback can be retail if arbitrage does not execute. There is no allowed input revealing that the current callback will be the last. First predicts same-step continuation; later predicts next-step continuation.",
    "position_error": {
      "scope": "V2 baseline only; next observed callback, excluding final callback of each seed",
      "first_then_same": 689820,
      "first_then_new": 1036833,
      "later_then_same": 227572,
      "later_then_new": 689706,
      "misclassified": 1264405,
      "total": 2643931,
      "rate": 0.4782291973580248,
      "qualification": "Timestamp/count identify first observed print exactly by definition. These counts measure the separate next-position heuristic, not arb-vs-retail classification accuracy. Baseline includes OOG, so this diagnostic is contaminated and cannot certify candidate behavior."
    }
  },
  "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        // Timestamp/count identify the first observed print, not the end of the step.\n        // Linearized two-pool router share: s(f) = 1/2 + (30bps-f)/(4*size).\n        // max f*s(f)*flow gives f = 15bps + size at equal prices.\n        uint256 retailMid = 15 * BPS + wmul(sizeHat, 500000000000000000);\n        // Later prints use a volatility premium and expected arrival flow instead.\n        uint256 arbMid = 4 * BPS + wmul(sigmaHat, 700000000000000000) + wmul(wmul(lambdaHat,sizeHat), 4842 * BPS);\n        uint256 mid = firstInStep ? retailMid : arbMid;\n        uint256 estimate = wmul(pHat, 7 * WAD / 10) + wmul(fastHat, 3 * WAD / 10);\n        uint256 gap = wdiv(absDiff(spot, estimate), estimate);\n        if (gap > TOX_CAP) gap = TOX_CAP;\n        uint256 shift = wmul(gap, 800000000000000000);\n        uint256 bidFee;\n        uint256 askFee;\n        if (spot >= estimate) { bidFee = mid + shift; askFee = mid > shift ? mid - shift : 0; }\n        else { askFee = mid + shift; bidFee = mid > shift ? mid - shift : 0; }\n        bidFee = clampFee(bidFee); askFee = clampFee(askFee);\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 \"no_cubic\"; }\n}\n",
  "sha256": "68cc95b39e04f78af6975f5fbc0781e2edbf644d4fc427ab192d64723bc33f0a",
  "tuning": [],
  "paired": {
    "n": 0,
    "mean_diff": null,
    "se": null,
    "worst5": []
  },
  "gas": {
    "V2": {
      "max_ok": 243554,
      "oog": 7,
      "other_halts": 0,
      "n_seeds": 256
    },
    "candidate": {
      "max_ok": null,
      "oog": null,
      "other_halts": null,
      "n_seeds": 0
    }
  },
  "notes": {
    "nothing_fabricated": "No edge gain, standard error, candidate gas result, board score, or confirmation result is claimed. Null metrics were not measured. Candidate simulation was interrupted before a complete batch returned. No fabricated values replace the missing results.",
    "setup": "Pinned checkout 6b6921f8d463314aa7c96234e1be25a25245f704; supplied scratch/setup.sh run once successfully, StarterStrategy validation passed. Scratch checkout is excluded from delivery.",
    "baseline_sha256": "28417e116f57f1029fdd1803832e852574902c1ae7253c05657f317db76da4ab",
    "baseline_construction": "Fetch code from the specified api.imd.fun artifact, apply precisely the two requested replacements, encode UTF-8, verify the provided SHA-256. The reproduced digest matched.",
    "configs": "For each seed 10000..10255: np.random.default_rng(seed), uniform size [19,21], then rate [0.6,1.0], then sigma [0.000882,0.001008]. 10000 steps; initial price 100, X 100, Y 10000, mu 0, dt 1, retail_size_sigma 1.2, retail_buy_prob 0.5; config seed=seed. Simulator handles price seed=seed and retail seed+1.",
    "measurement": "Added atomic counters in amm_sim_rs/src/evm/strategy.rs around EVMStrategy.call execution results: successful gas_used max; HaltReason::OutOfGas count; other Halt and Revert count. Python-exposed reset/read counters bracket each run_batch. Counters exclude calls after getName resolves Vanilla_30bps; initial name calls are included, harmless for peak. Init/name included in peak; deployment is not. Rust-side instrumentation does not change Solidity bytecode or the EVM gas budget. Transport errors were not separately instrumented; other_halts counts EVM Halt/Revert outcomes.",
    "reproduce": "Run supplied setup in pinned checkout; apply the included instrumentation script; rebuild maturin; run the included baseline reproduction script. The candidate retains V2 estimators and replaces the mapping block, with a cheaper closed-form quote calculation. Candidate peak relative to V2 is unverified; do not adopt without a clean measurement.",
    "instrumentation_script": "from pathlib import Path\np=Path('amm_sim_rs/src/evm/strategy.rs');s=p.read_text();s=s.replace('use revm::{','use std::sync::atomic::{AtomicU64, Ordering};\\npub static MAX_OK: AtomicU64 = AtomicU64::new(0);\\npub static OOG: AtomicU64 = AtomicU64::new(0);\\npub static OTHER: AtomicU64 = AtomicU64::new(0);\\npub static POS: [AtomicU64;4] = [const { AtomicU64::new(0) };4];\\n\\nuse revm::{',1)\ns=s.replace('    name: String,','    name: String,\\n    position: Option<(u64,bool)>,',1).replace('            name: default_name,','            name: default_name,\\n            position: None,',1)\ns=s.replace('        // Encode trade info into pre-allocated buffer','''        if self.name != \"Vanilla_30bps\" {\n            let first = self.position.map_or(true, |(t,_)| t != trade.timestamp);\n            if let Some((t, was_first)) = self.position {\n                let next_same = t == trade.timestamp;\n                POS[(if was_first {0} else {2}) + (if next_same {0} else {1})].fetch_add(1, Ordering::Relaxed);\n            }\n            self.position = Some((trade.timestamp, first));\n        }\n        // Encode trade info into pre-allocated buffer''',1)\na=s.index('    fn call(');before=s[:a];after=s[a:]\nafter=after.replace('ExecutionResult::Success { output, .. } => {','ExecutionResult::Success { output, gas_used, .. } => {\\n                if self.name != \"Vanilla_30bps\" { MAX_OK.fetch_max(gas_used, Ordering::Relaxed); }',1)\nafter=after.replace('ExecutionResult::Revert { output, .. } => {','ExecutionResult::Revert { output, .. } => {\\n                if self.name != \"Vanilla_30bps\" { OTHER.fetch_add(1, Ordering::Relaxed); }',1)\nafter=after.replace('Err(EVMError::OutOfGas)','{ if self.name != \"Vanilla_30bps\" { OOG.fetch_add(1, Ordering::Relaxed); } Err(EVMError::OutOfGas) }',1)\nafter=after.replace('Err(EVMError::ExecutionFailed(format!(\"Halted: {:?}\", reason)))','{ if self.name != \"Vanilla_30bps\" { OTHER.fetch_add(1, Ordering::Relaxed); } Err(EVMError::ExecutionFailed(format!(\"Halted: {:?}\", reason))) }',1)\np.write_text(before+after)\np=Path('amm_sim_rs/src/lib.rs');s=p.read_text();s=s.replace('/// Python module definition','''#[pyfunction]\nfn measurement(reset: bool) -> Vec<u64> {\n    use crate::evm::strategy::{MAX_OK,OOG,OTHER,POS};\n    use std::sync::atomic::Ordering;\n    [&MAX_OK,&OOG,&OTHER,&POS[0],&POS[1],&POS[2],&POS[3]].iter().map(|a| if reset {a.swap(0,Ordering::Relaxed)} else {a.load(Ordering::Relaxed)}).collect()\n}\n\n/// Python module definition''');s=s.replace('    m.add_function(wrap_pyfunction!(run_batch, m)?)?;','    m.add_function(wrap_pyfunction!(run_batch, m)?)?;\\n    m.add_function(wrap_pyfunction!(measurement, m)?)?;');p.write_text(s)\n",
    "baseline_reproduction_script": "from pathlib import Path\nimport hashlib, numpy as np, amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.competition.config import build_config\ncompiler=SolidityCompiler()\ndef compile(s,name=\"Strategy\"):\n    r=compiler.compile(s,name); assert r.success,r.errors; return list(r.bytecode)\n# V2.sol must be constructed from the requested artifact with the two specified replacements.\ns=Path(\"scratch/V2.sol\").read_text()\nassert hashlib.sha256(s.encode()).hexdigest()==\"28417e116f57f1029fdd1803832e852574902c1ae7253c05657f317db76da4ab\"\nv2=compile(s)\nvanilla=compile(Path(\"contracts/src/VanillaStrategy.sol\").read_text(),\"VanillaStrategy\")\nconfigs=[]\nfor seed in range(10000,10256):\n    rng=np.random.default_rng(seed)\n    size=rng.uniform(19,21); rate=rng.uniform(.6,1.0); sigma=rng.uniform(.000882,.001008)\n    configs.append(build_config(seed=seed,gbm_sigma=sigma,retail_arrival_rate=rate,retail_mean_size=size))\nsim.measurement(True)\nresult=sim.run_batch(v2,vanilla,configs,8)\nprint(sim.measurement(True))\n"
  }
}