# qt1: Taylor's qm tables (qm-spline compression) in trim-2's contract

**Summary.** I replaced trim-2's network with the qm-spline lookup and kept trim-2's filter, 3-slot state and fee conversion. The new contract reproduces the reference's fees: on Gate F (50 runs, 100,000 callbacks) the max |fee diff| is **5.83e-06 bps**. Its deployed runtime is **20,605 bytes** and its pyrevm peak is **194,051 gas**, so both targets are met.

On the real engine (seeds 9535000..9535127, n = 128) it scores:
- **+2.159991618 (SE 0.110379644)** against t03;
- **+0.818639700 (SE 0.054576749)** against trim-2.

Its afterSwap peak on the engine is **208,775 gas**, with **0 OutOfGas** in 1,402,238 calls.

Every figure here is a local measurement on this machine. None of it is independently certified.

Credit:
- The policy, filter, replica and qm tables are by Taylor (gtmcknight): [amm-sim research/solved @4812a638](https://github.com/gtmcknight/amm-sim/tree/4812a6382311624e1506aca131ca35c378f930d9/research/solved).
- The table compression is qm-spline's ([artifact](https://api.imd.fun/artifacts/17d249ab0c33fc44931d9b105cf3f9e3846a560bd518b67310c2a56defacdecc)).
- The filter, math, 3-slot state and fee conversion come from trim-2 ([artifact](https://api.imd.fun/artifacts/22560aac69c88188ffee4c1dfa7c58685ae83fd4b415fef626ed7258a12e7542)), which builds on port-3 ([artifact](https://api.imd.fun/artifacts/0dbcc10af41b3c3467ff0d9b9cb64c81328fcf18295f9be06b2d81bb98874067)).

## Setup and Gate P

| Step | Result |
|---|---|
| Platform | Linux x86_64 |
| amm-challenge cloned at 6b6921f8d463314aa7c96234e1be25a25245f704 under the workspace's `test/scratch/ac` | passed |
| port-3's setup script (the one in the brief) saved as `scratch/setup.sh`, run once with `sh scratch/setup.sh` | exit 0. Wheel sha256 matched. `Strategy 'StarterStrategy' validated successfully!` |
| Taylor amm-sim at 4812a6382311624e1506aca131ca35c378f930d9, `research/solved` (sparse checkout) | passed |
| **Gate P:** unmodified `python3 -I gates.py`, plain Python 3.12.3 | **pass**: gaussian+qm is 443.522608 / 571.623551 / 525.865859 on seeds 10000 / 10001 / 10002. Every digit of all four columns matches the README's table, including lattice+qm 443.663520 / 571.977293 / 526.411631, perfect-info 448.261189 / 576.779199 / 531.886497 and gaussian+plain 443.455598 / 571.463409 / 525.168028 |
| trim-2's Strategy.sol extracted from its artifact | sha256 `6157028022f7f2151781ea3a772e4a99956ab9c38c8fbabf4995887d05564b27`, 11,680 deployed bytes (matches) |
| QMS1 blob decoded from qm-spline's base64 | 10,167 bytes, sha256 `3ac7cb8811ecfb6a17f499aa4e9b70dd55f7fb6432b3aec3b904e11a3dece38e` (matches) |
| t03 = zlib(base64(`code_zb64`)) | sha256 `cb6d945511e1e10af78baa64c2a6cb25806f0998403ce6440654bfc3c70092d9` (matches cb6d9455…) |

## Reference (the Python below, `qmref.py`)

The reference combines two parts, using only the standard library:
- **Filter:** trim-2's filter, which is port-3's `standalone.Coarse` code verbatim. To this I added real.py's `synced` flag: it is reset at each new step and set when an own retail fill moves the rival estimate.
- **Fee rule:** real.py's `RealPolicy.lookup` (qm variant). It reads the sd level from `sqrt(v)*1e4`, the posterior sd after the update, exactly as real.py passes it. It uses tag `0c` in phase 0 and phase + `s`/`c` otherwise. It interpolates bilinearly at levels k and k+1, then linearly in sd. The column axis is `_pos2` over pol_mid's `W2L`.

The decoded tables come from a pure-Python port of qm-spline's decoder: Cox–de Boor at the grid nodes, clamp at 0, A = w + F rounded to 6 decimals, B = point mirror. They are **identical (max |diff| = 0) to qm-spline's numpy decoder JSON** over all 10 tables.

The init fee follows real.py: `init()` uses the *plain* `pol_mid` table at (0,0,0), which is 0.002823606104386589 each, not a qm table. The contract returns 2823606104386589 WAD.

**Check values reproduced:** the reference gives 443.101741 / 571.454483 / 525.908441 on seeds 10000..10002, every printed digit equal to qm-spline's values.

**Gate Q** is qm-spline's: paired loss 0.0632 (se 0.0072, n = 2048) against the full qm tables. I did not re-run it, because the reference is exactly real.py over those decoded tables, as the identical tables and check values above show.

## Contract design (generated by `gen.py` from the blob and trim-2's source)

- The following are trim-2's source byte for byte: `ln`, `exp`, `root`, `pdf`, `cdf`, `trunc`, `update` and `afterInitialize` (apart from the init constant). The storage packing in `afterSwap` is also trim-2's.
- The synced flag is stored in bit 255 of slot 2, and `cnt` is read as `s2>>192 & 0xffffffff`.
- The net is replaced by the qm-spline lookup:
  - **Coefficients:** 4,896 int16 values, stored as `c + 32768` in 16 lanes per 32-byte word. That makes 306 words of PUSH32 immediates, returned by 20 small binary-tree functions (`cw0..cw19`) under one dispatcher `cw`.
  - **Basis values:** computed at runtime by Cox–de Boor (6 divisions per node). The knot vectors are packed as 16-bit lanes (2 words per axis per table). There are no basis tables.
  - **sd axis:** a single cubic with no interior knots, so it is a Bernstein basis. I use the exact integer weights C(3,s)·l^s·(7−l)^(3−s), which sum to 343.
  - **Lookup rule** (qm-spline's): compute F at the 4 grid nodes × 2 sd levels, clamp each at 0, interpolate bilinearly, then linearly in sd.
  - **Ask side:** fee input = F(pw,p2) + (w_q − w). Here w_q is the clamped row's offset, so the input is a − w as real.py computes it.
  - **Bid side:** F is taken at the mirror point (320 − pw, last − p2), and the fee input is F + (w − w_q).
  - **Fee conversion:** trim-2's (`U − exp(−x/10000)` if x > 0, clipped to [0, 10%]).
- **Contract rules:** no assembly; `contract Strategy is AMMStrategyBase`; Taylor (gtmcknight) credited in the header. `amm-match validate`: `Strategy 'TaylorGaussianQMSpline' validated successfully!`
- **Compile issue fixed:** a single 306-leaf nested `if` tree made solc 0.8.24 (viaIR) segfault at the default 8 MB stack. It compiled only with an unlimited stack. Splitting the tree into 20 sub-functions fixed it, and the shipped source compiles at the default stack.
- **Gas fix:** the first working version accumulated into dynamic memory arrays. It cost about 72–100k gas per surface (pyrevm peak 288,854). The shipped version contracts each coefficient stripe straight into stack and fixed-index memory accumulators, at about 34–43k per surface.

## Size

Deployed runtime is **20,605 bytes**, under both the 24,000-byte target and the 24,576 cap. The compiler is the challenge's: solc 0.8.24, optimizer 200 runs, viaIR, Paris. The source is 42,990 bytes, sha256 **`c68887cff61180e12ba2b1ceb333edf76a830f91f63b5d775a8806fb9ec08aca`**.

## Gate F

Setup:
- Replica seeds 70000..70049.
- Each run drives Taylor's `replica2.run` with the reference and records the first 2,000 own-pool callbacks.
- The callbacks are replayed in order on a fresh pyrevm deployment, as port-3's `check.py` does: amounts and reserves as int(float·1e18), init at 100 / 10,000, **gas = 245,000 per call**.

All 100,050 calls succeeded.

- n = 50 runs, 100,000 callbacks, 200,000 fee comparisons.
- **max |fee diff| 5.826e-06 bps**, mean 1.689e-07 bps, init diff 0. The target is ≤ 0.01 bps: **pass**.
- **pyrevm peak 194,051** (seed 70032), **mean 124,776.9**. Per-run peaks range from 157,420 to 194,051. The target is ≤ 200,000: met.
- The sha256 of the concatenated per-run trace hashes is `66c1d374a625da5ece27dbe777beff17320fa124ff195d8da2dbf8fa46a5a7dc`.

## Engine (real engine, each strategy alone vs the 30 bps VanillaStrategy)

Method:
- `amm_sim_rs.run_batch(X, VanillaStrategy, configs, 8)`, with configs per `MatchRunner._build_configs` for seed i (port-3's transcription in `engine.py`).
- Seeds **9535000..9535127** only, in 4 chunks of 32.
- `gas_stats_reset()` before and `gas_stats()` after each chunk.
- Each seed was run once per strategy: candidate, then t03, then trim-2. Nothing was re-run.

Mean submission edge: candidate 533.054377388, t03 530.894385770, trim-2 532.235737688.

| Pair | n | mean_diff | se | worst5 (seed, diff) | ahead |
|---|---:|---:|---:|---|---:|
| candidate − t03 | 128 | **+2.159991618** | 0.110379644 | (9535096, −0.878549878), (9535060, −0.290820903), (9535073, −0.159565111), (9535100, +0.003834528), (9535078, +0.238640550) | 125/128 |
| candidate − trim-2 | 128 | **+0.818639700** | 0.054576749 | (9535096, −0.683208388), (9535125, −0.499936775), (9535054, −0.365720343), (9535055, −0.289423148), (9535052, −0.201705272) | 117/128 |
| trim-2 − t03 (for reference) | 128 | +1.341351918 | 0.117145832 | (9535060, −1.637289022), (9535064, −1.477667845), (9535016, −1.330706926), (9535057, −0.885600959), (9535100, −0.776676298) | 111/128 |

SE is the sample SD of the paired differences divided by √n.

### gas_stats (Submission role)

Sums are over the 4 chunks. Peak is the max over chunks. Mean = sum_ok_gas / ok.

| Strategy | Callback | Calls | OutOfGas | Peak | Mean |
|---|---|---:|---:|---:|---:|
| candidate | afterSwap | 1,402,238 | 0 | **208,775** | 137,940.08 |
| candidate | afterInitialize | 128 | 0 | 90,858 | 90,858.00 |
| t03 | afterSwap | 1,391,456 | 0 | 235,394 | 135,537.53 |
| t03 | afterInitialize | 128 | 0 | 243,234 | 243,234.00 |
| trim-2 | afterSwap | 1,390,179 | 0 | 130,574 | 71,232.83 |
| trim-2 | afterInitialize | 128 | 0 | 90,800 | 90,800.00 |

- revert, other_halt, tx_error and bad_return were 0 in every row.
- Candidate afterSwap peaks per chunk: 201,777, 206,279, 208,161, 208,775.
- The engine peak minus the pyrevm peak is 14,724, consistent with trim-2's ~15,000. That leaves 36,225 gas of margin under the 245,000 limit.
- Wall time per 32-seed chunk: candidate about 51 s, t03 about 30 s, trim-2 about 15 s.

## Notes and limits

- **Engine headroom:** the contract costs about twice trim-2's gas, because each callback evaluates two spline surfaces at about 35–43k each. More headroom would come from two cheaper steps: binary search for knot spans (about 2.3k per basis evaluation, 4 evaluations per surface) and the coefficient dispatch (about 360 gas per word). I did neither, because both targets were already met.
- **Fee error:** spline values carry fixed-point rounding (WAD bases, integer divisions in Cox–de Boor). Against the Python decoder at 40 test points (20 grid nodes and 20 random interior points with random sd fraction, across the 5 tables), the max |diff| of the surface is 1.9e-11 bps. Gate F measures the combined error at 5.8e-6 bps.
- **Scope of the engine figures:** only seeds 9535000..9535127 were used on the engine, once per strategy. Replica results do not convert to board scores.
- **Not included here because of the 64 KB limit:** the generator `gen.py`, the Gate F harness (`check.py`, port-3's `check.py` with the reference swapped in and traces cached), the engine harness (port-3's `engine.py` with the seed range changed) and the unit-test scaffolding. The contract and reference below are complete.

## Strategy.sol (complete; sha256 c68887cff61180e12ba2b1ceb333edf76a830f91f63b5d775a8806fb9ec08aca, 42,990 bytes)

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {AMMStrategyBase} from "./AMMStrategyBase.sol";
import {TradeInfo} from "./IAMMStrategy.sol";
// Solved AMM policy by Taylor (gtmcknight), amm-sim 4812a638 research/solved: Gaussian filter + qm tables (qm_k1e-5.json),
// fee rule of real.py's qm variant (sd level, phase, synced flag). All credit for the policy, filter and tables: Taylor.
// Tables compressed by qm-spline (cubic B-splines, QMS1 blob sha256 3ac7cb88...); filter, 3-slot state, math and fee conversion
// from trim-2 (port-3's filter); synced flag stored in bit 255 of slot 2.
// Taylor source: https://github.com/gtmcknight/amm-sim/tree/4812a6382311624e1506aca131ca35c378f930d9/research/solved
contract Strategy is AMMStrategyBase {
    int256 constant U=1e18;
    int256 constant LN2=693147180559945309;
    uint256 constant M64=0xffffffffffffffff;
    // slots[0] = m (int128) | v (int128)<<128 ; slots[1] = sp (int128) | r (int128)<<128 ; slots[2] = fb | fa<<64 | t<<128 | cnt<<192
    function getName() external pure override returns(string memory) { unchecked {return "TaylorGaussianQMSpline";} }
    function mul(int256 a,int256 b) internal pure returns(int256){ unchecked {return a*b/U;} }
    function divi(int256 a,int256 b) internal pure returns(int256){ unchecked {return a*U/b;} }
    function ab(int256 x) internal pure returns(int256){ unchecked {return x<0?-x:x;} }
    function clip(int256 x,int256 a,int256 b) internal pure returns(int256){ unchecked {return x<a?a:(x>b?b:x);} }
    function ln(int256 x) internal pure returns(int256 z){ unchecked {
        require(x>0); int256 k;
        while(x< U){x*=2;k--;}
        while(x>=2*U){x/=2;k++;}
        int256 y=divi(x-U,x+U); int256 y2=mul(y,y); int256 q=y; z=y;
        for(int256 n=3;n<=29;n+=2){q=mul(q,y2);z+=q/n;}
        return 2*z+k*LN2;
    } }
    function exp(int256 x) internal pure returns(int256){ unchecked {
        if(x< -42*U)return 0; require(x<60*U);
        int256 k=(x>=0?x+LN2/2:x-LN2/2)/LN2; int256 r=x-k*LN2;
        int256 r2=mul(r,r);
        int256 even=665280*U+mul(r2,75600*U+mul(r2,840*U+r2));
        int256 odd=mul(r,332640*U+mul(r2,10080*U+mul(r2,42*U)));
        int256 s=divi(even+odd,even-odd);
        return k>=0?s*int256(uint256(1)<<uint256(k)):s/int256(uint256(1)<<uint256(-k));
    } }
    function root(int256 x) internal pure returns(int256){ unchecked {
        if(x<=0)return 0; uint256 n=uint256(x)*1e18;uint256 z=n;uint256 r=1;
        if(z>>128>0){z>>=128;r<<=64;} if(z>>64>0){z>>=64;r<<=32;}
        if(z>>32>0){z>>=32;r<<=16;} if(z>>16>0){z>>=16;r<<=8;}
        if(z>>8>0){z>>=8;r<<=4;} if(z>>4>0){z>>=4;r<<=2;} if(z>>2>0){r<<=1;}
        for(uint256 i=0;i<7;i++)r=(r+n/r)/2;
        return int256(r<n/r?r:n/r);
    } }
    function pdf(int256 x) internal pure returns(int256){ unchecked {if(ab(x)>10*U)return 0;return divi(exp(-mul(x,x)/2),2506628274631000200);} }
    // Hart rational normal tail approximation; erf(x)=2*Phi(x*sqrt(2))-1.
    function cdf(int256 x,int256 density) internal pure returns(int256){ unchecked {
        int256 y=ab(x);if(y>8*U)return x>0?U:int256(0);
        int256 n=35262496599891000;
        n=mul(n,y)+700383064443688000;n=mul(n,y)+6373962203531650000;
        n=mul(n,y)+33912866078383000000;n=mul(n,y)+112079291497871000000;
        n=mul(n,y)+221213596169931000000;n=mul(n,y)+220206867912376000000;
        int256 d=88388347648318400;
        d=mul(d,y)+1755667163182640000;d=mul(d,y)+16064177579207000000;
        d=mul(d,y)+86780732202946100000;d=mul(d,y)+296564248779674000000;
        d=mul(d,y)+637333633378831000000;d=mul(d,y)+793826512519948000000;
        d=mul(d,y)+440413735824752000000;
        int256 tail=mul(mul(density,2506628274631000200),divi(n,d));return x>0?U-tail:tail;
    } }
    function trunc(int256 m,int256 v,int256 lo,int256 hi) internal pure returns(int256 Z,int256 mt,int256 vt){ unchecked {
        if(v<=0)return (lo<=m&&m<=hi?U:int256(0),m,0);
        int256 sd=root(v);int256 a=divi(lo-m,sd);int256 b=divi(hi-m,sd);
        int256 pa=pdf(a);int256 pb=pdf(b);
        Z=cdf(b,pb)-cdf(a,pa);
        if(Z<1e6)return(Z,m<lo?lo:hi,v/4);
        int256 r=divi(pa-pb,Z);
        mt=m+mul(sd,r);vt=mul(v,U+divi(mul(a,pa)-mul(b,pb),Z)-mul(r,r));if(vt<0)vt=0;
    } }
    // ---- qm-spline lookup (QMS1 blob sha256 3ac7cb88..., 10,167 B): 5 cubic tensor B-splines over (row, column, sd level),
    // ask side only; bid = point mirror. Coefficients int16 (1/8 bps) as PUSH32 immediates, 16 lanes of (c+32768) per word.
    function cw0(uint256 i) internal pure returns(uint256){ unchecked { if(i<8){if(i<4){if(i<2){if(i<1){return 0x946594cb947894aa80009489986280009852988098639846984798398000983e;}return 0x800087468e9780008e0e8f578ec98e158e788e1f80008e5094a4800094f3941c;}if(i<3){return 0x85468606840d83bd83d783a0800083ba873d800087b1869b872f878f8732876a;}return 0x81d58254800082018339800083ee82eb852d826f82a5826f8000828185cd8000;}if(i<6){if(i<5){return 0x81d9800080ac835583a5821481f381b5800081cc859b800086c7835882588326;}return 0x830881b581c4817880008197835d800083aa82f881cc8294819581ea800081b2;}if(i<7){return 0x800080fa81bc8000817382a281c282008133817680008162831380008331826f;}return 0x80c480e780e27fab817e7e178000816b81ed80008297818281ed809481258205;}if(i<12){if(i<10){if(i<9){return 0x7fd67f03800081ea80848000808a80737fcf801e802d812580007d4180f88000;}return 0x80008000800c7fee80147ff4800a800e80007db2801f800080207ff97fdf7faf;}if(i<11){return 0x80027ffe80017ffb80007fc27ffd80007ffe80037ffd7ffb80087fc38000804d;}return 0x800080007fff8000800080007fff800080008000800080018001800080027ffe;}if(i<14){if(i<13){return 0x8000800080008000800080008000800080008000800080008000800080008000;}return 0x8000800080008000800080008000800080008000800080008000800080008000;}if(i<15){return 0x80008000800080008000800080008000800080007fff80008000800080008000;}return 0x9158964b93b0958980009481985a800097db98ac994497aa987297c680009836; } }
    function cw1(uint256 i) internal pure returns(uint256){ unchecked { if(i<24){if(i<20){if(i<18){if(i<17){return 0x800087448f0480008e099021920b8c338f2d8cdf80008e45944a80009526936e;}return 0x853a862d84ca836983ec8379800083ba86b48000870a864e859a885c86d487e3;}if(i<19){return 0x823881db8000820f83ae8000841183208425830c827882a68000828785ba8000;}return 0x833a8000832382b382f4826c81c881ff800081da833f8000848e8390837c8250;}if(i<22){if(i<21){return 0x8269820c8171821b800081b683408000839f82ab833d81c681e88170800081c3;}return 0x800080f68373800083a5816b82a4812b81de806680008166820380008255831f;}if(i<23){return 0x8237803982247e96821c7ad78000802281a88000808d82aa806982257fad8369;}return 0x84e86ccb80008238807480007f56811a7ea682c87c0e8df780007fdf81148000;}if(i<28){if(i<26){if(i<25){return 0x7fd080007f0d80717f6a810c7d6b867280007eca800a800081257f6680c37e12;}return 0x7fe8801f7fda805f80007feb80148000805c7fce80477fa6807c7dc58000805a;}if(i<27){return 0x80007fff80048000800f7ff9800a7ff680097fe9800080027ff480007fcf8012;}return 0x80297ff7800c7ff580087ff2800080017ffe80007ff280057ff980077ffa800b;}if(i<30){if(i<29){return 0x80097ff1800080017fe680007f4f80167fea80127ff3801680007fff80078000;}return 0x7ffa80007fc480057ffa80047ffd80058000800080138000806e7fec80117ff3;}if(i<31){return 0x978192ff95819389800094ad987d800098f9984597c9991d981b98cf80009852;}return 0x8000875e8dbc80008ed68cf88be690c28d888ff080008e609595800094b69622; } }
    function cw2(uint256 i) internal pure returns(uint256){ unchecked { if(i<40){if(i<36){if(i<34){if(i<33){return 0x84cc83cb84d984d983e8844d800083fa88ee80008882892f8928863087fe8689;}return 0x825d829c8000824b83ee8000838e848882c38309833182a7800082ed84718000;}if(i<35){return 0x83018000839282f782a081e8824881a280008212831f8000822d82e9831e826f;}return 0x8287814a822e80a0800081c882868000823282c682258259818882b7800081cb;}if(i<38){if(i<37){return 0x8000810281ec80008267825e816982708098834f8000816882ed800082668276;}return 0x8044819c7f3481e67e7684e580007fc881d68000825580fa82de7ef682367dca;}if(i<39){return 0x76c794b480007bd9805c800081217faf81877c7e82a87673800080b880ff8000;}return 0x7fca800080cb7f2981837d5c8354792d8000817e804a80007ea581407c9b85d9;}if(i<44){if(i<42){if(i<41){return 0x80387fb0804f7f5e80008016801e80007fc680627f2381307e7b835180007f64;}return 0x8000800180168000802880067fe6801e7fe1803780007ffe7fc580007fca7fe5;}if(i<43){return 0x803d7ffe7fe5801b7fea802480007fff7fd280007faa7ffd800e7ff0800e7fe9;}return 0x7fee801d80007fff7f96800080097ff380257fda801a7fd580008001802c8000;}if(i<46){if(i<45){return 0x7fd3800080147ffb80087ff880057ff880008000803c80007fe7800c7fe58019;}return 0x943e94c5943a94808000944c98498000983298509854980c981397ef80009800;}if(i<47){return 0x8000874f8e9d80008e568ebd8eb28dde8e508dd680008e1e9472800094a29459;}return 0x847684db844d8428842a83fe80008412877c800087a48767877d87d2873b8783; } }
    function cw3(uint256 i) internal pure returns(uint256){ unchecked { if(i<56){if(i<52){if(i<50){if(i<49){return 0x826682328000826a8388800083a5832d83af832082c082f2800082c884928000;}return 0x82d28000828082e2828e828481fe82728000822e83058000833d831282c582b2;}if(i<51){return 0x8203824a819e82ac800081ec82ab80008307825782b681e88238818a8000822d;}return 0x8000814282468000826d81d982a08114823380ff800081d582798000826d82ac;}if(i<54){if(i<53){return 0x8140808f81347ff081217f94800080b981a18000815a81f180e381ae80f58233;}return 0x805d7e5580008010806380008012808e7f9680b27fd180ea8000800c80f58000;}if(i<55){return 0x7fe080007fe9800b7fe280437f9b80a280007fb2800d800080897fb480557f33;}return 0x800080067ff4801080007ffa800180007fdd7ffe80107fd7802e7f8a80008008;}if(i<60){if(i<58){if(i<57){return 0x800080007ffb80007fe180047ffe7fff80027ffd80007fff80058000801d7ffb;}return 0x7fda80047ffe80017fff8003800080008005800080187ffa80047ffc80027ffc;}if(i<59){return 0x80017fff800080008008800080177ffd800080017fff8001800080007ff88000;}return 0x8001800080017fff800080017fff8001800080007ff780007ff4800180017fff;}if(i<62){if(i<61){return 0x9435941b982b980997de98939875984e9862980f982c982c9822980a98069806;}return 0x8d3c8d6d8d328d5b94b095bf956593969243934593b494c99472942c9461941b;}if(i<63){return 0x863685ff862485df85ff85f08d028abb8c028f158fe78f148e308cdd8d448d91;}return 0x82da82498287829f82608281824582628798898a86b484be849e850f85b78683; } }
    function cw4(uint256 i) internal pure returns(uint256){ unchecked { if(i<72){if(i<68){if(i<66){if(i<65){return 0x83148331832a831981e681c581bb8193818381358477842a84ae84ca843c8398;}return 0x832d832b82c78279822b820e8238819881a5811d814380f1839283ec833d830c;}if(i<67){return 0x8314833f82b28295827682568242821281aa8184810381867fe081948342833d;}return 0x7ff6804482b482b68293826e823281f481d2819681ae813d80f980d880208112;}if(i<70){if(i<69){return 0x804880d37eb280d2829483198202823081e181c781918190812f80f680e18087;}return 0x8083813a80a17fca7fd87e3981b18247824781bd81b8816481588127810a810e;}if(i<71){return 0x80c680e2808580b481247dbb832a7b4b8a398235821e81a38161814180fc8106;}return 0x809280e68081801580c080b480d880ac7d148265873a868680ca81bd80e48120;}if(i<76){if(i<74){if(i<73){return 0x7fe5818e8070806f807d80588031804f8063807d7f957efd8446868d808081a9;}return 0x830785f3804b80e3806880527ff07fc7804b803e803d8042800b7ed7851d86e9;}if(i<75){return 0x7ffd7ff283be870e7f4280f780107fc67fee801f7fea7fe6802c7fd87fdf802a;}return 0x80057fff7ff7800380d184ff7ff080337fca80157ff77ff37ffc800c7fd78018;}if(i<78){if(i<77){return 0x7ff680067ff780087ff9800282f4858c7f5780107ff680027ff680077ff97fff;}return 0x80217ff0800c7ff880097ff680087ffc811282dc7ecd805e7fc880197fe5800a;}if(i<79){return 0x7fa180327fcc80137fee80097ff2800c7ff780037c2680467d777f9a803e7fd7;}return 0x7b5b7fe780297fe780197ff680097ffb80087ff980057ffe810e81e183bb8070; } }
    function cw5(uint256 i) internal pure returns(uint256){ unchecked { if(i<88){if(i<84){if(i<82){if(i<81){return 0x7fe7809a806680117fed80077ff680037ffd80027ffc80037ffe800080087cd8;}return 0x93a1942e97c1982d97a597b6993f9a3199be97e69765985697bc97d697d997fb;}if(i<83){return 0x8c408c5a8dcd8d0395ad93bb955b94ed92b290138f0c9487961293c894e7949d;}return 0x872485a986f585e985e885c68a908df38be88c43912f932295678c608b3c8ddd;}if(i<86){if(i<85){return 0x84a081f8822c82a8822b82848218829388f486d2874e8603833e82e6819986ef;}return 0x82e482ca826e82f4825d81d581b781d381547fbc8499849b847e846284d4844b;}if(i<87){return 0x830682f882eb82ce8298824b81b181bf818b81e27fde82e7837983bd832b8378;}return 0x8276831182b682bf8273824b821681e581cd817b8147812880527fff83878390;}if(i<92){if(i<90){if(i<89){return 0x7f3d83be83e582e2827e82678237820681e881cb813d812d812f80ff800d7f85;}return 0x812d7f4b82336e7880df82a9826b81fd81f981b981b381328144812d80af80fd;}if(i<91){return 0x80de80797fb281fa7b4c8ba985c282e281ac8247817581ae8145813880e3806e;}return 0x80d480ba8054802480297f58825e77c185a881ad828d817481a9814e812080d2;}if(i<94){if(i<93){return 0x812a8106806d80bb7ff580537fc97e7384787f4583a08446818381b9814680fb;}return 0x81c080f980c88041808f802d7fe780fe7fe3820d7aeb811a8a8e856f81288136;}if(i<95){return 0x883182ff812580c7807480b47ff87fe3810a7f9081587d8584127f0a885e8163;}return 0x81367fb0893784577fce80e680127fa780297f787f8580767f49817e7dcb8080; } }
    function cw6(uint256 i) internal pure returns(uint256){ unchecked { if(i<104){if(i<100){if(i<98){if(i<97){return 0x7fe7803c7f9d80128d0181b8812880207fba807a7f89806c80127fc080657f2a;}return 0x7fb8800a7fec800d7fe87ffc940e82797fb37fb680657fa9803b7fd77ffa8012;}if(i<99){return 0x80787fc4801a800a800580097ffb800484df83167e7781467ece80ce7ec98062;}return 0x84457b85823a7e5f806d7f8580257fbf80247ff2819c7aa380ba7f9481077f6f;}if(i<102){if(i<101){return 0x5d65917877c384a97ca581727f6e80567fdc80307fe3800980a57e7297e56ddd;}return 0x80067fe1865e794a81697e2d80c47f6080287fd3800f7fea800c7ffc7fce81c8;}if(i<103){return 0x950f940e98bc987598b998c5979a9717976098c298f9983798969801986b9819;}return 0x8e618dfd8c918dcf94579587940f93fc95fd973a97ce939c92be947593939439;}if(i<108){if(i<106){if(i<105){return 0x853885ff85978598866185e18ed28cba8e7f8ee48ad68a4388658f818f8b8dcf;}return 0x828a84a683c48340826982de8252820f869b881c86018633885c8864894e84d3;}if(i<107){return 0x831782bb82b681c4823a822d81d8822080a5818e849b84e5845084538352835e;}return 0x834982fd828b8243822281dd81fb81c1819b81ac81eb7fcf83b583c183a48314;}if(i<110){if(i<109){return 0x834e834682ee82918258820381e181bc8193817a8181816580a98021837b835b;}return 0x80ca7e3482d1830e82b98279821f81f581c581618184812e810e8125811a7f38;}if(i<111){return 0x808481147fdf8479835c833b824c827e81dd81bd81508169810480c781228086;}return 0x805e807a80e57f4582c877aa834d825a82ef81f381e3815b814380eb80ef80d1; } }
    function cw7(uint256 i) internal pure returns(uint256){ unchecked { if(i<120){if(i<116){if(i<114){if(i<113){return 0x80c5806b808b8052805e80c37caf857a861184f7819a82158142813180da80e6;}return 0x80ec80838093802c800f80197f5781987ad980ee8722819d8233815f814f80ee;}if(i<115){return 0x80d8813280bb808d80217ffd80407ef27fd97bf188bb7cf28333807d81ee8147;}return 0x861e8167814d80c680727ffa80027fd87d99809c7dce84267822825d8775852a;}if(i<118){if(i<117){return 0x7da58091889f8119819a803a806b7fcc7ff6800281717f4a81147d5784717e6d;}return 0x801b7fae80897fd882c981457fff809d7fa17f8280a97fb97f3d805a7f6a8167;}if(i<119){return 0x7fdc800d7ff280277fcb800c837582f280987fb07fdb80b17f21804f80227ff0;}return 0x7d3b81217fae801a7fed7ffa80147ff97d0385cd7af4820a7e7a7fdb80687fe3;}if(i<124){if(i<122){if(i<121){return 0x86307dd082db7ef4804c7ffe800a80157fe2800a81df7dff7d82886c7b7282bd;}return 0x829f85647ca681397e3a80aa7fcc80037ff97ff580107ffb7c2e84e881b373e1;}if(i<123){return 0x7fa2809e809f7d2781547f9d80847fb6800e8001800080067ff9800281997b0a;}return 0x931a93499852985d981b9814982c982f984197c397d097cd97d8973996ed973b;}if(i<126){if(i<125){return 0x8d3e8c628c718c819481945a945d944f93f593df936594a9948d940494059357;}return 0x86e386448610855885f4858f8db08dfd8d6e8d668dec8dc08eae8c498cae8d00;}if(i<127){return 0x83a5828082a68310828f83468261829086e886ad86d086a68646864685a28746;}return 0x82c482b1827882c9825781fc82118256814b81698417842d838e837583948363; } }
    function cw8(uint256 i) internal pure returns(uint256){ unchecked { if(i<136){if(i<132){if(i<130){if(i<129){return 0x82c782af827e825c8240822b81f881d281ee81b1817d816583bc83c7831e8310;}return 0x838583a382bd82918242822a81fb81e981d881b381b181d780fa80c5838a83ae;}if(i<131){return 0x806a80668393838c829c824c820d81db81c581c5817e8176819f8116811380b3;}return 0x811e80ba802e800883a283af8282821181d581a181a38154815c8157813d8150;}if(i<134){if(i<133){return 0x80fc80e780e280cd8007802083d483fe821581d9817a8175813f814380fc8118;}return 0x80ce80cf808380de8051810f7f407f5883e5842581a381bc8155813c811880e2;}if(i<135){return 0x80e480ce8090807f808b808a80d57fdc80997f648468841881b88164811b80f6;}return 0x814380ed80ae8066806b8046804d8088802480d87de2807c847e83f281af8131;}if(i<140){if(i<138){if(i<137){return 0x83e582fb815280aa8062805a801f7ff580917fd180437f51815b7f60840e8311;}return 0x806b7fd0830e84448032809b80207fbe7f8a80117f58802e7fc580b47ecd8043;}if(i<139){return 0x7ffa80167fde80078301827e80c2802d7fbc80557fd9801d802d7ff280137f99;}return 0x80107ff780067fee800d7ffa829e83c07f7980007fd37fa6802e7fe07fe68006;}if(i<142){if(i<141){return 0x80b77f7b800d7ff5800380027ffc800281d581877ed380a87feb8006800c7ffb;}return 0x7e5581307f3280787ff180087ffc7ffd80047ffe7e367e2c822b7ba7813f7e94;}if(i<143){return 0x825c7d2f81227f22808a7fa4800c7ffa800380017ffe800180fd82107ceb83ff;}return 0x800f802d7f7d80747fab80217fd9800f7ffc80017fff7fff80017fff7f867e63; } }
    function cw9(uint256 i) internal pure returns(uint256){ unchecked { if(i<152){if(i<148){if(i<146){if(i<145){return 0x9327931a93289328985c97e198aa984e985d98439829982c9828981e98369826;}return 0x8cdc8c788be28bf28bfc8bee8c1b8bf492f293a5929c92cb929692e093449339;}if(i<147){return 0x841484f28390841883f1843b84a28487847a845b848184738c938b7a8d338c9c;}return 0x819980d582048148847c823385fe84068399828281c281ee81e281a9826481a8;}if(i<150){if(i<149){return 0x829f81277f8a81d580f081e68051816c81ed83e880c781f7812b84fa8438816c;}return 0x81d981c681e881c6810481908350803181687de183887ffb82bc81a6837b827a;}if(i<151){return 0x80af816e800d80e58187820981738139819681a77fc68135809c82467fdb815b;}return 0x810680567f93811e81257f56812d803d8134813a810b816f8066810980d7802d;}if(i<156){if(i<154){if(i<153){return 0x80aa809980ca80ba7fc4802f7fbc80b7816e7fa080738040812c800281fa8093;}return 0x7fff80067ff1800080797f0980de7fe380197fee802a7fc87f907f0480ce7faf;}if(i<155){return 0x80097ffa80067ffd80007fff800480007fc7804c7fad800a7ff180087ff38006;}return 0x7fdc805c7f97800d7fef800a7ff580057fff80017ffb7fff80187fca80357ff9;}if(i<158){if(i<157){return 0x80007fff8000800080167fbc80487ff6800c7ff880077ffc8001800080028000;}return 0x9b5b9816992798079813983f97cf980e7ff8800f7fed80027ffc80027ffd8001;}if(i<159){return 0x93bd8f1c976891918e6d8f5a8ec19410931d92d5933592f497c999b2963698d3;}return 0x848483f784c084518b1c91a685f38e178fad90478f228b988be28c9b8b198c01; } }
    function cw10(uint256 i) internal pure returns(uint256){ unchecked { if(i<168){if(i<164){if(i<162){if(i<161){return 0x841b843f82a581e881cf821b81458207848a815286f7835b82f982698374848c;}return 0x82bf8059843b829182f2805f80b881f481a0815c840b808b83eb86c5821e845a;}if(i<163){return 0x80cf80f681148107826183a48180825b81f8828582ef811c814980e6820280e0;}return 0x811a813a814880e2806081e67d3880ee820780d7831c81c68265815580738150;}if(i<166){if(i<165){return 0x813b8160823b80f781b2808580b1804e80297f2f838f7f76820780aa820681eb;}return 0x7eee84a77d85811680eb8148801f8109802280d080837fbe7fde7dd2812f7fe4;}if(i<167){return 0x7f3c80107fb07fed806a7e2281217f9880e77f8b81ae8063811c7fc4804e8010;}return 0x806b7e2b7f9f803980347fbd80357fec800580627fad80157f4082c07f6e801d;}if(i<172){if(i<170){if(i<169){return 0x802280577fac80177ff57fc581367fa17fe180507fc180087ff67f9280567fe5;}return 0x7e15818c7f09803b7fba7fee80237ff47ffe80687e79808a80c97ef980917fed;}if(i<171){return 0x7ff580327fea7f4c80597f9b801e800080177ffd7ffa80027ffe7fbf80b28013;}return 0x93f09359931b937898e996839b82963a949798279773985e980c980898b89852;}if(i<174){if(i<173){return 0x872487c489698c5f8b908af38d7b8bec927e986c8c56988799ad96c19764928a;}return 0x84d8871c82e5864186fa871685c084818491859d839c84be8d7c86ee93c18800;}if(i<175){return 0x81778216809881f8834c811884cd82b1827a81e882d182f182988095834a81c7;}return 0x8202818280cc8177812a81407fbc81c0826d835381f68260821582c8825a817a; } }
    function cw11(uint256 i) internal pure returns(uint256){ unchecked { if(i<184){if(i<180){if(i<178){if(i<177){return 0x81f3832a81438201816e8190816280e180ea81ca7ebf81be8275812983708213;}return 0x807b7f7f7ee5809a81e38127827c813c81a080db80db802d80c47f91842e7f76;}if(i<179){return 0x80e280167ff87fef800881427f5e7fd08144820a80ad816080a080d1803a8030;}return 0x80488215807c807c7fd280427f2e7f617fcd7deb7f1b7f4180fe80c0820a80b1;}if(i<182){if(i<181){return 0x7ff87fa680457fed803880ce806680747fcc7fc48037803b7fdc81547f5f8042;}return 0x7d8f802d7fe9804a800980677fb6801a80677d2c83317daf80df7ff580067fd4;}if(i<183){return 0x81a0764f8e0175c68444801c80337f177fd97fcb80317fef7e8d85fd77b783c2;}return 0x7fd4801c7ff380007ede86507688873d7cf77ecd80598090804c7fed7fff8005;}if(i<188){if(i<186){if(i<185){return 0x98a69855980797b097da979c97209763804a7d3e84117c3481777fbc80367f85;}return 0x9336920294ce913e919d91ac927a93a592f9928c9245927597e6985b974a98a7;}if(i<187){return 0x851083f1848b84658bb68d0589fc8dd18d848dad8c428aaf8b968b958ae48b3c;}return 0x82ea830d825681c68210821782fa825d850d84d9855684b28462841b84b485b4;}if(i<190){if(i<189){return 0x827f821d82c88248823d81e681c4820b81df81f381d181da82ba835b824382e9;}return 0x8154815181bc812e8216828181d7820d81e681dc8207816f81a981a7819d81ad;}if(i<191){return 0x811b815080e28141811180d880f78129821580d382f2819181b881678156813a;}return 0x81808047825380e5811080be80bd80c880a281b3800680ed816b8215811f8177; } }
    function cw12(uint256 i) internal pure returns(uint256){ unchecked { if(i<200){if(i<196){if(i<194){if(i<193){return 0x800380e77f92804e80d68165809380c1807b809580658087808d7f91815d8051;}return 0x7ff47ff680027fcd80137f5680697fd280d7802c81308062807f7ff18039805a;}if(i<195){return 0x7fa780a67ed080867f5080477fd1802a7ff780477fba800e808d7fe580f67fcf;}return 0x7fdd80697fac801380387edc81827f10810c7f6680547fb7800e7fa180487fe9;}if(i<198){if(i<197){return 0x817d7f5380717f8b80107fc180317ff37f9c81a17d83819b7db280fa7f45808b;}return 0x7fe480567f70804e7f5b802f7fd880177ffa800d7ff4800180397ed581d97e76;}if(i<199){return 0x94369426987097959967983e983e982897f7982b981f9821980d980f98039807;}return 0x8d5f8d798d668d6e93ee951a91de93c793a5942395159429943794309457941a;}if(i<204){if(i<202){if(i<201){return 0x862f863686448617862c862a8e118dd490008ed28e418da28c8c8d938d9d8d8b;}return 0x822f82c282cc82b5829782a6828a828b85b586088443856385cb865886e78640;}if(i<203){return 0x83d983b3830a81b181b681d281bc81b8818281768543851f851583908321828f;}return 0x831382d1828a8253827682e0819e819f8185816f80dc817e83028342835f83ce;}if(i<206){if(i<205){return 0x829c82d482ad82cd82b5827a822381ab81e98146810d8142804b812683828381;}return 0x7f5780c0829382ff82658256822381f581df81d3816d80ff80e580f3800780b3;}if(i<207){return 0x809a80297ff37f66825d8211823a822a820781cf81918159814280f8809b80e7;}return 0x80a981207fd481257d8180dc820e830f81c981d981a6817e8157813d80f9808c; } }
    function cw13(uint256 i) internal pure returns(uint256){ unchecked { if(i<216){if(i<212){if(i<210){if(i<209){return 0x80c780cf807480d080877e8682437e0c81be80e7827c81938186813c811280e7;}return 0x80f880d480a5802980b880ac80df809b7db18133892284b3811781c681188111;}if(i<211){return 0x8005817c80a2804e8072804380348054803c807380977ea38219866f80bd816e;}return 0x85ca860480468108807580717ffa7fd58066801e807e7fea7fee80a4837686f5;}if(i<214){if(i<213){return 0x80477ff1822f86f57f62812080307fbf7feb801b7fd080187fb6808d7ef77fcf;}return 0x7ff580137fe08003813785787ff580317fc8801080037ff7800b7ff980107fd2;}if(i<215){return 0x7ffc800180007ffc80067fff81fe86327f15801c7fea800c7fea800a7ff28006;}return 0x800a7ffe800180007fff80057ff98001805182797edd805c7fc980187fea8005;}if(i<220){if(i<218){if(i<217){return 0x80207fdf800c7fee80057ffc80047ff7800a7ffd7ed77f3f7eda7fea801c7fef;}return 0x7adc812c7fb9802b7fde80147ff680057ffc80087ff880028003812883d57ee4;}if(i<219){return 0x7ff3804e80ad7fa7800e7ff180067ffa80017ffe80017ffd80027fff80257e7a;}return 0x93e0942097ec99309686993f98f498db970a976f981b982897b4980697c997f5;}if(i<222){if(i<221){return 0x8c4b8d338d9f8d239444922c97239122921f9223964f95cc93f793b4950193f9;}return 0x860e8601869e863685ea862b8ddc8f808a9a92269103907689f88b068dbf8e02;}if(i<223){return 0x813681be82c582ba8278829c827582a185b683cc883881e4845a84838882879d;}return 0x839f82f5844f829981a481d481b781d9812b80fd854a867383a5859a83a78361; } }
    function cw14(uint256 i) internal pure returns(uint256){ unchecked { if(i<232){if(i<228){if(i<226){if(i<225){return 0x82c1832d82db82fd81d4825e820681a981a181c080918192835382df83b2832a;}return 0x82b7829f82bb82ab8276825b826b821381708179813981457f5381a483458435;}if(i<227){return 0x7f5281e282f4826f82a1824a826c820581d6819f81578137812b80eb80be7f38;}return 0x809f805980fe7b34821682b78207822681d381c981c9814c812480e580c280cc;}if(i<230){if(i<229){return 0x80f97fae80ce7f79804580e082928253822b81ea81d6818f8154812c80be80e0;}return 0x80de80c88017807f7eec82c07ad3829781cd818981c1823281528187811e80c7;}if(i<231){return 0x81038112807a80a38009800c80347aff8aaa79a188198537813a8175818080fb;}return 0x827680b9810a805f808080357fec80ff800282ec77d1841287978562813b8157;}if(i<236){if(i<234){if(i<233){return 0x847a844080c280d38083808880267fd180d17f9d81047e69842e7d9a86c37db2;}return 0x80de7fad88528420803780a880697fa17ff17f697fcd80287fc480617e4a8129;}if(i<235){return 0x7fca80527f61801884ce820b80a7804c7f9e80208034801f80327fcd803f7f93;}return 0x7ff47ff7800a7fef80197ff68ee5852a7f197ff9802f80077f8480167fbb8026;}if(i<238){if(i<237){return 0x805a7fb98002800c7ff7800f7fef800782df81eb7f0f80b87ee280847f8e802c;}return 0x7f2e7dcf80db7f7f803f7fc380187fdf80197ff77fbc7db380247e5d81c87f3f;}if(i<239){return 0x6c8586b67ded82657e6580967fae802c7fea80177ff08005812d7ec98c127afa;}return 0x80017fe383177db4801c7f3c80477fd280117fef80067ff980057ffe7fc58175; } }
    function cw15(uint256 i) internal pure returns(uint256){ unchecked { if(i<248){if(i<244){if(i<242){if(i<241){return 0x94c8941498a197ea996f97f1983e9818996a98be98449846987d980598789828;}return 0x8e2b8e5d8cc88e1a944c95919245959c9496951291f8934e9489946c9393945e;}if(i<243){return 0x869485f28629857d86da85c58e408cf990d28c398db08d2d918d8fa18d548dfa;}return 0x85688455832a835b82b482f88298823d8681881183f7882785f5869683c08569;}if(i<246){if(i<245){return 0x82a38341814082d182ee821781e4820d8134806784d8821486d381c0850b83c9;}return 0x83be828982d281fc82d0814e81c181c1819f81a181e28159837c84dc829e8457;}if(i<247){return 0x82f8836482b082d8826b821f819f819e81bf81678175814c817e7f03836f8262;}return 0x812d7eda8298830782958279821381e681da8160815a80fb812380c081d88074;}if(i<252){if(i<250){if(i<249){return 0x80dd80038159805682b782d682618277821481e28132815380f980e780f780af;}return 0x802881137fef812f7f427ef1824a831e8225827281c48183813980f080dd807b;}if(i<251){return 0x80c4805280927fda817d7d9e83ab7db082db833182d7815c81c8811f80dc80e0;}return 0x81288093808180217ffd7fdf7f258383767284d0848d81d781b181db813480ff;}if(i<254){if(i<253){return 0x8010818a80ac809380297ff17fd17edd7ed37de3869b7ca5851d7c7682b88132;}return 0x832c7db081f280ca808980317fd87fee7e0e80d07e4d82467944827b85d98759;}if(i<255){return 0x7e77806f891f80e98141807e805a7fd680197fe181267f3d80c07eb383d47e00;}return 0x80297fc8807f7fdd7f2b7f8c80cd804e7ff07f6280527fdd7f5780537f9f809f; } }
    function cw16(uint256 i) internal pure returns(uint256){ unchecked { if(i<264){if(i<260){if(i<258){if(i<257){return 0x7fb680227fd9802b7fc8800d88fd811f80727fd57fcc80a07f54802580467fdf;}return 0x7e8180a77fff7ff9800d7fef80197ff77f0a82f87d3981157e737ff580317ffd;}if(i<259){return 0x847f7c2882ce7e9180397ff27ffe80047fed800784607b3783f97f9b7f1b81a8;}return 0x7ff382a57b78830c7da381137fb680137ff9800580047ffd7af0856f7d4d7deb;}if(i<262){if(i<261){return 0x7fc2807f80ac7eee81877e7180ca7f71801b7ff380047ffc7fff8001819a7d6e;}return 0x933293589806982297cd97f797e097d797a497b997dc97a597bb97289704972f;}if(i<263){return 0x8d518c7a8cbd8ca09442940a947693f09421941c949a943b93f193f193f2930f;}return 0x864b868d8604859c85e985af8d888dd88cf08dae8d428d338c698cdd8d7c8ce1;}if(i<268){if(i<266){if(i<265){return 0x82ee8306834b831882cb832782d782c286e18688873e866586e186c7876286d0;}return 0x82fb8261832b820e821d820f822882618198818383a0846582a28406830c836f;}if(i<267){return 0x826082b18267828781f6828e820581d281f481b0814281ac835d831e8353827c;}return 0x830383008297825e823f8219820e81ea81bc81b381b781bd817180f582fa8365;}if(i<270){if(i<269){return 0x8110808682f7830e82668251820a81e681b381c8817b8194817d8155808d811c;}return 0x80dc81587f8d80f082ea82fa827f820081de819c81aa815c815381458148811c;}if(i<271){return 0x810e80b08129803181487ff083348303823481c48176816e814681378102813f;}return 0x80d080d0808181047fcd81f77e1d811282898426811f8203813b8144811c80e3; } }
    function cw17(uint256 i) internal pure returns(uint256){ unchecked { if(i<280){if(i<276){if(i<274){if(i<273){return 0x80ce80d580988087809080cf80cb7f5f81a17e72833a81c182358130813480fb;}return 0x81b880c780cb8073806c8044807e8059809c802e7f258088820d8556811b815f;}if(i<275){return 0x829383de812280c08067804b80257ff980747fd080537fc480b37f7c833380a2;}return 0x7fff7fee823982928066809180327ff67fc27fcb7fb380107ff87fcd7f948027;}if(i<278){if(i<277){return 0x7ff77ffd7ff38003828f82fb80bc80327fd57fb98037800280217ffb7ffc801a;}return 0x80247ff280077ff980067ffd81dd83487f8e7fdd7fd7805d7f9a80187fd1800a;}if(i<279){return 0x7fb480037fe380077ffa80047ffc800181a180577f1980cb7faa7f8180537fd9;}return 0x7fd07fe87fec801980087ffe80027fff80027fff7e157fbc80ff7ef07f438073;}if(i<284){if(i<282){if(i<281){return 0x81ea7ecd805f7fdb80257fe380017fff800080008000800080d681567d7d817d;}return 0x7ff5806a7f2d80567fbf801b7fe6800a7ffd80017fff8001800080007fb97ea3;}if(i<283){return 0x9238918f921f916191cf919e91b291c9980b983a980a9842981b982098089828;}return 0x82d6831f82bd825d82b282678295829289bf8a4489f88aab8a218a3b8a608a1d;}if(i<286){if(i<285){return 0x8025847a7f44811184227ba386a67ea085897c82892a828980f581f77c778357;}return 0x7f9580ee7fb37ffe80138028803b7f8981f27fcf831980787e7f82b87e0781b7;}if(i<287){return 0x7faa81047fc78006800880197ff67fff801b7f6f801a7ffc7ffa7fea800f7ffa;}return 0x7fec80207ff67fff800280007ff67fff803b7f16802f7ffb7ff67feb80098002; } }
    function cw18(uint256 i) internal pure returns(uint256){ unchecked { if(i<296){if(i<292){if(i<290){if(i<289){return 0x94698722a2cd8f0b8c0193f892b790d995eb9fe38e2a96bc9da2959b9854980b;}return 0x82d1814e88e5813881f582a8846e81a488b38fb77c128d058cca893c87998b3e;}if(i<291){return 0x833c7b0384ee80cf7f69819a87b87d4b839b864c7de7846381ea814d7f938248;}return 0x817f7bfa81ee7ecb80117f9a83407edc813e828e807381a581207ebd7e6780ea;}if(i<294){if(i<293){return 0x80be7e55809f7df1812c7dcb84377ed07f3f8165803f807c7fbe809b7d878068;}return 0x80747c6c84637c5682097e2381807f6b7f24846f7b4b83827d1b839b7b5f80f9;}if(i<295){return 0x93c88d1c90f8a3f58fd9976c8c3093d8985a98169b23920a975796699a8897b8;}return 0x829385477f8285d883e9816b81e883448a4d8a738f9c811289128b248c338963;}if(i<300){if(i<298){if(i<297){return 0x7e108b958042821481967f5085ff7f34851f7ae886d380a881a8811e82b880d0;}return 0x7e9e837180fe80157f837ffb7f927f2984a479c182a5801f7f23818d765982d2;}if(i<299){return 0x8495688f960a7cf07ed280c380a87fe87dd4860677f080ac8022803c7de18047;}return 0x805e7c70817a80f879c983e27de480587b8f90d46e1c81c7857a7c2a81b07fa8;}if(i<302){if(i<301){return 0x9145925c921a8bcb912b8fea921690d897e197b5976899d9980b982196919767;}return 0x83b582288474827e829d82f682a0831489e08a9b886c8e668b6489ba88b88944;}if(i<303){return 0x82617fec8275813480c782107ebe8212816c84a9810b82a181d381ae83968124;}return 0x8068800480af7f9f7fd97fd2804c7f7b80be81e3810180d980ce802b80c080c1; } }
    function cw19(uint256 i) internal pure returns(uint256){ unchecked { if(i<305){return 0x7f9e81927edb805f7dd781567f0d80187f99804d7e927feb804c7fd480367fe0;}return 0x7fd3806c7f887ffc7f24803a7ff27ff1803d7ee680cf7f2981947f4280617ff7; } }
    function cw(uint256 i) internal pure returns(uint256){ unchecked { if(i<160){if(i<80){if(i<32){if(i<16){return cw0(i);}return cw1(i);}if(i<48){return cw2(i);}if(i<64){return cw3(i);}return cw4(i);}if(i<112){if(i<96){return cw5(i);}return cw6(i);}if(i<128){return cw7(i);}if(i<144){return cw8(i);}return cw9(i);}if(i<240){if(i<192){if(i<176){return cw10(i);}return cw11(i);}if(i<208){return cw12(i);}if(i<224){return cw13(i);}return cw14(i);}if(i<272){if(i<256){return cw15(i);}return cw16(i);}if(i<288){return cw17(i);}if(i<304){return cw18(i);}return cw19(i); } }
    // per table: row knots (2 words), column knots (2 words), nr, nc, first coefficient index; knots in 1/64 grid units
    function tab(uint256 tb) internal pure returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256){ unchecked { if(tb==0)return(0x29f0290226fe2610259925512507248a23b422211e0711d10000000000000000,0x000000000000000050005000500050003e2f31f92ddf2c4c2b762af92aaf2a67,0x00000000030003000300030002f002e0024800b8001b000b0000000000000000,0x0000000000000000000000000000000000000000000000000000000000000000,24,10,0);if(tb==1)return(0x28a0283427cc276026ef267725f9257724df23f420d812c50000000000000000,0x000000000000000050005000500050003d3b2f282c0c2b212a892a0729892911,0x0c000c00091007a906f6068d063005d00573050a045702f00000000000000000,0x000000000000000000000000000000000000000000000000000000000c000c00,24,14,960);if(tb==2)return(0x2af42a2d298e28f7285527ab2709267225d3250c226518230000000000000000,0x0000000000000000000000000000000000000000500050005000500037dd2d9b,0x0c000c000c000c000781074006bc064505bb054404c0047f0000000000000000,0x0000000000000000000000000000000000000000000000000000000000000000,18,12,2304);if(tb==3)return(0x28a2283627ca275e26ed267725f7256724b42395204c12b70000000000000000,0x000000000000000050005000500050003d492fb42c6b2b4c2a992a0929892913,0x0c000c00094507e30720069d063305cd056304e0041d02bb0000000000000000,0x000000000000000000000000000000000000000000000000000000000c000c00,24,14,3168);return(0x5000500050005000314e2bc82a0228c4273c25fe24381eb20000000000000000,0x0000000000000000000000000000000000000000000000000000000000000000,0x00000000000000000c000c000c000c0007710685057b048f0000000000000000,0x0000000000000000000000000000000000000000000000000000000000000000,12,8,4512); } }
    function kn(uint256 K0,uint256 K1,uint256 L) internal pure returns(int256){ unchecked { return int256((L<16?K0>>(16*L):K1>>(16*(L-16)))&0xffff); } }
    // cubic B-spline basis at x (1/64 units) by Cox-de Boor; returns span m, N[q] = basis of coefficient m-3+q (WAD)
    function bas(uint256 K0,uint256 K1,uint256 n,int256 x,int256[4] memory N) internal pure returns(uint256 m){ unchecked {
        if(x>=kn(K0,K1,n)){m=n-1;}else{uint256 lo=3;uint256 hi=n;while(hi-lo>1){uint256 md=(lo+hi)>>1;if(kn(K0,K1,md)<=x)lo=md;else hi=md;}m=lo;}
        int256 l1=x-kn(K0,K1,m);int256 l2=x-kn(K0,K1,m-1);int256 l3=x-kn(K0,K1,m-2);
        int256 r1=kn(K0,K1,m+1)-x;int256 r2=kn(K0,K1,m+2)-x;int256 r3=kn(K0,K1,m+3)-x;
        int256 tp=U/(r1+l1);int256 n0=r1*tp;int256 n1=l1*tp;
        tp=n0/(r1+l2);n0=r1*tp;int256 sv=l2*tp;tp=n1/(r2+l1);n1=sv+r2*tp;int256 n2=l1*tp;
        tp=n0/(r1+l3);N[0]=r1*tp;sv=l3*tp;tp=n1/(r2+l2);N[1]=sv+r2*tp;sv=l2*tp;tp=n2/(r3+l1);N[2]=sv+r3*tp;N[3]=l1*tp;
    } }
    // nC consecutive coefficient lanes starting at flat index idx
    function stripe(uint256 idx,uint256 nC) internal pure returns(uint256 x){ unchecked {
        uint256 o=idx&15;x=cw(idx>>4)>>(16*o);
        if(o+nC>16)x|=cw((idx>>4)+1)<<(16*(16-o));
    } }
    function ln16(uint256 x,uint256 p) internal pure returns(int256){ unchecked { return int256((x>>(16*p))&0xffff)-32768; } }
    // one coefficient stripe contracted with the two column-node bases: ta = sum C0[p] c[p], tb = sum C1[p] c[p+dc]
    function row2(uint256 x,uint256 dc,int256[4] memory C0,int256[4] memory C1) internal pure returns(int256 ta,int256 tb){ unchecked {
        ta=C0[0]*ln16(x,0)+C0[1]*ln16(x,1)+C0[2]*ln16(x,2)+C0[3]*ln16(x,3);
        if(dc==0){tb=C1[0]*ln16(x,0)+C1[1]*ln16(x,1)+C1[2]*ln16(x,2)+C1[3]*ln16(x,3);}
        else{tb=C1[0]*ln16(x,dc)+C1[1]*ln16(x,dc+1)+C1[2]*ln16(x,dc+2)+C1[3]*ln16(x,dc+3);}
    } }
    function bern(uint256 l,uint256 s) internal pure returns(int256){ unchecked {
        int256 a=int256(l);int256 b=7-a;
        return s==0?b*b*b:(s==1?3*a*b*b:(s==2?3*a*a*b:a*a*a));
    } }
    // node value: raw sum (1e36 * 1/(8*343) bps) -> WAD bps, clamped at 0
    function cl(int256 F) internal pure returns(int256){ unchecked { F=F/U/2744;return F<0?int256(0):F; } }
    // fee surface F (WAD bps) of table tb at grid point (pw,p2) (WAD grid units): F clamped at 0 at the 4 nodes x 2 sd levels,
    // bilinear in (row, column), then linear in sd (real.py's RealPolicy.lookup on the decoded tables)
    function surf(uint256 tb,int256 pw,int256 p2,uint256 k,int256 tt) internal pure returns(int256){ unchecked {
        (uint256 KR0,uint256 KR1,uint256 KC0,uint256 KC1,uint256 nr,uint256 nc,uint256 base)=tab(tb);
        uint256 i=uint256(pw/U);if(i>319)i=319;int256 f=pw-int256(i)*U;
        uint256 j=uint256(p2/U);{uint256 jm=tb==0?11:47;if(j>jm)j=jm;}int256 g=p2-int256(j)*U;
        int256[4] memory A0;int256[4] memory A1;int256[4] memory C0;int256[4] memory C1;
        uint256 mi=bas(KR0,KR1,nr,int256(i*64),A0);uint256 dr=bas(KR0,KR1,nr,int256(i*64+64),A1)-mi;
        uint256 mj=bas(KC0,KC1,nc,int256(j*64),C0);uint256 dc=bas(KC0,KC1,nc,int256(j*64+64),C1)-mj;
        int256[8] memory W;W[0]=bern(k,0);W[1]=bern(k,1);W[2]=bern(k,2);W[3]=bern(k,3);W[4]=bern(k+1,0);W[5]=bern(k+1,1);W[6]=bern(k+1,2);W[7]=bern(k+1,3);
        // Fv[l*4 + rownode*2 + colnode]
        int256[8] memory Fv;
        uint256 i0=base+(mi-3)*nc+mj-3;uint256 sn=nr*nc;
        for(uint256 q=0;q<dr+4;q++){
            int256 e0a;int256 e0b;int256 e1a;int256 e1b;
            for(uint256 s=0;s<4;s++){
                uint256 x=stripe(i0+s*sn+q*nc,dc+4);
                (int256 ta,int256 tb2)=row2(x,dc,C0,C1);
                int256 w0=W[s];int256 w1=W[s+4];
                e0a+=w0*ta;e0b+=w0*tb2;e1a+=w1*ta;e1b+=w1*tb2;
            }
            if(q<4){int256 ra=A0[q];Fv[0]+=ra*e0a;Fv[1]+=ra*e0b;Fv[4]+=ra*e1a;Fv[5]+=ra*e1b;}
            if(q>=dr&&q<dr+4){int256 rb=A1[q-dr];Fv[2]+=rb*e0a;Fv[3]+=rb*e0b;Fv[6]+=rb*e1a;Fv[7]+=rb*e1b;}
        }
        int256 lv0=mul(mul(cl(Fv[0]),U-f)+mul(cl(Fv[2]),f),U-g)+mul(mul(cl(Fv[1]),U-f)+mul(cl(Fv[3]),f),g);
        int256 lv1=mul(mul(cl(Fv[4]),U-f)+mul(cl(Fv[6]),f),U-g)+mul(mul(cl(Fv[5]),U-f)+mul(cl(Fv[7]),f),g);
        return mul(lv0,U-tt)+mul(lv1,tt);
    } }
    function w2l(uint256 L) internal pure returns(int256){ unchecked {
        uint256 K=L<16?0x7ff77ff67ff57ff47ff27fef7fec7fe77fe27fd87fce7fc47fb07f9c7f7e7f60:(L<32?0x800780068005800480038002800180007fff7ffe7ffd7ffc7ffb7ffa7ff97ff8:(L<48?0x808280648050803c80328028801e801980148011800e800c800b800a80098008:0x00000000000000000000000000000000000000000000000000000000000080a0));
        return int256((K>>(16*(L&15)))&0xffff)-32768;
    } }
    // real.py/evalpol _pos2 over pol_mid's W2L (grid units of 5 bps), WAD in and out
    function pos2(int256 v) internal pure returns(int256){ unchecked {
        if(v<=-160*U)return 0; if(v>=160*U)return 48*U;
        uint256 lo=0;uint256 hi=48;
        while(hi-lo>1){uint256 md=(lo+hi)>>1;if(w2l(md)*U<=v)lo=md;else hi=md;}
        int256 a=w2l(lo);return int256(lo)*U+(v-a*U)/(w2l(hi)-a);
    } }
    function sdl(uint256 k) internal pure returns(int256){ unchecked { return int256((0x221a14100c080400>>(8*k))&0xff); } }
    // qm fee rule: w, w2 offsets (WAD bps), phase, synced flag, belief variance v (WAD, ln-price^2)
    function fees(int256 w,int256 w2,uint256 ph,bool syn,int256 v) internal pure returns(int256 fb,int256 fa){ unchecked {
        int256 sd=root(v)*10000;uint256 k;
        while(k<6&&sd>=sdl(k+1)*U)k++;
        int256 tt=clip((sd-sdl(k)*U)/(sdl(k+1)-sdl(k)),0,U);
        int256 pw=clip(w/5+160*U,0,320*U);int256 wq=(pw-160*U)*5;
        uint256 tb;int256 p2;int256 nc1;
        if(ph==0){tb=0;p2=clip(w2/5,-6*U,6*U)+6*U;nc1=12;}
        else{tb=(ph==1?1:3)+(syn?0:1);p2=pos2(w2/5);nc1=48;}
        int256 xa=surf(tb,pw,p2,k,tt)+wq-w;
        int256 xb=surf(tb,320*U-pw,nc1*U-p2,k,tt)+w-wq;
        fb=xb>0?U-exp(-xb/10000):int256(0);fa=xa>0?U-exp(-xa/10000):int256(0);
        fb=clip(fb,0,U/10);fa=clip(fa,0,U/10);
    } }
    function afterInitialize(uint256 x,uint256 y) external override returns(uint256,uint256){ unchecked {
        int256 sp=int256(y*1e18/x);
        slots[0]=uint256(uint128(int128(ln(sp))));
        slots[1]=uint256(uint128(int128(sp)))*(1+(uint256(1)<<128));
        slots[2]=2823606104386589*(1+(uint256(1)<<64));
        return(2823606104386589,2823606104386589);
    } }
    // filter update over a gap of dt steps; returns new m, v, rival spot r and the arb flag
    function update(int256 m,int256 v,int256 fb,int256 fa,int256 sp,int256 r,int256 s,bool buy,uint256 dt) internal pure returns(int256,int256,int256,bool arb){ unchecked {
        int256 lo=ln(mul(sp,U-fb));int256 hi=ln(divi(sp,U-fa));
        uint256 n=dt-1;if(n>12)n=12;
        for(uint256 i=0;i<n;i++){v+=893025000000;(,m,v)=trunc(m,v,lo,hi);}
        v+=893025000000;
        int256 lp=ln(buy?mul(s,U-fb):divi(s,U-fa));
        int256 sd=root(v);int256 la=divi(pdf(divi(lp-m,sd)),sd);
        (int256 Z,int256 mt,int256 vt)=trunc(m,v,lo,hi);
        int256 d=ab(ln(divi(s,sp)));if(d<1e9)d=1e9;
        int256 pi=pdf(divi(ln(d)+6801595083153746944,1176000000000000000));
        int256 lr=divi(mul(mul(Z,260000000000000000),pi),mul(d,1176000000000000000));
        pi=la+lr>0?divi(la,la+lr):int256(0);arb=pi>U/2;
        if(pi>5e15&&pi<995e15){
            m=mul(pi,lp)+mul(U-pi,mt);
            v=mul(pi,mul(lp-m,lp-m))+mul(U-pi,vt+mul(mt-m,mt-m));
        }else if(arb){m=lp;v=0;}else{m=mt;v=vt;}
        int256 pe=exp(m);r=clip(r,mul(pe,997e15),divi(pe,997e15));
        return(m,v,r,arb);
    } }
    function afterSwap(TradeInfo calldata t) external override returns(uint256,uint256){ unchecked {
        uint256 s0=slots[0];uint256 s1=slots[1];uint256 s2=slots[2];
        int256 m=int256(int128(uint128(s0)));int256 v=int256(int128(uint128(s0>>128)));
        int256 sp=int256(int128(uint128(s1)));int256 r=int256(int128(uint128(s1>>128)));
        int256 fb=int256(s2&M64);int256 fa=int256(s2>>64&M64);uint256 cnt=s2>>192&0xffffffff;bool syn=s2>>255==1;
        int256 s=int256(t.reserveY*1e18/t.reserveX);bool arb;
        if(t.timestamp>(s2>>128&M64)){(m,v,r,arb)=update(m,v,fb,fa,sp,r,s,t.isBuy,t.timestamp-(s2>>128&M64));cnt=0;syn=false;}
        uint256 ph;
        if(!arb){
            int256 c=t.isBuy?divi(mul(s,U-fb),997e15):divi(mul(s,997e15),U-fa);
            if(t.isBuy?c<r:c>r){r=c;syn=true;}
            cnt++;ph=cnt==1?1:2;
        }
        int256 w=(ln(s)-m)*10000;int256 rr=(ln(r)-m)*10000;
        (fb,fa)=fees(w,rr,ph,syn,v);
        slots[0]=uint256(uint128(int128(m)))|uint256(uint128(int128(v)))<<128;
        slots[1]=uint256(uint128(int128(s)))|uint256(uint128(int128(r)))<<128;
        slots[2]=uint256(fb)|uint256(fa)<<64|t.timestamp<<128|cnt<<192|(syn?uint256(1)<<255:0);
        return(uint256(fb),uint256(fa));
    } }
}
```

## Python reference (complete; `qmref.py`, stdlib only, needs the 10,167-byte QMS1 blob from qm-spline's artifact)

As a replica policy: `replica2.run(seed, QMRef('blob.bin'))`.

```python
"""qt1 reference: Taylor's (gtmcknight) Gaussian filter (as port-3's standalone.Coarse / trim-2) + real.py's qm fee
rule over the DECODED qm-spline tables (QMS1 blob, sha256 3ac7cb88...). Standard library only.
usage: from qmref import QMRef; QMRef('blob.bin') is a replica2 policy (wants_j).
Init fees = real.py's init: the full plain pol_mid table at (0,0,0) = 0.002823606104386589 each.
"""
import math, struct

SIG2 = .000945 ** 2
LD_M, LD_S = math.log(11.12e-4), 1.176
INIT = 0.002823606104386589
MAXF = 0.1


def phi(x): return math.exp(-.5 * x * x) / 2.5066282746310002
def Phi(x): return .5 * (1 + math.erf(x / 1.4142135623730951))


def trunc(m, v, lo, hi):
    if v <= 0: return float(lo <= m <= hi), m, 0.
    sd = math.sqrt(v); a = (lo - m) / sd; b = (hi - m) / sd; z = Phi(b) - Phi(a)
    if z < 1e-12: return z, lo if m < lo else hi, v * .25
    pa, pb = phi(a), phi(b); r = (pa - pb) / z
    return z, m + sd * r, max(0, v * (1 + (a * pa - b * pb) / z - r * r))


def parse(blob):
    o = [0]
    def rd(fmt):
        v = struct.unpack_from('<' + fmt, blob, o[0]); o[0] += struct.calcsize('<' + fmt); return v
    assert blob[:4] == b'QMS1'; o[0] = 4
    form, ntab, nw, w0, h, ns = rd('BBHHBB'); assert form == 3
    S = list(rd('%dB' % ns)); n2 = rd('B')[0]; W2L = list(rd('%dh' % n2)); fb = rd('B')[0]
    tabs = []
    for _ in range(ntab):
        nr, nc, nk = rd('BBB')
        kr = list(rd('%dH' % (nr - 4))); kc = list(rd('%dH' % (nc - 4))); ks = list(rd('%dH' % (nk - 4)))
        assert nk == 4 and not ks
        tabs.append([nr, nc, nk, kr, kc])
    for t in tabs:
        t.append(list(rd('%dh' % (t[0] * t[1] * t[2]))))
    assert o[0] == len(blob)
    return dict(NW=nw, W0=w0, H=float(h), S=[float(s) for s in S], W2L=[float(v) for v in W2L], FB=fb, tabs=tabs)


def basis(knots, x):
    """all cubic B-spline basis values at x (Cox-de Boor recursion), right end included"""
    t = knots; n = len(t) - 4
    B = [1.0 if t[m] <= x < t[m + 1] else 0.0 for m in range(len(t) - 1)]
    if x >= t[-1]:
        last = max(m for m in range(len(t) - 1) if t[m] < t[m + 1]); B = [0.0] * (len(t) - 1); B[last] = 1.0
    for d in range(1, 4):
        Bn = [0.0] * (len(t) - 1 - d)
        for m in range(len(t) - 1 - d):
            a = t[m + d] - t[m]; b = t[m + d + 1] - t[m + 1]
            if a > 0: Bn[m] += (x - t[m]) / a * B[m]
            if b > 0: Bn[m] += (t[m + d + 1] - x) / b * B[m + 1]
        B = Bn
    return B[:n]


def surfaces(P):
    """F[t][level][row][col] = max(0, spline) at the grid nodes, in bps"""
    out = []
    for ti, (nr, nc, nk, kr, kc, C) in enumerate(P['tabs']):
        ncol = 2 * P['FB'] + 1 if ti == 0 else len(P['W2L'])
        Kr = [0.0] * 4 + [v / 64 for v in kr] + [P['NW'] - 1.0] * 4
        Kc = [0.0] * 4 + [v / 64 for v in kc] + [ncol - 1.0] * 4
        Ks = [0.0] * 4 + [len(P['S']) - 1.0] * 4
        Br = [basis(Kr, i) for i in range(P['NW'])]; Bc = [basis(Kc, j) for j in range(ncol)]
        Bs = [basis(Ks, l) for l in range(len(P['S']))]
        F = []
        for l in range(len(P['S'])):
            D = [[sum(Bs[l][s] * C[(s * nr + r) * nc + c] for s in range(nk)) / 8.0 for c in range(nc)] for r in range(nr)]
            E = [[sum(D[r][c] * Bc[j][c] for c in range(nc)) for j in range(ncol)] for r in range(nr)]
            F.append([[max(0.0, sum(Br[i][r] * E[r][j] for r in range(nr))) for j in range(ncol)] for i in range(P['NW'])])
        out.append(F)
    return out


class Tables:
    """A/B exactly as qms_decode.to_qm writes them (rounded to 6 decimals)"""
    def __init__(self, blob):
        P = parse(blob); self.P = P
        NW = P['NW']; w = [(i - P['W0']) * P['H'] for i in range(NW)]
        self.A = {}; self.B = {}
        for tag, F in zip(['0c', '1s', '1c', '2s', '2c'], surfaces(P)):
            A = [[[round(F[l][i][j] + w[i], 6) for j in range(len(F[l][i]))] for i in range(NW)] for l in range(len(F))]
            self.A[tag] = A
            self.B[tag] = [[row[::-1] for row in A[l][::-1]] for l in range(len(A))]


class QMRef:
    wants_j = True
    _cache = {}
    def __init__(self, blob_path):
        if blob_path not in QMRef._cache: QMRef._cache[blob_path] = Tables(open(blob_path, 'rb').read())
        self.T = QMRef._cache[blob_path]; P = self.T.P
        self.S = P['S']; self.W0 = P['W0']; self.NW = P['NW']; self.h = P['H']; self.FB = P['FB']; self.W2L = P['W2L']
        self.m = math.log(100); self.v = 0.; self.tlast = 0; self.cnt = 0; self.s2h = 100.; self.fb = self.fa = .003
        self.sp = 100.; self.synced = False
    def _pos2(self, v):
        W = self.W2L; n = len(W)
        if v <= W[0]: return 0.0
        if v >= W[n - 1]: return float(n - 1)
        lo, hi = 0, n - 1
        while hi - lo > 1:
            mid = (lo + hi) // 2
            if W[mid] <= v: lo = mid
            else: hi = mid
        return lo + (v - W[lo]) / (W[hi] - W[lo])
    def lookup(self, w, w2, phs, sd):          # real.py RealPolicy.lookup
        S = self.S; k = 0
        while k < len(S) - 2 and sd >= S[k + 1]: k += 1
        tt = min(1.0, max(0.0, (sd - S[k]) / (S[k + 1] - S[k])))
        tag = '0c' if phs == 0 else (str(phs) + ('s' if self.synced else 'c'))
        A, B = self.T.A[tag], self.T.B[tag]
        pw = min(self.NW - 1.0, max(0.0, w / self.h + self.W0))
        l2 = w2 / self.h
        if phs == 0:
            l2 = min(self.FB, max(-self.FB, l2)); p2 = l2 + self.FB; n2 = 2 * self.FB + 1
        else:
            p2 = self._pos2(l2); n2 = len(self.W2L)
        i = min(int(pw), self.NW - 2); j = min(int(p2), n2 - 2); f = pw - i; g = p2 - j
        def bl(Tb):
            return (Tb[i][j] * (1 - f) + Tb[i + 1][j] * f) * (1 - g) + (Tb[i][j + 1] * (1 - f) + Tb[i + 1][j + 1] * f) * g
        a = bl(A[k]) * (1 - tt) + bl(A[k + 1]) * tt
        b = bl(B[k]) * (1 - tt) + bl(B[k + 1]) * tt
        fa = 1.0 - math.exp(-(a - w) * 1e-4) if a > w else 0.0
        fb = 1.0 - math.exp(-(b + w) * 1e-4) if b > -w else 0.0
        return fb, fa
    def init(self, *args):
        self.fb = self.fa = INIT; return INIT, INIT
    def on_trade(self, is_buy, ax, ay, t, x, y, arb=False, p=100., s2=100., j=0):
        s = y / x; dt = t - self.tlast; is_arb = False
        if dt >= 1:
            self.cnt = 0; lo = math.log(self.sp * (1 - self.fb)); hi = math.log(self.sp / (1 - self.fa)); m, v = self.m, self.v
            for _ in range(min(dt - 1, 12)):
                v += SIG2; _, m, v = trunc(m, v, lo, hi)
            v += SIG2
            lp = math.log(s * (1 - self.fb)) if is_buy else math.log(s / (1 - self.fa)); sd = math.sqrt(v)
            la = phi((lp - m) / sd) / sd; Z, mt, vt = trunc(m, v, lo, hi); d = max(abs(math.log(s / self.sp)), 1e-9)
            lr = Z * .26 * phi((math.log(d) - LD_M) / LD_S) / (d * LD_S)
            pi = la / (la + lr) if la + lr > 0 else 0.; is_arb = pi > .5
            if .005 < pi < .995:
                m2 = pi * lp + (1 - pi) * mt; self.m, self.v = m2, pi * (lp - m2) ** 2 + (1 - pi) * (vt + (mt - m2) ** 2)
            elif is_arb: self.m, self.v = lp, 0.
            else: self.m, self.v = mt, vt
            pe = math.exp(self.m); self.s2h = max(pe * .997, min(pe / .997, self.s2h)); self.synced = False
        if not is_arb:
            cand = s * (1 - self.fb) / .997 if is_buy else s * .997 / (1 - self.fa)
            if (cand < self.s2h) if is_buy else (cand > self.s2h): self.s2h = cand; self.synced = True
            self.cnt += 1; ph = 1 if self.cnt == 1 else 2
        else: ph = 0
        self.tlast = t; self.sp = s
        fb, fa = self.lookup((math.log(s) - self.m) * 1e4, (math.log(self.s2h) - self.m) * 1e4, ph, math.sqrt(self.v) * 1e4)
        self.fb, self.fa = min(MAXF, max(0.0, fb)), min(MAXF, max(0.0, fa))
        return fb, fa
```