## delta

Starting from NP2, reconstructed from the [TWO code](https://api.imdnotdead.fun/artifacts/528a6da78583c6142644a552c86670f9d25c20e39e92f4de44deae05ddc8cecd) and [interior retail block](https://api.imdnotdead.fun/artifacts/da313379a2e69e9286668865e06b18dfcae25732c82b934b0fd9c2ef0d8c2ff5), add `PRESPOT_MIN_RATIO = WAD/100` and `PRESPOT_ALPHA = WAD/20`. For prints with `amountY/reserveY ≥ 1%`, undo the fee-adjusted reserve change using `amountX`, `amountY`, and `gamma`; blend `pHat` 95/5 toward the recovered `preY/preX` before computing fees.

## code

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {AMMStrategyBase} from "./AMMStrategyBase.sol";
import {TradeInfo} from "./IAMMStrategy.sol";

contract Strategy is AMMStrategyBase {
    uint256 constant PRESPOT_MIN_RATIO = WAD / 100;
    uint256 constant PRESPOT_ALPHA = WAD / 20;
    uint256 constant ELAPSED_CAP = 8;
    uint256 constant SIGNAL_THRESHOLD = WAD / 650;
    uint256 constant DIR_DECAY = 750000000000000000;
    uint256 constant ACT_DECAY = 530000000000000000;
    uint256 constant SIZE_DECAY = 530000000000000000;
    uint256 constant TOX_DECAY = 910000000000000000;
    uint256 constant SIGMA_DECAY = 690000000000000000;
    uint256 constant LAMBDA_DECAY = 990000000000000000;
    uint256 constant SIZE_BLEND_DECAY = 828000000000000000;
    uint256 constant TOX_BLEND_DECAY = 51000000000000000;
    uint256 constant ACT_BLEND_DECAY = 985000000000000000;
    uint256 constant PHAT_ALPHA = 270000000000000000;
    uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;
    uint256 constant PHAT_ALPHA_SAME = 120000000000000000;
    uint256 constant REVERT_U = 0;
    uint256 constant DIR_IMPACT_MULT = 4;
    uint256 constant GATE_SIGMA_MULT = 7200000000000000000;
    uint256 constant MIN_GATE = 30000000000000000;
    uint256 constant TRADE_TOX_BOOST = 3500 * BPS;
    uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;
    uint256 constant RET_CAP = WAD / 35;
    uint256 constant TOX_CAP = WAD / 5;
    uint256 constant TRADE_RATIO_CAP = WAD / 5;
    uint256 constant LAMBDA_CAP = 1820000000000000000;
    uint256 constant STEP_COUNT_CAP = 64;
    uint256 constant BASE_FEE = 4 * BPS;
    uint256 constant SIGMA_COEF = 200000000000000000;
    uint256 constant LAMBDA_COEF = 12 * BPS;
    uint256 constant FLOW_SIZE_COEF = 4842 * BPS;
    uint256 constant TOX_COEF = 300 * BPS;
    uint256 constant TOX_QUAD_COEF = 15000 * BPS;
    uint256 constant ACT_COEF = 91843 * BPS;
    uint256 constant DIR_COEF = 20 * BPS;
    uint256 constant DIR_TOX_COEF = 100 * BPS;
    uint256 constant STALE_DIR_COEF = 6850 * BPS;
    uint256 constant SIGMA_TOX_COEF = 500 * BPS;
    uint256 constant TAIL_KNEE = 600 * BPS;
    uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;
    uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;

    function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {
        slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[2] = 0; slots[3] = WAD; slots[4] = 0;
        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;
        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;
        slots[9] = 0; slots[10] = 0; slots[11] = 0; slots[12] = 0;
        return (BASE_FEE, BASE_FEE);
    }

    function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {
        uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = slots[2];
        uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];
        uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];
        uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];

        bool isNewStep = trade.timestamp > lastTs;
        if (isNewStep) {
            uint256 elapsedRaw = trade.timestamp - lastTs;
            uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;
            dirState = _decayCentered(dirState, DIR_DECAY, elapsed);
            actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));
            sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));
            toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));
            if (stepTradeCount > 0 && elapsedRaw > 0) {
                uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;
                if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;
                lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);
            }
            stepTradeCount = 0;
        }

        bool firstInStep = stepTradeCount == 0;
        uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;
        if (pHat == 0) pHat = spot;

        uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;
        uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;
        uint256 pImplied;
        if (gamma == 0) { pImplied = spot; }
        else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }

        {
            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;
            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;
            uint256 prePhat = pHat;
            bool secondPrint = !firstInStep && stepTradeCount == 1;
            bool sameDir = false; bool oppDir = false;
            if (secondPrint) {
                bool up2 = pImplied >= pHat;
                uint256 d1 = slots[12];
                if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }
                if (sameDir) alpha = PHAT_ALPHA_SAME;
            }
            if (firstInStep) { slots[11] = pHat; slots[12] = pImplied >= pHat ? 1 : 2; }
            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);
            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;
            if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }
            if (oppDir && REVERT_U > 0) {
                uint256 pre = slots[11];
                if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);
                else pHat = pHat - wmul(pHat - pre, REVERT_U);
            }
            if (firstInStep) {
                if (ret > RET_CAP) ret = RET_CAP;
                sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);
            }
        }

        // Interior retail routing equalizes fee-adjusted marginal prices.
        // Subsequent trades in a step cannot be the initial arbitrage trade.
        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {
            uint256 normalSpot = trade.isBuy
                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)
                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);
            pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);
        }

        // For a large print, remove its own impact before nudging the price estimate.
        {
            uint256 printRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;
            if (printRatio >= PRESPOT_MIN_RATIO) {
                uint256 preX;
                uint256 preY;
                if (trade.isBuy) {
                    uint256 netX = wmul(trade.amountX, gamma);
                    if (trade.reserveX > netX) {
                        preX = trade.reserveX - netX;
                        preY = trade.reserveY + trade.amountY;
                    }
                } else {
                    uint256 netY = wmul(trade.amountY, gamma);
                    if (trade.reserveY > netY) {
                        preX = trade.reserveX + trade.amountX;
                        preY = trade.reserveY - netY;
                    }
                }
                if (preX > 0 && preY > 0) {
                    uint256 preSpot = wdiv(preY, preX);
                    pHat = wmul(pHat, WAD - PRESPOT_ALPHA) + wmul(preSpot, PRESPOT_ALPHA);
                }
            }
        }

        uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;
        if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;

        if (tradeRatio > SIGNAL_THRESHOLD) {
            uint256 push = tradeRatio * DIR_IMPACT_MULT;
            if (push > WAD / 4) push = WAD / 4;
            if (trade.isBuy) {
                dirState = dirState + push;
                if (dirState > 2 * WAD) dirState = 2 * WAD;
            } else {
                dirState = dirState > push ? dirState - push : 0;
            }
            actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);
            sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);
            if (sizeHat > WAD) sizeHat = WAD;
        }

        uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;
        if (tox > TOX_CAP) tox = TOX_CAP;
        toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);
        uint256 toxSignal = toxEma;

        stepTradeCount = stepTradeCount + 1;
        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;

        uint256 flowSize = wmul(lambdaHat, sizeHat);
        uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);
        uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);
        fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));

        uint256 dirDev; bool sellPressure;
        if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }
        else { dirDev = WAD - dirState; sellPressure = false; }

        uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));
        uint256 bidFee; uint256 askFee;
        if (sellPressure) {
            bidFee = fMid + skew;
            askFee = fMid > skew ? fMid - skew : 0;
        } else {
            askFee = fMid + skew;
            bidFee = fMid > skew ? fMid - skew : 0;
        }

        {
            uint256 staleShift = wmul(STALE_DIR_COEF, toxSignal);
            uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);
            if (spot >= pHat) {
                bidFee = bidFee + staleShift;
                askFee = askFee > attractShift ? askFee - attractShift : 0;
            } else {
                askFee = askFee + staleShift;
                bidFee = bidFee > attractShift ? bidFee - attractShift : 0;
            }
        }

        {
            bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);
            if (tradeAligned) {
                uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);
                if (trade.isBuy) { bidFee = bidFee + tradeBoost; }
                else { askFee = askFee + tradeBoost; }
            }
        }

        if (sellPressure) {
            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));
            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));
        } else {
            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));
            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));
        }

        slots[0] = bidFee; slots[1] = askFee; slots[2] = trade.timestamp;
        slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;
        slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;
        slots[9] = toxEma; slots[10] = stepTradeCount;

        return (bidFee, askFee);
    }

    function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) {
        if (fee <= TAIL_KNEE) return fee;
        return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope);
    }

    function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) {
        result = WAD;
        while (exp > 0) {
            if (exp & 1 == 1) result = wmul(result, factor);
            factor = wmul(factor, factor);
            exp >>= 1;
        }
    }

    function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) {
        uint256 mul = _powWad(decayFactor, elapsed);
        if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); }
        uint256 below = wmul(WAD - centered, mul);
        return below < WAD ? WAD - below : 0;
    }

    function getName() external pure override returns (string memory) { return "no_cubic"; }
}
```

## sha256

`3ce21d811b5440456116b7d848e36c7938863ababf10dd028d710ed35c633e3d` (UTF-8 code text inside the Solidity fence, including its final newline).

## tuning

The pinned simulator's [TradeInfo](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/IAMMStrategy.sol) reports post-trade reserves; its [CFMM](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/amm/cfmm.rs) shows the fee-adjusted reserve changes used above. Configs follow [MatchRunner](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/match.py), [baseline variance](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/config.py), and the [simulation order and seeds](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/simulation/engine.rs). Every point is a paired difference in submission edge from separate candidate-versus-Vanilla and NP2-versus-Vanilla `run_batch` calls (16 seeds per call, 8 workers; SE uses ddof=1). The [CH reference](https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol) reproduced 525.5258821780834 on seeds 0–999; NP2 reproduced 526.1155722459862. Raw pre-spot rows add a pHat blend; target-correction rows interpolate its existing pImplied target; fee-adjusted rows use the pre-trade marginal price. A positive Δ favors the candidate.

| Family | Constants / gate | Seeds | n | Mean Δ | SE |
|---|---|---:|---:|---:|---:|
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0 | 10000–10255 | 256 | -1.60971529 | 0.05812701 |
| raw pre-spot | retail=0.005, first=0.0, ratio=0.02, centre=1.0 | 10000–10255 | 256 | -0.07317435 | 0.01243527 |
| raw pre-spot | retail=0.01, first=0.0, ratio=0.02, centre=0.5 | 10000–10255 | 256 | -0.20810145 | 0.01937286 |
| raw pre-spot | retail=0.0, first=0.005, ratio=0.02, centre=1.0 | 10000–10255 | 256 | -0.00109157 | 0.00075479 |
| raw pre-spot | retail=0.0, first=0.02, ratio=0.02, centre=0.5 | 10000–10255 | 256 | -0.00288078 | 0.00945049 |
| raw pre-spot | retail=0.002, first=0.005, ratio=0.02, centre=0.5 | 10000–10255 | 256 | -0.03583567 | 0.00837187 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=second | 10000–10255 | 256 | -0.29303682 | 0.02422992 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=outside | 10000–10255 | 256 | -0.43877687 | 0.03038465 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=inside | 10000–10255 | 256 | -0.03214812 | 0.00723765 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=small | 10000–10255 | 256 | -0.43426845 | 0.03041678 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=both | 10000–10255 | 256 | -0.26921725 | 0.02436700 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=second_opp | 10000–10255 | 256 | -0.13106711 | 0.01485030 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0, gate=second_opp | 10000–10255 | 256 | -0.46091973 | 0.02562502 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=second_same | 10000–10255 | 256 | -0.14526145 | 0.01938357 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0, gate=second_same | 10000–10255 | 256 | -0.56120242 | 0.03397255 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=confirm | 10000–10255 | 256 | -0.35747725 | 0.02014660 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0, gate=confirm | 10000–10255 | 256 | -1.06365536 | 0.04013862 |
| raw pre-spot | retail=0.02, first=0.0, ratio=0.02, centre=1.0, gate=counter | 10000–10255 | 256 | -0.07309474 | 0.02168194 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0, gate=counter | 10000–10255 | 256 | -0.41790012 | 0.03716181 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.005, centre=1.0, gate=large | 10000–10255 | 256 | -0.03196542 | 0.01666278 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.01, centre=1.0, gate=large | 10000–10255 | 256 | +0.01473498 | 0.01060851 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.02, centre=1.0, gate=blocked | 10000–10255 | 256 | -0.02296102 | 0.01196805 |
| raw pre-spot | retail=0.1, first=0.0, ratio=0.02, centre=1.0, gate=blocked | 10000–10255 | 256 | -0.11189139 | 0.01830960 |
| raw pre-spot | retail=0.0, first=0.05, ratio=0.005, centre=1.0 | 10000–10255 | 256 | -0.13906802 | 0.03055846 |
| raw pre-spot | retail=0.0, first=0.05, ratio=0.01, centre=1.0 | 10000–10255 | 256 | +0.02018909 | 0.00961862 |
| raw pre-spot | retail=0.0, first=0.1, ratio=0.005, centre=0.5 | 10000–10255 | 256 | -0.83181236 | 0.06415023 |
| raw pre-spot | retail=0.1, first=0.0, ratio=0.01, centre=1.0, gate=large | 10000–10255 | 256 | +0.00058481 | 0.01464178 |
| raw pre-spot | retail=0.2, first=0.0, ratio=0.01, centre=1.0, gate=large | 10000–10255 | 256 | -0.06261184 | 0.02028620 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.008, centre=1.0, gate=large | 10000–10255 | 256 | +0.00912950 | 0.01157997 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.015, centre=1.0, gate=large | 10000–10255 | 256 | +0.01670914 | 0.00893000 |
| raw pre-spot | retail=0.1, first=0.0, ratio=0.015, centre=1.0, gate=large | 10000–10255 | 256 | +0.01957026 | 0.01201337 |
| raw pre-spot | retail=0.05, first=0.0, ratio=0.01, centre=1.0, gate=large | 10256–10767 | 512 | -0.01002864 | 0.00594699 |
| raw pre-spot | retail=0.05, first=0.05, ratio=0.01, centre=1.0, gate=large | 10000–10255 | 256 | +0.03456119 | 0.01296203 |
| target correction | retail=0.25, first=0.0, ratio=0.02, centre=1.0, gate=all | 10000–10255 | 256 | -0.31795894 | 0.03206250 |
| target correction | retail=0.5, first=0.0, ratio=0.02, centre=0.5, gate=all | 10000–10255 | 256 | -0.86861762 | 0.04642707 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=1.0, gate=all | 10000–10255 | 256 | -3.38916344 | 0.09100731 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=0.5, gate=all, band=spot | 10000–10255 | 256 | -2.82196070 | 0.08471090 |
| target correction | retail=0.5, first=0.0, ratio=0.02, centre=1.0, gate=all, band=spot | 10000–10255 | 256 | -1.03019865 | 0.05422293 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=0.5, gate=all, band=implied | 10000–10255 | 256 | -1.03019865 | 0.05422293 |
| target correction | retail=0.5, first=0.0, ratio=0.02, centre=0.5, gate=all, band=implied | 10000–10255 | 256 | -0.31795894 | 0.03206250 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=0.25, gate=all, band=implied | 10000–10255 | 256 | -0.31795894 | 0.03206250 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=0.75, gate=all, band=implied | 10000–10255 | 256 | -2.03513162 | 0.06970279 |
| target correction | retail=0.25, first=0.0, ratio=0.02, centre=0.5, gate=all, band=implied | 10000–10255 | 256 | -0.11809820 | 0.02035525 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=1.0, gate=all, band=prefee | 10000–10255 | 256 | -0.35477707 | 0.04298084 |
| target correction | retail=0.5, first=0.0, ratio=0.02, centre=1.0, gate=all, band=prefee | 10000–10255 | 256 | -0.08468778 | 0.02378390 |
| target correction | retail=0.25, first=0.0, ratio=0.02, centre=1.0, gate=all, band=prefee | 10000–10255 | 256 | -0.01106932 | 0.01739644 |
| target correction | retail=1.0, first=0.0, ratio=0.02, centre=0.5, gate=all, band=prefee | 10000–10255 | 256 | -0.08468778 | 0.02378390 |
| target correction | retail=0.5, first=0.0, ratio=0.02, centre=0.5, gate=all, band=prefee | 10000–10255 | 256 | -0.01106932 | 0.01739644 |
| fee-adjusted pre-spot | retail=0.005, first=0, ratio=0.02, gate=all | 10000–10255 | 256 | -0.03838805 | 0.00897044 |
| fee-adjusted pre-spot | retail=0.02, first=0, ratio=0.02, gate=all | 10000–10255 | 256 | -0.21930451 | 0.01685478 |
| fee-adjusted pre-spot | retail=0.05, first=0, ratio=0.02, gate=all | 10000–10255 | 256 | -0.70355513 | 0.03159050 |
| fee-adjusted pre-spot | retail=0.05, first=0, ratio=0.02, gate=second | 10000–10255 | 256 | -0.38947903 | 0.02471240 |
| fee-adjusted pre-spot | retail=0.05, first=0, ratio=0.02, gate=inside | 10000–10255 | 256 | +0.00574632 | 0.00590743 |
| fee-adjusted pre-spot | retail=0.05, first=0.0, ratio=0.01, gate=large | 10000–10255 | 256 | -0.00601268 | 0.00455788 |
| fee-adjusted pre-spot | retail=0.1, first=0.0, ratio=0.01, gate=large | 10000–10255 | 256 | -0.01441711 | 0.00859801 |
| fee-adjusted pre-spot | retail=0.2, first=0.0, ratio=0.01, gate=large | 10000–10255 | 256 | -0.05293231 | 0.01086733 |
| selected clean | first=0.05, retail=0.05, ratio=0.01, raw pre-spot | 10000–10255 | 256 | +0.03456119 | 0.01296203 |
| selected clean | first=0.05, retail=0.05, ratio=0.01, raw pre-spot | 10256–10767 | 512 | +0.01851666 | 0.01060539 |

For the selected code, the two disjoint tuning blocks combine to n=768, mean Δ=+0.02386484 and SE=0.00828554.

## paired

Frozen code on the fresh confirmation block 2590000–2591999:

```json
{
  "n": 2000,
  "mean_diff": 0.02476925897607873,
  "se": 0.014470095602418815,
  "worst": -5.140715602119258
}
```

The estimate is positive but only 1.71 SE above zero, so this confirmation does not establish a reliable gain.

## blocked

`null`

## next

Test the same pre-spot gate only on large first prints; the 512-seed tuning block suggests later large-print corrections may dilute the gain. This is an inference from the tuning rows, not a confirmed variant.