From ff038070b8d122a43993f2b2524154323cc6b4d7 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Mon, 2 Nov 2026 22:40:39 -0600 Subject: [PATCH] Construct the selected stochastic caller with absolute error bounds --- .../NOTICE | 50 + .../PROOF.md | 282 + .../README.md | 62 + .../RESULT.json | 6702 +++++++++++++++++ .../SOURCES.json | 36 + .../TASK.json | 83 + .../VERIFY.json | 40 + .../endpoint.py | 70 + .../ledger.py | 190 + .../produce.py | 102 + .../sampler.py | 226 + .../verify.py | 177 + 12 files changed, 8020 insertions(+) create mode 100644 research/selected-absolute-stochastic-caller/NOTICE create mode 100644 research/selected-absolute-stochastic-caller/PROOF.md create mode 100644 research/selected-absolute-stochastic-caller/README.md create mode 100644 research/selected-absolute-stochastic-caller/RESULT.json create mode 100644 research/selected-absolute-stochastic-caller/SOURCES.json create mode 100644 research/selected-absolute-stochastic-caller/TASK.json create mode 100644 research/selected-absolute-stochastic-caller/VERIFY.json create mode 100644 research/selected-absolute-stochastic-caller/endpoint.py create mode 100644 research/selected-absolute-stochastic-caller/ledger.py create mode 100644 research/selected-absolute-stochastic-caller/produce.py create mode 100644 research/selected-absolute-stochastic-caller/sampler.py create mode 100644 research/selected-absolute-stochastic-caller/verify.py diff --git a/research/selected-absolute-stochastic-caller/NOTICE b/research/selected-absolute-stochastic-caller/NOTICE new file mode 100644 index 0000000000..b2820d48cf --- /dev/null +++ b/research/selected-absolute-stochastic-caller/NOTICE @@ -0,0 +1,50 @@ +New work: Ali Romman with substantial OpenAI Codex assistance. No subagents. +Apache-2.0. + +DreamingOfClouds supplies the selected PR6030 word. Its P104 lineage through +PR5907, PR5827, PR5811, PR5786 and earlier work remains credited. +https://github.com/CrocSwap/integer-mult-bounds/pull/6030 + +Ali Romman's PR6526 supplies the exact signed forward/reverse transfer method +and Hilbert tail proof. The new package changes the local error contract and +supplies the complete numerical caller and retained-state inverse. +https://github.com/CrocSwap/integer-mult-bounds/pull/6526 + +Ali Romman's PR6532 supplies the pair map, conditional moment proof and route +formula adapted in sampler.py. PR6509 supplies the prior deterministic center +family. PR6540 supplies a distinct coarse-grid codec and eight rank checks. +https://github.com/CrocSwap/integer-mult-bounds/pull/6532 +https://github.com/CrocSwap/integer-mult-bounds/pull/6509 +https://github.com/CrocSwap/integer-mult-bounds/pull/6540 + +Nick Petalas supplies PR6438's unbiased reversible ensemble construction and +PR6418's adaptive reuse bound. zxv's PR6066 supplies the reversible stochastic +shear ABI and earlier warning that restored randomness need not be fresh. +https://github.com/CrocSwap/integer-mult-bounds/pull/6438 +https://github.com/CrocSwap/integer-mult-bounds/pull/6418 +https://github.com/CrocSwap/integer-mult-bounds/pull/6066 + +Cinna Davis, 1337isnot1337, PR4088 and PR2226, supplies the consumed exact +native representations. All source notices remain unchanged. The compiler +retains the work of icekylinx, DreamingOfClouds, vendor531, Rohan Arun and the +preceding Gaussian lineage. Source coordinate code and source compiler remain +separate implementations; neither source is authored by this package. +https://github.com/CrocSwap/integer-mult-bounds/pull/4088 +https://github.com/CrocSwap/integer-mult-bounds/pull/2226 + +Tekalign's reversible lifting, JoyboyBrian's rounded ports, Arham Tahir's +numerical work and the PR4743/PR5485 lineage precede the pair construction. +Chris R / Clear1nsight and the credited PR4017 contributors supplied a distinct +source-bound deterministic native circuit with dirty scratch. +https://github.com/CrocSwap/integer-mult-bounds/pull/5485 +https://github.com/CrocSwap/integer-mult-bounds/pull/4017 + +Ali Romman's PR6499 supplies a different exact scalar grid contract between +independent native returns; PR6506 lowers that scalar layer to Boolean +circuits. Their native return/error and reset premises are not imported. +https://github.com/CrocSwap/integer-mult-bounds/pull/6499 +https://github.com/CrocSwap/integer-mult-bounds/pull/6506 + +Integer residue retention, scalar stochastic rounding, martingale orthogonality +and the concentration argument are established mathematics. No global +literature priority or physical reversible implementation is claimed. diff --git a/research/selected-absolute-stochastic-caller/PROOF.md b/research/selected-absolute-stochastic-caller/PROOF.md new file mode 100644 index 0000000000..178000008b --- /dev/null +++ b/research/selected-absolute-stochastic-caller/PROOF.md @@ -0,0 +1,282 @@ +# An absolute-error numerical caller with retained inverse state + +This result supplies a complete integer numerical execution of the selected +[PR #6030](https://github.com/CrocSwap/integer-mult-bounds/pull/6030) word and its literal inverse. It also proves error bounds for every +tensor width. It does not supply a physical reversible circuit, a fast recursive +native child, a fixed multitape schedule or a new complete kappa. The selected +frontier and all five framework assumptions remain unchanged. + +## Source and contract + +The source is the 22,803-event selected word pinned in SOURCES.json. It has +770 public fields, 29 owned labels, 31 INIT/CLEAR lifetimes, 23 COPY events, +18,404 ADDs, 861 SCALEs and 3,453 MOVEs. A field has N=512^f complex coordinates, +where f is a positive integer. The operator at each frame is the tensor power +of its 512-coordinate source frame. This defines the explicit tensor lift of +this fixed word. It does not identify every recursive caller with that lift. + +Every stored real and imaginary component is an integer times the same positive +grid spacing h. Public input integers are arbitrary. Each forward rounding +stage receives a new uniform seed, conditional on the entire previous state. +It can use one seed for all coordinates of that stage. The inverse retains and +reuses that stage's seed. No later forward stage can reuse it under this proof. + +The source compiler gives a recipe L C_r R for every one of the 2,886 distinct +MOVE edges. The independent coordinate implementation checks all 512 columns +of every recipe: 1,477,632 column comparisons. Both source modules run unchanged +with assertions enabled. The new matrix interpreter uses the same route tables +as the sampler, with exact linear pair arithmetic. Integer range checks keep +all matrix comparisons below the int64 limit. The rank counts for ranks 1 +through 8 are 2219, 457, 496, 100, 163, 11, 6 and 1. Their weighted sum is 5952. +The source's last MOVE Boolean is an ownership flag, not an inverse flag. + +## Completed numerical primitives and their inverses + +The central Gaussian pair is + +```text +C = [[1+i, 1-i], [1-i, 1+i]] / 2. +``` + +For integer Gaussian x,y put s=x+y and d=x-y. If Re(s)+Im(s) is even, let +c=0. Otherwise let c be sign(Re(s)) when Re(s) is odd, and `i*sign(Im(s))` +otherwise. With a fresh fair sign sigma, use + +```text +d' = i*(d-sigma*c)+sigma*c, +x' = (s+d')/2, y' = (s-d')/2. +``` + +All halves are exact integers. The sum s stays fixed, so the inverse uses +-i in the same formula and the same sign. The mean is the ideal C pair. The +squared error is h^2 when c is nonzero and zero otherwise. Thus one complete +layer of N/2 pairs has conditional mean-zero defect, squared error at most +`N*h^2/2`, and pathwise norm at most `h*sqrt(N/2)`. A common sign for the layer +is sufficient. These pair facts and their construction are prior [PR #6532](https://github.com/CrocSwap/integer-mult-bounds/pull/6532) work. + +A rank-r tensor native operator has `r*f` such layers, between its exact tensor +monomials. Use a fresh sign at each layer and reverse layers in the opposite +order for decoding. Conditional zero mean and unitary ideal layers give + +```text +E(native output | input) = (L C_r R)^tensor f input, +E(||native defect||^2 | input) <= r*f*N*h^2/2, +||native defect|| <= r*f*h*sqrt(N/2). +``` + +The stage construction need not attain the least variance of the complete +native operator. [PR #6540](https://github.com/CrocSwap/integer-mult-bounds/pull/6540) gives a different changed-grid interface and sharper +pointwise variance class; its grid and residue contract is not substituted here. + +For a scalar q=p/D in lowest terms, D is a power of two in the source. Given a +fresh uniform u in [0,D), round each component v by `floor((p*v+u)/D)`. Integer +q needs no seed and is exact. For noninteger q, each coordinate has the exact +mean `q*v`, variance at most 1/4 and absolute error below one grid unit. Hence a +complete complex field has variance at most `N*h^2/2` and pathwise norm at most +`h*sqrt(2N)`. Dependence between coordinates does not change these bounds. + +ADD performs y += `round(q*x)` and preserves x. Its inverse subtracts the same +integer increment from the restored x, with the retained seed. It needs no +residue label. Every noninteger SCALE in this source has p=+1 or p=-1. Store +for each real component the residue `v=(p*x+u)` mod D, using log2(D) bits. From +the rounded y, recover `x=p*(D*y+v-u)`. Integer SCALE factors are signed powers +of two; their inverses divide exactly on the reached image. + +COPY has coefficient one. Retain its old destination, then copy the source. +Its inverse checks the copied value and restores the old destination. CLEAR +retains the entire old field, and its inverse restores it. INIT inserts a zero +field; its inverse checks zero and removes that field. Thirty of the 31 ideal +CLEAR inputs are nonzero. This construction does not treat their data as free +clean scratch or prove that the retained values can be erased from outputs. + +Reverse all 22,803 instructions. Each step receives the state that its forward +step produced, because later steps have already been reversed. The local +inverse rules therefore recover every public input exactly. This is a bijective +encoding of reached states with a retained record, not a full-state permutation +on identical finite hardware registers. No unpriced dirty compensation follows. + +## Exact decoded transfer coefficients + +Decode each field by its current unitary frame. Ideal MOVE is then the identity; +ADD, SCALE, COPY and resets act by their displayed scalar word. The source frame +and ownership ledger is checked at every event. Independent forward and +transposed backward sweeps agree on every signed defect coefficient of every +final field. Reverse-cut checks also reconstruct each peak below. + +For cut t and field v, let c_j be the signed scalar transfer from a completed +instruction's defect to that field. Retain a defect only for native MOVEs and +noninteger ADD/SCALE instructions. Define + +```text +M(t,v) = sum_native j rank(j)*c_j^2, +S(t,v) = sum_noninteger scalar j c_j^2, +AM(t,v) = sum_native j rank(j)*abs(c_j), +AS(t,v) = sum_noninteger scalar j abs(c_j). +``` + +Shared earlier errors must be combined with their signs before squaring. +COPY propagates an existing error; it is not a fresh independent error. CLEAR +kills later transfer but cannot remove an earlier prefix excursion. The exact +maxima of all four scores occur at cut 20644, field 558: + +```text +M = 23423, +S = 161509/8, +AM = 2957, +AS = 4917/2. +``` + +Cut numbers count completed source events. The maximum ideal row L1 norm is +850, at cut 20479, field 558. Every ideal final row has the source's required +identity or identity-plus-productive-input form. RESULT.json records all 799 +final scores, coefficient digests, peak checks and ideal CLEAR inputs. + +## All-width absolute error bounds + +Let e(t,v) be the difference from the ideal execution with the same input. +All ideal charts and transfer coefficients are deterministic. At each native +microstage, the later ideal stages form a deterministic unitary map. Fresh +conditional zero mean makes distinct microstage and scalar defects orthogonal +in expectation, even when their inputs depend on earlier rounded values. +For every field at every cut, + +```text +E||e(t,v)||^2 <= (N*h^2/2) * (23423*f + 161509/8), +||e(t,v)|| <= h*sqrt(N/2) * (2957*f + 4917) for every seed stream. +``` + +There is no division by the input norm and no small relative-error premise. +The bound is valid for every input size. It also holds at zero input; in that +case this specific program in fact remains exactly zero. + +For a Hilbert-space martingale with increments bounded by deterministic b_j, +its sum S satisfies `Pr(||S||>=R) <= 2*exp(-R^2/(2*sum b_j^2))`. For completeness, +put a=||x|| and d=Re/a, with ||z||<=b. The increasing convex function +`cosh(lambda*sqrt(s))` lies below its secant on [(a-b)^2,(a+b)^2]. Therefore + +```text +cosh(lambda*||x+z||) + <= cosh(lambda*a)*cosh(lambda*b) + + (d/b)*sinh(lambda*a)*sinh(lambda*b). +``` + +Conditional zero mean removes the second term. The zero-a or zero-b cases +follow directly. Iterate, use cosh(x)<=exp(x^2/2), and apply Markov's inequality +with lambda=R/sum(b_j^2). This proves the stated bound. Zero total increment +bound gives zero error separately. This classical argument is also retained +in [PR #6526](https://github.com/CrocSwap/integer-mult-bounds/pull/6526); no new concentration inequality is claimed. + +For a fixed cut, each native microstage contributes a squared bound +`c_j^2*N*h^2/2`. Each noninteger scalar contributes at most `4*c_j^2*N*h^2/2`. +Only one field changes at each source event. A union over the 22,803 event +destinations covers all fields at all prefixes, including fields later cleared. +For every epsilon>0, + +```text +Pr(max_all_fields_and_prefixes ||e|| >= epsilon) + <= 45606 * exp(-epsilon^2 / (N*h^2*(23423*f + 161509/2))). +``` + +Unlike a relative contract, these deterministic absolute bounds require no +feedback stopping argument. Scalar and native coordinate correlations are +allowed; fresh forward randomness remains a necessary premise. + +At f=1, `h=epsilon*2^-12` makes every individual RMS error below epsilon. +With `h=epsilon*2^-16` the simultaneous failure probability is below 2^-40. +These are different guarantees, not least physical precisions or a direct +comparison with [PR #6526](https://github.com/CrocSwap/integer-mult-bounds/pull/6526)'s input-relative guards. The rational certificate proves +an even weaker exponent 8388608/208355 sufficient: the first 65 positive terms +of its exponential already exceed `45606*2^40`. The actual width-one binary-grid +exponent at 16 bits is twice that value. + +For a simple all-width rule, let b be the least nonnegative integer with +4^b>=f. Since f>=1, each displayed squared bound is at most f times its +width-one value. It suffices to choose + +```text +h = epsilon * 2^(-ceil(9*f/2)-8-b) for individual RMS error, +h = epsilon * 2^(-ceil(9*f/2)-11-b) for simultaneous failure below 2^-40. +``` + +The direct width-one RMS check improves the first sufficient rule by one bit. +No probability statement is inferred from the deterministic test seed stream. + +## Complete direct work and retained-state bill + +The literal reference uses ordinary integer operations and indexed storage. +A forward run uses `2976*f*N` rounded pair butterflies and 6906 tensor monomial +coordinate passes. A route pass reads f address digits per coordinate. The +inverse pays the same counts. Each pair uses at most 13 real additions or +subtractions, four exact halves and three sign changes, plus parity, bounds +and control checks. Each monomial applies at most two payload sign changes +per coordinate. There is no free native query or free Gaussian tensor power. + +The 18,404 ADDs and 861 SCALEs each evaluate two scalar components per +coordinate. ADD also pays two destination additions per coordinate. Reverse +ADD repeats its quantizer and subtracts. Reverse SCALE reads its residue or +performs an exact signed power-of-two division. The coefficients have absolute +numerators at most 16 and denominators at most 16, so their ordinary integer +work is linear in the signed payload width. Packing, reads, writes, domain +checks and buffer initialization are included, not treated as zero work. + +The exact retained budget for this uncompressed schedule is + +```text +fresh retained seed bits = 5952*f + 18592, +division residue bits = 578*N, +retained old whole-field values = 23 COPY + 31 CLEAR = 54 fields, +peak live plus retained values = 824 fields. +``` + +At width one these are 24,544 seed bits and 295,936 residue bits. The forward +schedule allocates 31 zero fields and copies 23 destinations. Reverse traversal +releases the corresponding values after use. These are upper bounds for this +specific record format, not joint information minima or clean hardware costs. +The checker also keeps copies of all 770 initial fields and all 770 output +fields to compare its inverse. Those verification copies are additional +storage and field-copy work; they are not included in the 824-field schedule. + +The two monomial routes for each distinct edge store 512 nine-bit destinations +and 512 two-bit phases each: 32,507,904 logical table bits for all 2,886 edges, +plus the small source recipes and rank/frame tables. The compiler and table +setup are finite costs. The dense all-column comparison is verification work, +not a hidden zero-cost runtime primitive. + +For input components of magnitude below 2^w, w>=1, the ideal field norm is +at most `850*sqrt(2*N)*2^w`. The pathwise bound above bounds the additional error. +A sufficient signed stored-component width is + +```text +W = w + ceil(9*f/2) + ceil(log2(1700+2957*f+4917)) + 2. +``` + +Six more bits suffice for displayed pair/scalar temporary arithmetic. This is +a sufficient width, not an optimum. The reference uses `O(f*N*W)` indexed bit +work per full forward/inverse word, with the fixed event counts above; address +arithmetic also costs O(f) bits and is covered since W>=f. Its data storage is +`O(N*W)`, with all field/verification-copy constants stated above, plus residues, +seeds and fixed route tables. A physical sampler, reversible gate lowering, +fixed tape routing, retained-data cleanup, accelerated recursive child costs, +outer error recovery and independent proof acceptance remain open. The direct +`O(f*N*W)` evaluation is not priced as the selected fast recursive supplier. + +## Verification and limits + +The registered normal and optimized commands regenerate every source recipe +and compare every matrix column. Source assertions stay enabled in a normal +subprocess. Both exact transfer sweeps and all reverse peak checks run. +Local finite checks enumerate pair inputs, every seed for all source scalar +coefficients, signed division residues and a complete mixed stochastic +trajectory. A 262,144-coordinate rank-eight tensor round trip exercises all +16 active layers. A separate exact-grid tensor input is seed independent and +agrees on all 262,144 coordinates with the source oracle. A dense width-one +run executes and reverses the complete +source word. A separate source-coordinate decoder checks all 770 final fields. +Semantic controls retain lost-residue, wrong-seed, reused-seed, signed-COPY, +CLEAR-prefix, global-phase and conjugation failures. Source byte changes are +rejected. RESULT.json gives the exact counts and hashes. + +These checks and the written proof establish the stated numerical contract. +They do not constitute an independent human review, proof-kernel acceptance, +a full predecessor scientific replay, a selected cold replay, or any of the +five complete framework assumption discharges. diff --git a/research/selected-absolute-stochastic-caller/README.md b/research/selected-absolute-stochastic-caller/README.md new file mode 100644 index 0000000000..55cfda784c --- /dev/null +++ b/research/selected-absolute-stochastic-caller/README.md @@ -0,0 +1,62 @@ +# A complete stochastic numerical caller with absolute error bounds + +The selected 22,803-event [PR #6030](https://github.com/CrocSwap/integer-mult-bounds/pull/6030) word now has a same-grid integer execution +with a literal retained-state inverse. Every one of its 2,886 distinct native +edges is checked on all 512 columns. A dense complete caller run and reverse +replay pass. A separate source-coordinate decoder checks all 770 final fields. + +For N=512^f and grid h, every field at every completed source prefix satisfies + +```text +E||error||^2 <= (N*h^2/2)*(23423*f + 161509/8). +``` + +At width one, grid spacing `epsilon*2^-12` suffices for individual RMS error +below epsilon. Spacing `epsilon*2^-16` gives simultaneous error below epsilon +with probability greater than 1-2^-40. These are absolute-error +contracts. They do not require a relative allowance that fails at small inputs. +The proof includes all-width rules and every retained value and direct cost. + +No complete kappa, physical reversible circuit, fast recursive supplier, +fixed tape schedule or selected assumption discharge is claimed. All five +framework assumptions and the selected frontier remain unchanged. + +- [PROOF.md](PROOF.md): complete numerical ABI, proof, error and work bounds. +- [RESULT.json](RESULT.json): exact source, transfer, execution and control receipt. +- [sampler.py](sampler.py): integer primitives, full caller and literal inverse. +- [ledger.py](ledger.py): signed coefficients from forward and reverse sweeps. +- [produce.py](produce.py): every native edge, checked against the separate source. +- [endpoint.py](endpoint.py): independent decoded numerical endpoint. +- [verify.py](verify.py): complete registered replay and rejection controls. +- [SOURCES.json](SOURCES.json), [NOTICE](NOTICE): source pins and attribution. + +Use CPython 3.12 and NumPy 2.3.4: + +```sh +python3.12 -B scripts/research_package.py --package research/selected-absolute-stochastic-caller +``` + +Both registered modes keep source assertions enabled in normal subprocesses. +The replay regenerates all 1,477,632 native column comparisons and the complete +caller. It also checks 2,401 pair inputs, 48 wide integer round trips, 2,015 +scalar contexts, 5,140 division round trips, all 32 seeds of a mixed trajectory, +and a 262,144-coordinate rank-eight tensor inverse. A separate exact-grid +input checks the tensor operator against the independent source oracle. Seven semantic controls, +two operator mutations and three actual source-corruption rejections remain. +These checks support the written theorem; they are not independent acceptance. + +The claim followed fresh canonical-main and public PR/Discussion checks, with +a second exact-main README/TASK search. Prior [PR #6526](https://github.com/CrocSwap/integer-mult-bounds/pull/6526) supplies the signed +stochastic caller method; [PR #6532](https://github.com/CrocSwap/integer-mult-bounds/pull/6532) supplies the conserved-sum pair sampler. +[PR #6540](https://github.com/CrocSwap/integer-mult-bounds/pull/6540)'s changed-grid codec is distinct. The complete same-grid caller join, +absolute budgets, full source-edge binding and explicit retained record are +new here. No subagents were used. + +## Open next questions + +A physical reversible implementation must price seed access, routing, records +and their cleanup. It must preserve arbitrary external dirty values under its +actual encoding. The direct native execution here is not the accelerated +recursive supplier. Bind one fast child to this numerical ABI, then recompute +the complete caller, tape, precision and outer bill. No such result follows +from the finite source checks or the information-preserving reference alone. diff --git a/research/selected-absolute-stochastic-caller/RESULT.json b/research/selected-absolute-stochastic-caller/RESULT.json new file mode 100644 index 0000000000..73d5082e65 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/RESULT.json @@ -0,0 +1,6702 @@ +{ + "schema_version": 1, + "status": "PASS_SELECTED_ABSOLUTE_STOCHASTIC_CALLER", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "source": { + "events": 22803, + "distinct_edges": 2886, + "frames": 1001, + "full_operator_columns": 1477632, + "move_events": 3453, + "rank_counts": { + "1": 2219, + "2": 457, + "3": 496, + "4": 100, + "5": 163, + "6": 11, + "7": 6, + "8": 1 + }, + "native_stage_count_per_tensor_axis": 5952, + "all_recipe_sha256": "73df25102e072a6a1d32d34c5115611f2eedc84c6b4de410cd6ce01778309ecc", + "source_assertions_enabled": true, + "operator_mutation_controls": 2 + }, + "ledger": { + "opcodes": { + "INIT": 31, + "ADD": 18404, + "SCALE": 861, + "MOVE": 3453, + "CLEAR": 31, + "COPY": 23 + }, + "noise_events": 15548, + "peak_order": [ + "M", + "S", + "AM", + "AS", + "M+S", + "M+4S", + "AM+2AS" + ], + "prefix_peaks": [ + [ + "23423", + 20644, + 558 + ], + [ + "161509/8", + 20644, + 558 + ], + [ + "2957", + 20644, + 558 + ], + [ + "4917/2", + 20644, + 558 + ], + [ + "348893/8", + 20644, + 558 + ], + [ + "208355/2", + 20644, + 558 + ], + [ + "7874", + 20644, + 558 + ] + ], + "final_scores": [ + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "31/2", + "4", + "19", + "4" + ], + [ + "719/8", + "59/2", + "47", + "19" + ], + [ + "6", + "3", + "9", + "3" + ], + [ + "77/4", + "7", + "45/2", + "7" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "65/4", + "4", + "37/2", + "4" + ], + [ + "69/4", + "6", + "41/2", + "6" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "63/4", + "4", + "39/2", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "2", + "5", + "2", + "3" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "97/8", + "37/4", + "33/2", + "19/2" + ], + [ + "19", + "3", + "21", + "3" + ], + [ + "45/4", + "3", + "29/2", + "3" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "25", + "7", + "30", + "7" + ], + [ + "11", + "6", + "14", + "6" + ], + [ + "12", + "3", + "15", + "3" + ], + [ + "97/8", + "41/4", + "33/2", + "21/2" + ], + [ + "31/2", + "5", + "19", + "5" + ], + [ + "65/4", + "4", + "37/2", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "97/8", + "61/2", + "33/2", + "29" + ], + [ + "63/4", + "2", + "35/2", + "2" + ], + [ + "45/4", + "4", + "29/2", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "133/8", + "31/2", + "43/2", + "16" + ], + [ + "6", + "3", + "9", + "3" + ], + [ + "37/2", + "7", + "22", + "7" + ], + [ + "33/2", + "4", + "19", + "4" + ], + [ + "33/4", + "3", + "21/2", + "3" + ], + [ + "83/4", + "2", + "45/2", + "2" + ], + [ + "97/8", + "41/4", + "33/2", + "21/2" + ], + [ + "20", + "3", + "22", + "3" + ], + [ + "45/4", + "3", + "29/2", + "3" + ], + [ + "25/2", + "7", + "17", + "7" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "31/2", + "4", + "19", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "33/2", + "4", + "19", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "24", + "8", + "29", + "8" + ], + [ + "133/8", + "21/2", + "43/2", + "11" + ], + [ + "6", + "3", + "9", + "3" + ], + [ + "35/2", + "7", + "21", + "7" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "49/4", + "21/4", + "33/2", + "11/2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "20", + "8", + "23", + "8" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "151/8", + "25/2", + "24", + "13" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "97/8", + "141/4", + "33/2", + "73/2" + ], + [ + "63/4", + "2", + "35/2", + "2" + ], + [ + "45/4", + "4", + "29/2", + "4" + ], + [ + "73/4", + "3", + "43/2", + "3" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "63/4", + "4", + "39/2", + "4" + ], + [ + "45/4", + "5", + "29/2", + "5" + ], + [ + "14", + "6", + "17", + "6" + ], + [ + "97/8", + "33/4", + "33/2", + "17/2" + ], + [ + "151/8", + "73/4", + "24", + "39/2" + ], + [ + "6", + "3", + "9", + "3" + ], + [ + "77/4", + "5", + "45/2", + "5" + ], + [ + "33/4", + "3", + "21/2", + "3" + ], + [ + "16", + "3", + "19", + "3" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "69/4", + "7", + "41/2", + "7" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "145/8", + "25/4", + "45/2", + "13/2" + ], + [ + "2", + "0", + "2", + "0" + ], + [ + "33/2", + "4", + "19", + "4" + ], + [ + "31/2", + "4", + "19", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "65/4", + "3", + "39/2", + "3" + ], + [ + "145/8", + "21/4", + "45/2", + "11/2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "69/4", + "5", + "41/2", + "5" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "31/2", + "4", + "18", + "4" + ], + [ + "16", + "3", + "19", + "3" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "16", + "3", + "19", + "3" + ], + [ + "33/4", + "3", + "21/2", + "3" + ], + [ + "65/4", + "3", + "39/2", + "3" + ], + [ + "357/4", + "98", + "165/2", + "48" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "97/8", + "25/4", + "33/2", + "13/2" + ], + [ + "14", + "4", + "17", + "4" + ], + [ + "45/4", + "13/2", + "29/2", + "7" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "31/2", + "4", + "19", + "4" + ], + [ + "151/8", + "27/2", + "24", + "14" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "20", + "8", + "23", + "8" + ], + [ + "33/2", + "4", + "19", + "4" + ], + [ + "31/2", + "4", + "19", + "4" + ], + [ + "39/4", + "2", + "23/2", + "2" + ], + [ + "25/2", + "4", + "17", + "4" + ], + [ + "97/8", + "41/4", + "33/2", + "21/2" + ], + [ + "12", + "3", + "15", + "3" + ], + [ + "11", + "6", + "14", + "6" + ], + [ + "83/4", + "4", + "45/2", + "4" + ], + [ + "33/4", + "3", + "21/2", + "3" + ], + [ + "733", + "12129/8", + "762", + "1250" + ], + [ + "852", + "39233/32", + "856", + "4713/4" + ], + [ + "1785/4", + "12777/16", + "931/2", + "3037/4" + ], + [ + "8", + "0", + "8", + "0" + ], + [ + "2237/4", + "6453/8", + "1225/2", + "798" + ], + [ + "961/2", + "6057/8", + "536", + "767" + ], + [ + "3379/4", + "42777/32", + "1701/2", + "4883/4" + ], + [ + "2013/4", + "28759/16", + "1139/2", + "5629/4" + ], + [ + "3045/4", + "19755/16", + "1593/2", + "4785/4" + ], + [ + "527", + "3181/4", + "465", + "1011/2" + ], + [ + "2271/4", + "34181/32", + "1275/2", + "3925/4" + ], + [ + "959/2", + "16591/16", + "553", + "4125/4" + ], + [ + "594", + "879", + "639", + "851" + ], + [ + "591", + "11585/8", + "631", + "1179" + ], + [ + "6747/16", + "6899/8", + "1757/4", + "612" + ], + [ + "643", + "11779/8", + "694", + "1232" + ], + [ + "1213/2", + "21507/16", + "625", + "4361/4" + ], + [ + "2449/4", + "6933/8", + "1329/2", + "865" + ], + [ + "2085/4", + "4527/8", + "927/2", + "360" + ], + [ + "601/2", + "3613/8", + "324", + "453" + ], + [ + "743/2", + "9857/16", + "408", + "2439/4" + ], + [ + "5951/16", + "1125/2", + "1837/4", + "558" + ], + [ + "2385/4", + "10225/16", + "1109/2", + "2275/4" + ], + [ + "903/2", + "8765/16", + "459", + "2057/4" + ], + [ + "650", + "29335/32", + "667", + "881" + ], + [ + "1781/4", + "14381/16", + "937/2", + "3267/4" + ], + [ + "3259/4", + "19897/16", + "1645/2", + "4745/4" + ], + [ + "809", + "14431/8", + "789", + "2673/2" + ], + [ + "3889/4", + "11063/8", + "1787/2", + "2485/2" + ], + [ + "1879/4", + "27361/32", + "1045/2", + "3217/4" + ], + [ + "1225/2", + "1735/2", + "621", + "817" + ], + [ + "2463/4", + "1771/2", + "1291/2", + "858" + ], + [ + "519", + "13173/16", + "569", + "3329/4" + ], + [ + "1155/4", + "1955/4", + "643/2", + "955/2" + ], + [ + "4249/16", + "1359/4", + "1307/4", + "356" + ], + [ + "764", + "8175/8", + "753", + "933" + ], + [ + "731/2", + "9347/16", + "406", + "2379/4" + ], + [ + "1185/2", + "3751/4", + "591", + "869" + ], + [ + "1343/2", + "7751/8", + "693", + "904" + ], + [ + "4499/16", + "4809/16", + "1291/4", + "1199/4" + ], + [ + "301", + "1981/4", + "325", + "945/2" + ], + [ + "1641/2", + "23815/16", + "829", + "4981/4" + ], + [ + "3825/4", + "6247/4", + "1809/2", + "1271" + ], + [ + "1019/2", + "56803/32", + "558", + "2751/2" + ], + [ + "2433/4", + "43375/32", + "1271/2", + "1098" + ], + [ + "1507/2", + "32309/32", + "768", + "3797/4" + ], + [ + "1593/2", + "14625/16", + "720", + "3071/4" + ], + [ + "571", + "6619/8", + "577", + "1061/2" + ], + [ + "511", + "27779/32", + "560", + "860" + ], + [ + "1155/4", + "1891/4", + "643/2", + "468" + ], + [ + "1873/4", + "4475/8", + "919/2", + "711/2" + ], + [ + "2463/4", + "47201/32", + "1273/2", + "4807/4" + ], + [ + "1569/2", + "24263/16", + "835", + "5183/4" + ], + [ + "3461/4", + "6437/4", + "1755/2", + "2629/2" + ], + [ + "1823/4", + "2047/4", + "907/2", + "1009/2" + ], + [ + "645", + "10471/16", + "548", + "2187/4" + ], + [ + "2901/4", + "16239/16", + "1475/2", + "3721/4" + ], + [ + "3263/4", + "30927/16", + "1559/2", + "5949/4" + ], + [ + "1275/2", + "8883/8", + "682", + "1098" + ], + [ + "3193/4", + "7729/8", + "1479/2", + "877" + ], + [ + "602", + "29481/32", + "619", + "3457/4" + ], + [ + "1757/8", + "6737/16", + "298", + "1765/4" + ], + [ + "644", + "4007/4", + "663", + "957" + ], + [ + "1851/4", + "31039/32", + "1077/2", + "984" + ], + [ + "2469/4", + "14695/16", + "1263/2", + "3445/4" + ], + [ + "991/2", + "13335/16", + "541", + "3241/4" + ], + [ + "1919/2", + "21891/16", + "906", + "5025/4" + ], + [ + "1555/2", + "21325/16", + "827", + "4619/4" + ], + [ + "589", + "6945/8", + "621", + "1703/2" + ], + [ + "2673/4", + "7933/8", + "1399/2", + "900" + ], + [ + "1163/2", + "6977/8", + "631", + "1653/2" + ], + [ + "2859/4", + "38863/32", + "1483/2", + "2225/2" + ], + [ + "2587/4", + "13711/16", + "1147/2", + "2937/4" + ], + [ + "459", + "11813/16", + "519", + "2993/4" + ], + [ + "2243/4", + "13893/16", + "1197/2", + "3257/4" + ], + [ + "755", + "18781/16", + "779", + "4557/4" + ], + [ + "332", + "8833/8", + "401", + "1793/2" + ], + [ + "510", + "12915/16", + "561", + "3185/4" + ], + [ + "715", + "42755/32", + "732", + "2159/2" + ], + [ + "280", + "9037/16", + "319", + "2217/4" + ], + [ + "1693/2", + "10147/8", + "850", + "2385/2" + ], + [ + "2471/4", + "14631/8", + "1381/2", + "1579" + ], + [ + "2985/4", + "18867/16", + "1549/2", + "4589/4" + ], + [ + "2275/4", + "25971/32", + "1207/2", + "1567/2" + ], + [ + "673", + "29983/32", + "690", + "1733/2" + ], + [ + "1237/2", + "28571/32", + "686", + "1817/2" + ], + [ + "3255/4", + "19749/16", + "1655/2", + "4715/4" + ], + [ + "2721/4", + "28481/16", + "1429/2", + "6195/4" + ], + [ + "629", + "4509/4", + "683", + "1105" + ], + [ + "1023/4", + "8629/16", + "605/2", + "2187/4" + ], + [ + "1589/2", + "20359/16", + "749", + "4539/4" + ], + [ + "2285/4", + "26433/32", + "1237/2", + "3211/4" + ], + [ + "1383/2", + "3783/2", + "722", + "1610" + ], + [ + "5273/8", + "1917/4", + "1067/2", + "397" + ], + [ + "286", + "8915/16", + "324", + "2247/4" + ], + [ + "874", + "20605/16", + "878", + "4949/4" + ], + [ + "3093/4", + "15579/16", + "1471/2", + "3545/4" + ], + [ + "596", + "14311/16", + "629", + "3449/4" + ], + [ + "2503/4", + "15823/16", + "1351/2", + "3687/4" + ], + [ + "1961/4", + "20207/16", + "1095/2", + "4061/4" + ], + [ + "3103/4", + "15483/16", + "1507/2", + "3661/4" + ], + [ + "503/2", + "6581/16", + "300", + "1697/4" + ], + [ + "470", + "4917/8", + "470", + "555" + ], + [ + "1059/2", + "13283/16", + "575", + "3231/4" + ], + [ + "3207/4", + "30545/16", + "1509/2", + "5823/4" + ], + [ + "1811/2", + "13127/8", + "890", + "2595/2" + ], + [ + "3193/4", + "24147/16", + "1629/2", + "5039/4" + ], + [ + "2597/4", + "14083/16", + "1339/2", + "3439/4" + ], + [ + "1819/4", + "9127/16", + "921/2", + "2111/4" + ], + [ + "1073/4", + "7105/16", + "625/2", + "1819/4" + ], + [ + "642", + "7715/8", + "601", + "1773/2" + ], + [ + "363", + "9619/16", + "404", + "2375/4" + ], + [ + "297/8", + "14", + "63/2", + "14" + ], + [ + "19/4", + "21/2", + "11/2", + "12" + ], + [ + "601/8", + "35/2", + "131/2", + "17" + ], + [ + "57", + "81/2", + "54", + "44" + ], + [ + "619/8", + "71/4", + "75", + "35/2" + ], + [ + "159/2", + "63/2", + "78", + "65/2" + ], + [ + "739/8", + "215/4", + "129/2", + "79/2" + ], + [ + "111", + "79/2", + "153/2", + "61/2" + ], + [ + "143/4", + "25", + "46", + "24" + ], + [ + "169/4", + "193/4", + "47", + "75/2" + ], + [ + "353/8", + "39/2", + "85/2", + "17" + ], + [ + "87/4", + "413/16", + "29", + "99/4" + ], + [ + "497/8", + "123/4", + "109/2", + "24" + ], + [ + "48", + "221/4", + "91/2", + "79/2" + ], + [ + "269/8", + "45/4", + "81/2", + "14" + ], + [ + "223/8", + "49/4", + "35", + "25/2" + ], + [ + "29", + "7", + "33", + "7" + ], + [ + "295/16", + "49/4", + "99/4", + "25/2" + ], + [ + "789/8", + "259/4", + "165/2", + "113/2" + ], + [ + "1067/16", + "69/2", + "229/4", + "26" + ], + [ + "281/8", + "27", + "91/2", + "27" + ], + [ + "449/16", + "193/4", + "135/4", + "73/2" + ], + [ + "289/8", + "33", + "95/2", + "35" + ], + [ + "1475/16", + "767/8", + "345/4", + "85" + ], + [ + "81/2", + "38", + "107/2", + "34" + ], + [ + "667/8", + "105/2", + "78", + "46" + ], + [ + "221/8", + "555/16", + "77/2", + "38" + ], + [ + "169/8", + "8", + "53/2", + "8" + ], + [ + "1379/16", + "159/2", + "329/4", + "69" + ], + [ + "489/16", + "85/4", + "155/4", + "43/2" + ], + [ + "735/16", + "153/4", + "207/4", + "53/2" + ], + [ + "625/16", + "30", + "179/4", + "32" + ], + [ + "123/8", + "103/4", + "24", + "53/2" + ], + [ + "69/4", + "81/4", + "45/2", + "41/2" + ], + [ + "269/8", + "49", + "93/2", + "47" + ], + [ + "70", + "32", + "24", + "12" + ], + [ + "479/8", + "1509/64", + "61", + "199/8" + ], + [ + "69/2", + "601/16", + "44", + "159/4" + ], + [ + "241/8", + "45", + "77/2", + "89/2" + ], + [ + "467/8", + "1119/16", + "61", + "287/4" + ], + [ + "247/4", + "2697/64", + "68", + "353/8" + ], + [ + "275/8", + "79/2", + "50", + "42" + ], + [ + "221/8", + "181/4", + "77/2", + "47" + ], + [ + "169/8", + "17/2", + "53/2", + "9" + ], + [ + "221/4", + "859/16", + "117/2", + "229/4" + ], + [ + "115/4", + "107/4", + "73/2", + "53/2" + ], + [ + "131/4", + "585/16", + "91/2", + "155/4" + ], + [ + "223/8", + "213/4", + "81/2", + "113/2" + ], + [ + "245/8", + "123/4", + "43", + "67/2" + ], + [ + "22", + "31", + "18", + "21" + ], + [ + "119/4", + "26", + "41", + "27" + ], + [ + "17/2", + "43/4", + "11", + "25/2" + ], + [ + "483/16", + "149/4", + "161/4", + "71/2" + ], + [ + "22", + "9", + "18", + "5" + ], + [ + "505/16", + "83/2", + "141/4", + "31" + ], + [ + "32", + "71/4", + "89/2", + "37/2" + ], + [ + "87/4", + "35/2", + "33", + "20" + ], + [ + "147/8", + "41/2", + "65/2", + "24" + ], + [ + "11/2", + "4", + "9", + "5" + ], + [ + "27/2", + "15/2", + "49/2", + "9" + ], + [ + "391/16", + "31", + "165/4", + "32" + ], + [ + "347/16", + "73/4", + "137/4", + "43/2" + ], + [ + "495/16", + "30", + "167/4", + "28" + ], + [ + "363/16", + "17", + "125/4", + "19" + ], + [ + "129/4", + "333/16", + "43", + "95/4" + ], + [ + "24", + "89/4", + "20", + "33/2" + ], + [ + "251/8", + "73/4", + "41", + "37/2" + ], + [ + "19/4", + "4", + "11/2", + "4" + ], + [ + "259/8", + "369/16", + "42", + "101/4" + ], + [ + "20", + "6", + "16", + "4" + ], + [ + "255/8", + "67/2", + "73/2", + "33" + ], + [ + "71/2", + "75/4", + "93/2", + "39/2" + ], + [ + "97/4", + "313/16", + "34", + "89/4" + ], + [ + "17", + "277/16", + "59/2", + "79/4" + ], + [ + "11/2", + "9/2", + "9", + "5" + ], + [ + "97/8", + "15/2", + "43/2", + "8" + ], + [ + "91/4", + "75/4", + "37", + "41/2" + ], + [ + "155/8", + "191/4", + "30", + "95/2" + ], + [ + "267/8", + "341/16", + "42", + "93/4" + ], + [ + "205/8", + "249/16", + "63/2", + "77/4" + ], + [ + "445/16", + "107/4", + "159/4", + "61/2" + ], + [ + "22", + "16", + "18", + "12" + ], + [ + "1463/8", + "1385/16", + "92", + "225/4" + ], + [ + "17/2", + "15", + "11", + "15" + ], + [ + "1123/16", + "48", + "253/4", + "45" + ], + [ + "21", + "24", + "17", + "14" + ], + [ + "293/4", + "213/4", + "60", + "95/2" + ], + [ + "214", + "68", + "78", + "18" + ], + [ + "165/8", + "69/4", + "61/2", + "37/2" + ], + [ + "281/16", + "25/2", + "125/4", + "16" + ], + [ + "11/2", + "9/2", + "9", + "5" + ], + [ + "207/16", + "9", + "91/4", + "11" + ], + [ + "1049/16", + "40", + "257/4", + "40" + ], + [ + "379/16", + "529/16", + "141/4", + "149/4" + ], + [ + "581/8", + "151/4", + "131/2", + "69/2" + ], + [ + "359/16", + "17", + "123/4", + "20" + ], + [ + "119/4", + "83/4", + "40", + "47/2" + ], + [ + "19", + "31", + "11", + "17" + ], + [ + "155/4", + "49/4", + "93/2", + "27/2" + ], + [ + "17/2", + "31/4", + "11", + "21/2" + ], + [ + "323/8", + "19", + "49", + "21" + ], + [ + "25", + "8", + "19", + "4" + ], + [ + "169/4", + "109/4", + "45", + "27" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "157/8", + "11", + "57/2", + "27/2" + ], + [ + "137/8", + "49/4", + "57/2", + "29/2" + ], + [ + "11/2", + "13/4", + "9", + "9/2" + ], + [ + "105/8", + "29/4", + "45/2", + "17/2" + ], + [ + "273/8", + "45/4", + "93/2", + "27/2" + ], + [ + "253/8", + "63/4", + "83/2", + "19" + ], + [ + "331/8", + "35/2", + "49", + "20" + ], + [ + "181/8", + "35/2", + "57/2", + "21" + ], + [ + "253/8", + "117/2", + "85/2", + "51" + ], + [ + "22", + "22", + "18", + "16" + ], + [ + "397/8", + "30", + "51", + "26" + ], + [ + "21/2", + "11", + "13", + "13" + ], + [ + "465/16", + "181/8", + "153/4", + "53/2" + ], + [ + "74", + "44", + "26", + "14" + ], + [ + "53", + "319/8", + "49", + "41" + ], + [ + "1077/8", + "301/2", + "203/2", + "98" + ], + [ + "735/16", + "81/2", + "233/4", + "42" + ], + [ + "2", + "0", + "2", + "0" + ], + [ + "11/2", + "13/2", + "9", + "9" + ], + [ + "12", + "12", + "35/2", + "14" + ], + [ + "229/4", + "1047/8", + "121/2", + "84" + ], + [ + "28", + "77/2", + "73/2", + "40" + ], + [ + "557/16", + "323/8", + "201/4", + "47" + ], + [ + "243/8", + "189/4", + "89/2", + "83/2" + ], + [ + "55/2", + "85/4", + "75/2", + "45/2" + ], + [ + "22", + "12", + "18", + "10" + ], + [ + "28", + "31/2", + "75/2", + "16" + ], + [ + "17/2", + "17/2", + "11", + "10" + ], + [ + "115/4", + "15", + "38", + "16" + ], + [ + "22", + "6", + "18", + "4" + ], + [ + "63/2", + "107/4", + "36", + "53/2" + ], + [ + "255/8", + "91/4", + "87/2", + "47/2" + ], + [ + "21", + "15", + "63/2", + "18" + ], + [ + "69/4", + "55/4", + "30", + "33/2" + ], + [ + "21/4", + "21/4", + "17/2", + "11/2" + ], + [ + "99/8", + "31/4", + "22", + "17/2" + ], + [ + "181/8", + "37/2", + "37", + "21" + ], + [ + "77/4", + "269/8", + "30", + "79/2" + ], + [ + "59/2", + "83/4", + "77/2", + "45/2" + ], + [ + "173/8", + "13", + "57/2", + "15" + ], + [ + "493/16", + "99/4", + "171/4", + "55/2" + ], + [ + "38", + "29", + "20", + "15" + ], + [ + "88", + "71/2", + "123/2", + "35" + ], + [ + "17/2", + "17/2", + "11", + "10" + ], + [ + "1389/16", + "865/16", + "255/4", + "199/4" + ], + [ + "22", + "12", + "18", + "6" + ], + [ + "737/16", + "303/8", + "173/4", + "37" + ], + [ + "58", + "22", + "113/2", + "21" + ], + [ + "165/8", + "177/16", + "61/2", + "49/4" + ], + [ + "35/2", + "149/16", + "61/2", + "43/4" + ], + [ + "11/2", + "4", + "9", + "4" + ], + [ + "27/2", + "17/2", + "49/2", + "9" + ], + [ + "623/16", + "225/8", + "197/4", + "59/2" + ], + [ + "377/16", + "405/16", + "141/4", + "107/4" + ], + [ + "869/16", + "561/16", + "223/4", + "145/4" + ], + [ + "359/16", + "18", + "123/4", + "20" + ], + [ + "121/4", + "45", + "40", + "28" + ], + [ + "22", + "17", + "18", + "15" + ], + [ + "249/8", + "193/16", + "77/2", + "53/4" + ], + [ + "17/2", + "13", + "11", + "16" + ], + [ + "131/4", + "41/2", + "41", + "21" + ], + [ + "22", + "22", + "18", + "8" + ], + [ + "263/8", + "397/8", + "71/2", + "69/2" + ], + [ + "141/4", + "265/16", + "45", + "73/4" + ], + [ + "177/8", + "22", + "63/2", + "22" + ], + [ + "133/8", + "24", + "57/2", + "23" + ], + [ + "11/2", + "12", + "9", + "6" + ], + [ + "101/8", + "35/4", + "45/2", + "19/2" + ], + [ + "97/4", + "23/2", + "37", + "14" + ], + [ + "87/4", + "89/4", + "32", + "43/2" + ], + [ + "135/4", + "20", + "42", + "21" + ], + [ + "189/8", + "31/2", + "61/2", + "19" + ], + [ + "2205/16", + "49/2", + "393/4", + "17" + ], + [ + "613/16", + "21/2", + "137/4", + "9" + ], + [ + "1035/16", + "221/8", + "245/4", + "53/2" + ], + [ + "895/16", + "177/8", + "217/4", + "23" + ], + [ + "95/4", + "17/4", + "55/2", + "9/2" + ], + [ + "19/4", + "2", + "11/2", + "2" + ], + [ + "791/16", + "137/8", + "195/4", + "33/2" + ], + [ + "461/8", + "183/8", + "117/2", + "22" + ], + [ + "61", + "22", + "76", + "23" + ], + [ + "1115/16", + "257/8", + "333/4", + "63/2" + ], + [ + "711/16", + "153/8", + "175/4", + "37/2" + ], + [ + "333/16", + "7", + "101/4", + "7" + ], + [ + "411/8", + "131/8", + "51", + "15" + ], + [ + "101/2", + "31/2", + "48", + "14" + ], + [ + "119/2", + "63/4", + "67", + "33/2" + ], + [ + "1095/16", + "199/8", + "315/4", + "26" + ], + [ + "51/2", + "25/2", + "29", + "13" + ], + [ + "239/16", + "133/16", + "75/4", + "35/4" + ], + [ + "699/16", + "545/16", + "173/4", + "101/4" + ], + [ + "695/16", + "33", + "171/4", + "24" + ], + [ + "115/4", + "7", + "71/2", + "7" + ], + [ + "223/8", + "161/16", + "35", + "41/4" + ], + [ + "221/8", + "265/16", + "69/2", + "69/4" + ], + [ + "563/16", + "71/4", + "177/4", + "37/2" + ], + [ + "545/16", + "65/4", + "167/4", + "29/2" + ], + [ + "227/8", + "237/16", + "37", + "63/4" + ], + [ + "367/16", + "421/16", + "123/4", + "91/4" + ], + [ + "333/16", + "65/4", + "101/4", + "25/2" + ], + [ + "229/8", + "37/4", + "71/2", + "19/2" + ], + [ + "217/8", + "233/16", + "65/2", + "53/4" + ], + [ + "531/16", + "333/16", + "165/4", + "87/4" + ], + [ + "215/8", + "45/2", + "34", + "17" + ], + [ + "19/4", + "13", + "11/2", + "9" + ], + [ + "125/8", + "227/16", + "37/2", + "63/4" + ], + [ + "1175/8", + "343/4", + "106", + "119/2" + ], + [ + "299/2", + "611/8", + "213/2", + "53" + ], + [ + "139/4", + "8", + "81/2", + "8" + ], + [ + "291/8", + "305/8", + "45", + "57/2" + ], + [ + "911/8", + "969/16", + "72", + "149/4" + ], + [ + "201/2", + "465/8", + "141/2", + "77/2" + ], + [ + "679/16", + "793/16", + "201/4", + "159/4" + ], + [ + "587/16", + "265/16", + "179/4", + "67/4" + ], + [ + "1311/16", + "125/4", + "285/4", + "65/2" + ], + [ + "995/16", + "449/16", + "215/4", + "105/4" + ], + [ + "727/16", + "411/16", + "229/4", + "105/4" + ], + [ + "723/16", + "313/8", + "217/4", + "77/2" + ], + [ + "915/16", + "259/16", + "229/4", + "67/4" + ], + [ + "823/16", + "303/16", + "207/4", + "81/4" + ], + [ + "205", + "0", + "61", + "0" + ], + [ + "142", + "0", + "46", + "0" + ], + [ + "142", + "32", + "46", + "8" + ], + [ + "94", + "32", + "34", + "8" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "7", + "0", + "7", + "0" + ], + [ + "521/2", + "118", + "112", + "42" + ], + [ + "521/2", + "113", + "112", + "39" + ], + [ + "123/2", + "57/4", + "49", + "21/2" + ], + [ + "123/2", + "61/4", + "49", + "23/2" + ], + [ + "165/8", + "69/4", + "53/2", + "35/2" + ], + [ + "165/8", + "61/4", + "53/2", + "31/2" + ], + [ + "165/8", + "45/4", + "53/2", + "23/2" + ], + [ + "165/8", + "57/4", + "53/2", + "25/2" + ], + [ + "123/2", + "141/4", + "49", + "39/2" + ], + [ + "123/2", + "12", + "49", + "8" + ], + [ + "123/2", + "12", + "49", + "8" + ], + [ + "123/2", + "28", + "49", + "12" + ], + [ + "157/8", + "61/4", + "51/2", + "31/2" + ], + [ + "413/8", + "61/4", + "83/2", + "27/2" + ], + [ + "157/8", + "71/4", + "51/2", + "33/2" + ], + [ + "503/8", + "67/2", + "46", + "26" + ], + [ + "139/2", + "40", + "34", + "14" + ], + [ + "43/2", + "2", + "22", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "237/8", + "10", + "65/2", + "10" + ], + [ + "237/8", + "10", + "65/2", + "10" + ], + [ + "237/8", + "12", + "65/2", + "12" + ], + [ + "237/8", + "27/2", + "65/2", + "14" + ], + [ + "29", + "5", + "31", + "5" + ], + [ + "115/4", + "7", + "61/2", + "7" + ], + [ + "123", + "32", + "51", + "8" + ], + [ + "17", + "0", + "17", + "0" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "485/8", + "18", + "95/2", + "14" + ], + [ + "485/8", + "19", + "95/2", + "15" + ], + [ + "237/8", + "10", + "65/2", + "10" + ], + [ + "237/8", + "11", + "65/2", + "11" + ], + [ + "65/2", + "10", + "33", + "10" + ], + [ + "65/2", + "3", + "33", + "3" + ], + [ + "297/2", + "34", + "53", + "10" + ], + [ + "139/2", + "34", + "34", + "10" + ], + [ + "214", + "72", + "78", + "20" + ], + [ + "3005/16", + "139/2", + "389/4", + "41" + ], + [ + "15", + "4", + "15", + "2" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "1553/8", + "52", + "179/2", + "22" + ], + [ + "273/8", + "6", + "71/2", + "6" + ], + [ + "641/8", + "14", + "119/2", + "10" + ], + [ + "641/8", + "33/2", + "119/2", + "13" + ], + [ + "68", + "10", + "36", + "6" + ], + [ + "28", + "6", + "30", + "6" + ], + [ + "17", + "0", + "17", + "0" + ], + [ + "18", + "0", + "18", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "343/8", + "17", + "52", + "19" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "393/8", + "6", + "89/2", + "6" + ], + [ + "393/8", + "6", + "89/2", + "6" + ], + [ + "393/8", + "6", + "89/2", + "6" + ], + [ + "393/8", + "6", + "89/2", + "6" + ], + [ + "37/2", + "4", + "19", + "4" + ], + [ + "55/2", + "4", + "28", + "4" + ], + [ + "61/2", + "2", + "25", + "2" + ], + [ + "61/2", + "2", + "25", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "127/2", + "50", + "28", + "14" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "26", + "5", + "27", + "5" + ], + [ + "59/4", + "2", + "31/2", + "2" + ], + [ + "63", + "0", + "39", + "0" + ], + [ + "21", + "0", + "17", + "0" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "37/2", + "2", + "19", + "2" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "127/8", + "4", + "17", + "4" + ], + [ + "55/2", + "8", + "28", + "8" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "61/2", + "2", + "25", + "2" + ], + [ + "61/2", + "2", + "25", + "2" + ], + [ + "1102", + "429", + "272", + "95" + ], + [ + "1102", + "462", + "272", + "108" + ], + [ + "975", + "377", + "241", + "71" + ], + [ + "1102", + "807/2", + "272", + "80" + ], + [ + "145/8", + "2", + "37/2", + "2" + ], + [ + "145/8", + "2", + "37/2", + "2" + ], + [ + "145/8", + "2", + "37/2", + "2" + ], + [ + "145/8", + "2", + "37/2", + "2" + ], + [ + "63/4", + "3", + "33/2", + "3" + ], + [ + "27/2", + "2", + "14", + "2" + ], + [ + "21", + "0", + "17", + "0" + ], + [ + "6", + "0", + "6", + "0" + ], + [ + "3782", + "1512", + "452", + "132" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "187", + "0", + "91", + "0" + ], + [ + "142", + "16", + "46", + "4" + ], + [ + "145/8", + "2", + "37/2", + "2" + ], + [ + "145/8", + "9/4", + "37/2", + "5/2" + ], + [ + "145/8", + "6", + "37/2", + "6" + ], + [ + "145/8", + "25/8", + "37/2", + "7/2" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "3722", + "9077/4", + "422", + "495/2" + ], + [ + "930", + "578", + "196", + "118" + ], + [ + "3722", + "1470", + "422", + "146" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "160", + "44", + "60", + "14" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "930", + "352", + "196", + "56" + ], + [ + "930", + "360", + "196", + "60" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "46", + "8", + "30", + "4" + ], + [ + "46", + "8", + "30", + "4" + ], + [ + "15", + "0", + "15", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "12", + "0", + "12", + "0" + ], + [ + "142", + "0", + "46", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "13", + "0", + "13", + "0" + ], + [ + "31", + "8", + "33", + "8" + ], + [ + "41", + "85/4", + "37", + "35/2" + ], + [ + "67", + "20", + "47", + "10" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "63/2", + "69/4", + "35", + "35/2" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "8", + "8", + "9", + "8" + ], + [ + "43", + "17", + "37", + "13" + ], + [ + "31", + "8", + "33", + "8" + ], + [ + "37", + "16", + "41", + "16" + ], + [ + "8", + "6", + "9", + "6" + ], + [ + "37", + "21", + "41", + "21" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "5", + "9", + "5" + ], + [ + "169/4", + "91/4", + "73/2", + "39/2" + ], + [ + "121/4", + "59/4", + "65/2", + "29/2" + ], + [ + "145/4", + "39/2", + "81/2", + "20" + ], + [ + "29/4", + "29/4", + "17/2", + "15/2" + ], + [ + "145/4", + "83/4", + "81/2", + "43/2" + ], + [ + "8", + "13/2", + "9", + "7" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "133", + "106", + "59", + "38" + ], + [ + "73", + "27", + "47", + "15" + ], + [ + "103", + "68", + "63", + "38" + ], + [ + "20", + "13", + "13", + "7" + ], + [ + "34", + "20", + "37", + "20" + ], + [ + "29/4", + "5", + "8", + "5" + ], + [ + "29/4", + "5", + "8", + "5" + ], + [ + "29/4", + "4", + "8", + "4" + ], + [ + "5", + "0", + "5", + "0" + ], + [ + "288", + "116", + "96", + "30" + ], + [ + "138", + "88", + "64", + "30" + ], + [ + "20", + "10", + "13", + "6" + ], + [ + "701/4", + "333/4", + "161/2", + "75/2" + ], + [ + "29/4", + "17/4", + "8", + "9/2" + ], + [ + "93/4", + "16", + "16", + "12" + ], + [ + "29/4", + "5", + "8", + "5" + ], + [ + "133", + "58", + "59", + "22" + ], + [ + "73", + "23", + "47", + "13" + ], + [ + "103", + "103/2", + "63", + "30" + ], + [ + "20", + "10", + "13", + "6" + ], + [ + "34", + "37/2", + "37", + "19" + ], + [ + "29/4", + "4", + "8", + "4" + ], + [ + "29/4", + "4", + "8", + "4" + ], + [ + "29/4", + "4", + "8", + "4" + ], + [ + "133", + "285/4", + "59", + "59/2" + ], + [ + "73", + "137/4", + "47", + "37/2" + ], + [ + "103", + "201/4", + "63", + "57/2" + ], + [ + "20", + "10", + "13", + "6" + ], + [ + "34", + "69/4", + "37", + "35/2" + ], + [ + "29/4", + "97/16", + "8", + "25/4" + ], + [ + "29/4", + "4", + "8", + "4" + ], + [ + "29/4", + "17/4", + "8", + "9/2" + ], + [ + "32", + "8", + "34", + "8" + ], + [ + "85", + "28", + "63", + "18" + ], + [ + "70", + "48", + "48", + "28" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "125/4", + "16", + "69/2", + "16" + ], + [ + "8", + "6", + "9", + "6" + ], + [ + "15/2", + "2", + "8", + "2" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "43", + "21", + "37", + "17" + ], + [ + "31", + "13", + "33", + "13" + ], + [ + "37", + "81/4", + "41", + "41/2" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "37", + "101/4", + "41", + "51/2" + ], + [ + "8", + "33/4", + "9", + "17/2" + ], + [ + "8", + "5", + "9", + "5" + ], + [ + "8", + "6", + "9", + "6" + ], + [ + "115", + "62", + "69", + "32" + ], + [ + "41", + "73/4", + "37", + "29/2" + ], + [ + "67", + "20", + "47", + "12" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "63/2", + "89/4", + "35", + "47/2" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "21/4", + "9", + "11/2" + ], + [ + "31/4", + "25/4", + "17/2", + "13/2" + ], + [ + "43", + "79/4", + "37", + "33/2" + ], + [ + "31", + "53/4", + "33", + "23/2" + ], + [ + "37", + "65/4", + "41", + "33/2" + ], + [ + "8", + "13/2", + "9", + "7" + ], + [ + "37", + "93/4", + "41", + "49/2" + ], + [ + "8", + "21/4", + "9", + "11/2" + ], + [ + "8", + "5", + "9", + "5" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "31", + "181/16", + "33", + "47/4" + ], + [ + "41", + "20", + "37", + "14" + ], + [ + "67", + "44", + "47", + "24" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "63/2", + "77/4", + "35", + "39/2" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "31/4", + "4", + "17/2", + "4" + ], + [ + "8", + "29/4", + "9", + "15/2" + ], + [ + "169/4", + "20", + "73/2", + "16" + ], + [ + "121/4", + "14", + "65/2", + "14" + ], + [ + "145/4", + "95/4", + "81/2", + "49/2" + ], + [ + "29/4", + "6", + "17/2", + "6" + ], + [ + "145/4", + "357/16", + "81/2", + "91/4" + ], + [ + "8", + "6", + "9", + "6" + ], + [ + "8", + "31/4", + "9", + "17/2" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "205/4", + "22", + "91/2", + "16" + ], + [ + "5", + "0", + "5", + "0" + ], + [ + "74", + "24", + "58", + "12" + ], + [ + "8", + "8", + "9", + "8" + ], + [ + "48", + "21", + "42", + "15" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "4", + "9", + "4" + ], + [ + "8", + "23", + "15", + "25" + ], + [ + "31/2", + "2", + "16", + "2" + ], + [ + "31/2", + "2", + "16", + "2" + ], + [ + "13", + "2", + "13", + "2" + ], + [ + "13", + "2", + "13", + "2" + ], + [ + "18", + "2", + "18", + "2" + ], + [ + "1/2", + "2", + "1", + "2" + ], + [ + "193/4", + "155/4", + "119/2", + "81/2" + ], + [ + "5", + "0", + "5", + "0" + ], + [ + "591/64", + "127/8", + "181/8", + "21" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "2", + "2", + "2", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "29/4", + "5", + "8", + "5" + ], + [ + "87/16", + "65/8", + "21/2", + "17/2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "3", + "2", + "3", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "1/8", + "49/16", + "1/2", + "13/4" + ], + [ + "3", + "2", + "3", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "333/64", + "589/64", + "79/8", + "79/8" + ], + [ + "3", + "2", + "3", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "97/16", + "2", + "25/4", + "2" + ], + [ + "13", + "2", + "13", + "2" + ], + [ + "205/4", + "4089/64", + "95/2", + "529/8" + ], + [ + "175/4", + "26", + "103/2", + "27" + ], + [ + "61/2", + "32", + "26", + "25" + ], + [ + "45/2", + "75/8", + "35/2", + "8" + ], + [ + "799/128", + "705/64", + "8", + "89/8" + ], + [ + "493/4", + "21/4", + "87/2", + "11/2" + ], + [ + "127", + "4", + "46", + "4" + ], + [ + "253/2", + "4", + "45", + "4" + ], + [ + "34", + "6", + "26", + "6" + ], + [ + "125/8", + "49/8", + "20", + "7" + ], + [ + "65/8", + "14", + "15", + "14" + ], + [ + "7", + "0", + "7", + "0" + ], + [ + "5/2", + "2", + "3", + "2" + ], + [ + "5/2", + "2", + "3", + "2" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "1", + "0", + "1", + "0" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "1", + "9/4", + "1", + "5/2" + ], + [ + "5", + "2", + "5", + "2" + ], + [ + "5", + "2", + "5", + "2" + ], + [ + "5", + "0", + "5", + "0" + ], + [ + "1", + "9/4", + "1", + "5/2" + ], + [ + "1", + "0", + "1", + "0" + ], + [ + "1", + "4", + "1", + "4" + ], + [ + "1", + "0", + "1", + "0" + ], + [ + "1", + "2", + "1", + "2" + ], + [ + "5", + "2", + "5", + "2" + ], + [ + "26", + "0", + "20", + "0" + ], + [ + "14", + "0", + "14", + "0" + ], + [ + "187/4", + "18", + "101/2", + "16" + ], + [ + "3", + "0", + "3", + "0" + ], + [ + "1", + "0", + "1", + "0" + ], + [ + "45/2", + "51/2", + "30", + "27" + ], + [ + "192", + "133", + "70", + "49" + ], + [ + "2", + "0", + "2", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0" + ] + ], + "final_coefficient_sha256": [ + "b60ec2f95301ea3dda5dabd41bfc3c38df6374b4643fc0573fd67d4a50b61b2a", + "73845d81e8abb31e5c884f7d307e516052e10a2440bc5f4991d5a7205e7cfbba", + "d3834c8cd943610fa26925e40ec1dd2c8031110835e9480396b2d736a0172d0b", + "57d391f63db52dc8148451a832f34979c7c4e3961c63a2bc05eaa40ad93f123c", + "850931f88518df4b787f95b28904d96aef793d615c604561fd2d2ddf050afd49", + "2e4f499438005c07ff00c6b8f44f57370e3078e3063a51ea829323009b8128ac", + "28f94061f0985b756a591534f45456f98196bf943d45ec3039964844caade01a", + "d2db43193f1ebcd35ab2cf7d5c4f755e5a802c16368b80e38ddb8facb029fd92", + "cd47f4d8f5265e57768a93c6fa65bd19c235005e1012c67402bdef1161564943", + "af6c316208c8d9ce988c0de1756e69f0750065a32e826a543b151afa4e4fae30", + "3c6ea713e4968fcc96cb94a85524d246befb834d88ca319a2838f76090902b60", + "98262ab8eaaaf13aaed2bc9fcb1d2b20ab731401cb63986c1f1222298b9df08f", + "cd5ff38b604c3f4fd7405b5f797af15d500e3fc777b3bae844650fd7564fd8f7", + "29180a86253c2cf3cbd2c08d7dcccae2de0e2aca99f4f567ef853dc937efea83", + "8f6e968efaa420ea2eda20e97c0dc52d4b5ad172e913ba220660a81ba89b481e", + "f80a723aed47a6fc1657afc66a3fc1de6e6a3ebebbbfd473ba88ec9dcf3687e1", + "d7b1c472e2572fb70ee82211cf0953e3bb9e1e4573ce4f36e4f367b861e73f95", + "4de446d30423e03156b0b614b4a1ba307e88ddc0065b272653d3c07714f94318", + "b5db9af0a77712206e2e32d5a412aa7417a6f15d7e23546959666a2ad727af84", + "2a8e43608b741400c7d1f8fd1abb70ab5dd3b560d9894b3fbe8abf5e460c4b80", + "297808e0e8171ce5e246d7a16c2c613b4e568868dcd7a78d03ce4de986296383", + "b81df1a9a752817d409d5f721ae4fecdb52c65e7eab5dc9b89ea3bc4eed2d7cd", + "74be71b6b30383309b4a7f65234e38faff6ffacd6c45f3882b86374aed431534", + "89207c2955a7668b2b21f253d5ec0cf675454dc9872a6e2e2eab3109cd76c127", + "73c4fbbec0057063eb7cf2d876ccb432930fe283600848efd33e4cb5d2777829", + "b86ca4062989fc7bc5c32f02dcbb08a53b1a84ec12ae6ed494ab1f8af256126f", + "462d2c6a38745a46c8592e06ea3c2eada99d553958140992a7ee78ff479742ff", + "d402ab7b41ebc3118bd15bb7bc6e2ccf3a7bc69a26b782bf72e7cb53a265aac7", + "62fdeedbad1251bd885ccfeb0cc60e12687912ab6c37074e7d17c8bdb9c4a870", + "d4909aceb9d5451fe295b7a01755417167885abc31a2d75ddf54ca41bf81bf45", + "46c9dbe63ad727356e7acad5a4271720c1d3dfd3f03ef204ba7ad667b8a0ebb5", + "85f458a2a504638ee67367eb6350424d6b57b04487e4b8994923a9ced540ca79", + "896e73a969f3844bacac4ad525330525c6486d2fdd527a8a95b5a36bdad741d0", + "87681adc96456156777e31ea3c95ad1af59475b4df221475846ed2c86fb1a430", + "a76cfdc42818242925475a91b10dbd59ea8c6a642a0e233adccf5d61dd4d661d", + "19ba5841bc45a5e6d11855dd39b084a8c580e1c72066b6282be35947742f645d", + "794a57946cf994e5c4065bc8195cdabf8dedb22f97aebad2ede59cd18aca50de", + "fe16fecfa62fa441f51dabb5d24d6ad103e781146b8e0597cec84a7fd435ace9", + "4ea8c43240f6a7adf36fe1d1bdbe63a6fdb03a3ff20c51dff8d95ab284b9e933", + "fbe88e7d3fbf0cfe3f942f1a0a62df5189eb75c495a27c247c038b6a26353eba", + "b83429d9906825669421b81e2b42db38059b83a854268ae764d878811cdf9942", + "d6563b934e5ecd37ababa36cec287d90a7d37514a29e71a57c5f65bc8d74deb3", + "970e039ffc74a1e0ea6f13394f5dbaf9fae9601458ae9a519c3d9319cdfc4547", + "5d49b5a81abd7bbb722d360a414ecd50e30be0156bd059c58eaf524a9749ba58", + "15abfec59cac19dbce30c473854e509fb42b9078a83baba4a6b8dec2103c6ea7", + "ba7e95a970ca8f4e0b9c8dd2e1868ebcd406a75887967d746c85e12a2399e5cd", + "921e3571b0cd985df47a3204310d7f0ad95732d0ddd0da11bef333ffd5014209", + "21caec09485244d3c79333d9b93483d9f5ec19c1dadfccdd0958dc6fec4d0ac1", + "69e2a28617767bbc4abb4618ac9db351507dbb382cd88530148fd5e776b5b52c", + "d2c895f6bd4e6caabf305dcfbaf859c6be1ef408f64b0b7e64972190e518d9cd", + "3ccf9d8e608e8a73c869d9c58d8137fd88df440a8ff789916a494a0e251738f1", + "b9d1d871ccdcf5ead338ec61d7feabbec840dd9a966554309190f8e8b60335f8", + "1d9f6435d61a849d0495bb154c1c11c466b347ab6c1fc724412930c12104f868", + "264780f54e54f1e77b593a0f143c42d48428ef0489828ebe881bf18a24ad950d", + "85931c10f5bb6b475fceaa50a009a70537a9f5b44df9d2a0ff76aaa0a99f8a43", + "27cde464517c4c20974e92412f6bb74af4722b5474771afb2a15abf02603257f", + "fa5a7460f6dd0aa64ceed4fc36397e130ca300e6804db03d03f56353ef0825e6", + "372f14dd14d3f1bf56396530733f4fbc4f56ed593cba5e4b8729c68fc8a044c5", + "9a3aac8df20be74246dc44ef9834042daa27371437f1079d3b63395bde18b0e5", + "a7254effedd204a5502f3cd0fdcfbc43c47fc1e58f86be607a9d12fa1dffcfb4", + "df361062b625633cdaff5003ff9e29ffe8338bf77d3cd750108fd06aaaf8cee1", + "6590c80d033ee50e0cefef657681e79e691e81cc697ee01a14e6f4377a60cf53", + "f381747274753e5e687b8fa84d2188de2f34c476181393f645b3cee36a1d4d7e", + "f5a00f0444a05f3174a74cd1afc7d6aee1b52a72f0649bd1051e23e3f4fa5e93", + "a5c69bcf09c02e519bcb86dfc4285450503ab7af71bcbfeff136874715e9c795", + "de9daaac5f72629a8af5a41a9ae19a0f3121435aca5ad98cb66c0fcf48918cbc", + "7b7c399929024ba39889490c19145c78ae1d93cb53e96e1e014c810aa97ad334", + "3eb4f06d9233ad0e40df1ab6cb452465e8a52f1acdd7579e9c4f997fc033255e", + "661f41f04c937962e9dba730c0b62775b274da685591e78a4bccbc4ab9f722ce", + "4c35cce3b631999ce4b9166a96250a8f67eabc9ef4806a1fa8ae7948e288af8f", + "c92dd8110c81620aad5ce7e43c34142ae8c3ca65a510426cef007a2fe24c8cf9", + "2c90e4a105e150fc20013572b0372d64a1dab8c152cba03a056fe8dc5ceb029f", + "cc709f30f5c05547e7f3462f9d6abf1d97accd33307bd8454d88604473efedd0", + "e96569a289737a760b22d4b5a53b01b3d4bcd739585226d5a97cf45100f37fcc", + "3f49b49691d0bf4d267d62a0c7d140ef99b395029c4b40459c9bf2fdc40c4b5b", + "2a06a64a93b6a06c4355147c68bdb264789ef75b127354049242e68cf875a3ea", + "200259c9d5cfe1b17b06bb385412a526513f45fe00e086fb3360eaffbea1fa13", + "de6f469204ca237e2d3e476f688a0adeb8ef1cba5f52ac0a09dda081dffa17ad", + "261ad3c414db30bf60730593f08146f3d968329f9b2d13867466b2427b7f3701", + "66605ffd9cc39f2c94f50a0aab9f08fc9e1a3d632586d9bab3e5b61ce75c8bc4", + "13ec8e90f04fdc9a0cc38fcc64f480a733cfe04d2206818bb6e09f75f563f617", + "689b142d7814e8a5d8bbb2abe9a2fc17a17c8241537eeb1a50cefb38c7652a92", + "d711b37f9923f32eafdf7b39ee6fa9b2b3151d23d22d8a41a481df654efb6547", + "43fb0fc0f0c5320c922d52426c345d628ef92d29376a3c0a9130ba927f707a90", + "e4cd7ae85ecb263977f98245a94f9ecc778dbd471f899bbea6701b6a144eb739", + "c3953784e67a9870c15cf6c126136e984dbfb16da4d9a3b413208ce4cd4e41d4", + "8375fccecf707aa82497f3ce0b46cb08bfb44d1f88b60aea8054db66f1113b0e", + "126d22ee805b7b6ff9f7fbd4d8fc82bdf4e79041e1c5c623889439b43516e149", + "60891c617a50323bc82cf9bfef1552b3385a0002dad99536e16677a5889445d7", + "cccf551d5e6aa911f770dc855d4bf0f966bcc0cac7bfb58e9423f1ed060a641a", + "2e5c2b6abf4804a6ca5cf0ee1088eca0c3d656cbb91ad42fcb473de3797901f9", + "8d430fa285d01a20577e7745009c9e9a9a68a8d64e3ca100f7edeb56665c24a3", + "ef51b57f16a7944fbb0318cf98dde426a41a0690d999b406c1e05e3aa9288358", + "2afbb14c076408f0579adb06b56128a05c1f7a05779f7bdb09a4d88e1f70701c", + "3f223384f75b6a7d8d86c1d917fd411a5a8aad938718d80f8a26475a4c8b3f04", + "7d71b2794c776253f9351ce9c57526df35fe24697a949c287ae37773d2be764e", + "df9f4be485e4d77b51027cd3d1958ead67df56d0e61ed8a4caedac127521ace3", + "2df536a82f9568a503b2d3b0bb2c735e7384369bdc209ccbba67cecc0c9b15f9", + "c4dd4de065c1385f4e0e5f3476148a313ca3f67035d79be4d0d96453b7cf8d2c", + "8c34eac2a2e0619231a8b335bcca6003dc6a2e5f7d2f38b1d7e161e873918729", + "cff2cd982f92efc7285317b200aa32b571298eb17af072b37e23dcebe3d2177f", + "2aa86f045bd2aa3c9e4679c5023722ef85e9a5df28be84b3018a08bc03185401", + "3482ccf19952f3dc66c89c498daa6610a07bc91f0b5098c99d4b7dc7640376a3", + "3c51f643ae7d1daf51a69eb5e49e2d420d1b4450ae3051d81a45d0bec6a0370f", + "82af8e3195fe7ed3b768160753c6a2c0c966d7759aefed484e2c52ca25348543", + "2aba300d6b8fa4e4277b78b13cf938cf2ff667f64fb4fe3bc33e84cb9fe46662", + "fef90c8a751ebb2371c5b4298bcb88308984a0c4f256aec2c17eecfbce63fe85", + "10f77a47ca9c1856ac18e3dc95f69893daed469dd04f17c0f5d2f5530d0c4fde", + "5dc093a56994c9e8c91a88cb34638ea569a194adcacd58699c976a597995243d", + "afcd43390d05e9602c096ffdb2548e71c199d4a38104ba28e08ecf14d05fbe24", + "2c929546a8fccfef112164fa249fb9236ca11a98995552ae1d1498401a37d3a5", + "e4d8160cf5b22bfd802754e385f373f7ff695ff4b057714303f6865eaaceb49f", + "2e85b3ef2f688838aec2b1a8b0a1182551787cf76071696b455cc65aa70f5ec2", + "7348b61b66814275c17abeaf1f7fee539b9cff0cba9d172b8c99f1a07be6f689", + "43c87771c16f247e18eea505fd3278ffe360a582c161999b634f2d3b2837386a", + "6be56ea1a5ee024acca59d9ac3d55347c49822a39db94a1d89bbdb5375b80b57", + "629098d37ff14c3d7cd1081482892b6f33038d03431a0f8ba469816d2ecbda04", + "cb2c2cf819008cc1b14d94f13a314fba8a84c18e5c1f3e1cfa7317fc8c07647e", + "f4bce28f96bcc780dae8e3e462af335da266a6b24da4914484f62c2602d2066e", + "05788aaa67719be74999792b86066c7d228e7e9e19a81b30a7fca10502834c33", + "0ffba62eef8127ac6b0062c88e5802578f4558a890e5274d829134a507494d9f", + "bf8ac99f8840d0d6467f38c8c8cad4a1cc3c116b89319fd2bd9ace3b54679fbd", + "e5ea7e59ae58378d6935f4602d4ebc41c32e20a83dda228ebcb548617171a510", + "e1456515ac91b08e6888cddce637d2668710bd544f809dcbba95cfaed572df60", + "188bfd6fd4263d73cbda9fc040238605aae753e80637b30c7e2ad2b74c62c74b", + "fef6e12424c1e7e156e203ba53442e3fbd7df6e876bc8ac41b69372d054700e8", + "0be152b35a5b9d181a72004ab96ed45f67a91919350cd4f155865c4a24a037b1", + "ac05d1b36359745915d35de8403d3676840091ef9a8a4bb21fcb6f8b70ed1ce4", + "514929801203e366bef69e22f6212488219255eab19f0223bfaec1a885756939", + "818aad7e346ad2f675b44a993fbfa73a9d35d7e92d918ae289bb1e90de25413e", + "9239ff447c5d7509693d2a41a72bf2aeae633b6a415f1c23d96b3eb2af8c3d5c", + "fe636a66b36601e93a17509ce41134a39398c60eca7753ef35de0e0dcef65bc9", + "bcaafb9e1a43ce3163e2e8ac0ddfa5deae6e5a4380890bb47a2ca21737f27cfb", + "dd4aea8d5ae04cbbbc129b0d66467341125cee59d03899d081dc383c35ddb57d", + "8a0c33950249adefc2a27ad73c123b716f666958fd35649732d2f85fb844b175", + "61ae0f6bfeb2730254ae7172a6d1a48f2c1752e1e8d239682184769f4d2497cc", + "ed63aad141a1f0815c66d1648896c0611f8dd5b186cbde34886a208807822475", + "2a4e40502c61780501242e09124127fb6551284d5a3ef8611da21a3a7e5191b2", + "a18f755a2cdfe4c2ed02005056153b8eff6d50cd3cba2e843e5d90d5f047cc5b", + "91c19e084db8f9cb2502646afba807a29037390317f292b11b4d433bf6b9a6b9", + "c04e24283347081d878b322178060cd65dcf996d0cc75039b83b3b28a03b8807", + "4b7d38f3141efcd216d1f1b5590a3464e2b438b8c918e31dcc74a4a7f9fcc8ee", + "f505f9451a0bdf310feffe712cd269cfcdfeae5cd8c895503754e203aa0f6da9", + "f5b8bf91bb596d9d6db01f88e25dd5a07deb98f41d1344dd27d60b7e6f585791", + "8627eb074fce2c4b417dc3f7c3f7878e4152515c6830027ea34e18bb88a5df0e", + "aaaf53cebdb09cf96cf36ae1f83867702b7700c086e733e1038a1fda1a531897", + "2241fa51772f0842ba43916f8a27fe9babb5cb0cea347275ab0aa3b9fe13ff0e", + "f394f495f2b689abe6ea9991f5a51a8ffe8e103de5eefb816eeea0e202c8dfb5", + "cc06451968fd107776cab165ef685d7b1cd72c4bc3474fba465c9cf3c77a4ae2", + "28a78fb6a049ffc3294816dfd0d53b87b24c7073cca6c98542cb48727c8f8556", + "ba2f069b83f2a9f9332cb5db6fb5b1777e07d7c64488b577017619ae03efd76b", + "6227c4d8f503ae919d909f9da130c9f96f8ff4349d5681f78b12c5189e105d31", + "293fbb8ea624b02bf521cc91f318a902bc4430267f1fd014bd52d4e31b6409bc", + "20e00c7179c72fcfd10626f2f2ea17f66364536e25605d5213f303c6876bb554", + "0ce1f2deccee0c330dd57fac13806fc8a68985d386f1a56d402cee2b29539a8e", + "85a9826bc0356f04b2761a68bef995a7fef19bf422452d60cd07755866717999", + "a6c1e77cae6b4b2bf6a775bc6888e45787712c8b44d591f3450bb4830aa0e507", + "5c8464493c98cc09b011072bf870d6a79caa636b88575aaa3e284c49b46c53d8", + "59e0b5c9f14e7fc42c64ee120446405fe9486c51ec25e9cc8fccebeeac654a45", + "5344e3505887869e5d6e6c2fbcb7639e0ea6b8e235eeebd6f8b1edfbea2c25be", + "7e954195aad6cacf6f609a6ef310843cc4ca6a4fcd04cce9e86f7e53bb161f02", + "ad71c9145550be5dd160a4f46e582d266f04ab65e13e9975d8a50048b9ae1450", + "9839e245fa21a1324ab5f602a4b30cb3f196cba055df67153f3ca6f37f0d182e", + "d2ad356e736f2ef57449477e07e78b2149d2c37786f80fb938a9f448368f4b51", + "cd3e7c96f15a8866e6b1576128d5fb6aa2bf8b733f9955a1319bed6d6b284472", + "166552fac84400f1689b02297da8bb6e5bcaf9f733f7c0729a959e02185ca34f", + "c2433aca2a3a2c67aaa29ab338550a64e1c67ab3d0404bef1b497618fe7af2fd", + "740f08cd2b16954e0582a302cbecf152f1704a84ad41e77a9818ad7c4c72a519", + "52372a0359698fc7d878dbc8d89262952f59c76fcb09aedaef13db63e93ce068", + "d3182b94fc41befc54e7e6a31bc768e92009f1a59a60fad7c2700ef08274ce30", + "763e0007831c4cf248e32ee785efb4013e558be22a437c218d49981ddd9a56e8", + "7873006984850068f01c805dd3ccca0247ebb9f745ffe4747999a676aaf5a2f0", + "e93e0de8f35f189dfea8afadf388cdc6fe2a6962b75dedf13a2037f9e038d327", + "7258b1911da7702196bd7cfb95a6206cdd4162492fdf86528b4798b027a7d967", + "e9186592e4749c7a3efa209a913823acfd7ff5fa1d616b8bd22fcf0ec7e9f6d2", + "03be5206b6b53cdc4780535ed3d509f689a4ef6c196d8f02d23cb82d4a766816", + "6baa2c4bae24fc6829c79159f06bc2d435a651064fc50a69743902ed32fd84b0", + "2c367bf0642df5117b33c07397d12f303948b2ad0b4a63bdedf0108aea684091", + "47f0532b293d8fe938392b0c01f3b6d5203470b40e82a6f9e992cd0a87af9d80", + "8415f7cb7cd3b61c4025c5fc88df2fa0c3c3705af9637ae29b62be309b17d608", + "59b2bf1e14758dbf18504f1647f0ef0f59402be3f5561453a4fde0664597fd18", + "489bcd106e2921761530afa5a59bfb020fd4cac56b7ea98801e2e28176513131", + "473a721bf9137bd3489f0636353e7c20eccb7df4365e90e9657aa395075c6b79", + "ac74c45b6de58e24bcc6124cd53eac4c498648a55304971931fc6a5ca43038ac", + "a180ae93d0e39d5d66317ae7c80ecb19bb0ac3d7ff740dd6741a4d8bc2f04a1a", + "496e5ebfde31ae5eab7c11fa61955d785023cf6ccb3106d0c0802d5ac77b32ef", + "d1cc5fac8f447b38cc0b1389a5d0961b1204b9ee5a4aaa5c9a6fc90f4b4352b7", + "cdf12cba427f1a4f8020a674775375898c3ac5e3b80f5ef2ab511d4ba854255c", + "d107c2e550c64dfeda60361fc02e9169cb8dc38b15db2d96834b4f8de753f3e2", + "92f09fb16eb80b591c227d5e93da95f535f5ce37c3912b068f970a900d1e03bc", + "8b6032e3af79d6dc7d20f1869ce72bef1d9b9f330776c9b9b1a059d64d8b748e", + "9d710b84ce3873c5cf0ff37fb548ccac66706eb88f1dc3ef660214799b53e4c1", + "bf4c7ce8c768c42c80e9ac13e98d76a57a7298546a71a5da7b26ac3ca2b88439", + "c4d61c2ef441e3d0f7b6e8ff860c8d3b7079ae01b3110175df12feb4c5b7e194", + "c2f2e3fb99d82297a80d39c3f9a1e678ca07d5e66941c086524dbf8e88cbeab3", + "40b982b78f50cae884b345ec0f1d0b062034ab50812d2e9fb8927bfa6cd3cfd6", + "caad4c08972a8d036c445fc654e5bb9c5e62ff700036ab9a73e4ce3987b1b2de", + "01eb7ffcf27e8390ac1fc5081b162f9088265dc36199ad3a23a3304a3b012248", + "83d1ecd090a8366aefcd5911f839845a1dc5f43e7affbdcf56d1ce5aff98da66", + "0746fd672061f38575ef56c1472b3fb19725d9022c643afafe6fa7d8ae85010a", + "c1b1e0ac21f0be0fe74a164d7a2df1ba55339cfd08a80443f34920e09d056af6", + "923e5e29cd933e44c1708a439c1cb2ab0edd7fa198d27556b2b5ff25ec1a0c40", + "f71ab504a1555fbda556060511932016a7280652fbb6083a2d7f46d801ffcbef", + "ca9ba2ab7610386879d338d77809df821b7c934af7d4f309af727cdbe9364754", + "8ab5603b1a1e48abde8c5adc39cc2406e6758d78d2dbe1438a97538ea0640d7c", + "eaebd4890bf4099cdf985181317f2e0b267f72e4354f2b23ffed3cdf596d2984", + "314349db1af32757bcfeb07b540de77692d65de9960750463c63b5db81fca204", + "e870c731d7f904158890a4d93e40bb9a9f1fede2063afe47b9aa2243d76fa3c8", + "170053346248dbd12096ba941d3a4fe61fcf2eb46c8d5200b37e78134dd54450", + "1f00b635ebe3c3ce6934de53fe311af3bfa377474ed9d3e323eef1ac54e27ec8", + "faa9aea4a192c6d680e06384861243887baf23448791630048e3b1b424f935e5", + "f302cceadfe15de4b2cca6e0e585498dcf2e7be1c9f57f31b5ca38273ca61ac4", + "aa6498b2055a263b97ff3b661df4ac7fde2b11a319622e7daf418d04a1fcb205", + "3e1453a99dbc0848414be566fa7855a77ee6701cae9cce33ec6057b30f4815e0", + "e8156259a589ff61a5ba213b86f4205d21a25164efd2f3aa2f876ab6f6c45745", + "d94924a24d9487b4784afd7bf77e3daf1d7dcd5e29ec83a2e0489b1c52a3069b", + "ac48ef8c47b24e3134d8659ad96ece0dbb9976397ae56ee6b37060037ca881b1", + "2e70a808225771e51981197d3f8a15a6bf380789abe696a07b7966be316fcc9e", + "8624f959135e57ee4bfae5f2ceeba194b3a942975c19d4114e20aa08ce8c5c37", + "53f3f7b6a43c70e75f93abb941fc84a945e9f0129d897caa0883acefcb7d8046", + "c0acdc5bedee791badc1f4236f4c11f3dae5b91eb86d95d2e9163474d3a0c2c8", + "ba5156ed141c1e8cabb310a75524550902473ae1ddb0b3f6fb4079871a0b7fd3", + "8effaa008bd4333f39d4429d6d0b0b686192fde797986e2b19a475604b4c34c2", + "23956e335ee8bff48cfade99337307730a4bebdd83e60fe6c0d5d666a1de3afd", + "5073653d3b1d8e61ff2c2984126310c7e2b8cc88b55ea2bbfd8a31cb6b22d40d", + "1e3726f9deecd3dc9f956c50ea421b869a6664d11fbeee8a6840ffe19dd8ceae", + "9a9061acb07b5f6c5aaf55a11dd2414e278859a94d5a2a39fe7023e08291b07f", + "9c44d9b5fc2a00382a243dee01e712029dd84c2008214980e3da2bf0b043e96a", + "326db9f9fe3732409d5973acbb34c5a669167c38cdfafa2bbe8e01a1cd488e26", + "040fcfa2d9618c4cdf2ade19a06ca7cc54ca8dd8b95b6f1b4c09f07da17a0f8d", + "dc52092ef0ed2a70aa0c2dcacf2bbbfa3b565078a65ec37560a2dc5c0192b38e", + "7df2b53ee5fc7c47aa99b5415c17f260b816e5e809d3e36db342be52da74ca86", + "0122810bc7b1b8ee6979728bbef6b0104f8a6812211526743445221264048469", + "16d5f12a6d3127458a4069dbdaae174eae0d1d1f5df1028431134e1a47c3cdcd", + "2d7f11d62ed54b98b60d7c19f0ef8295913b3c43d56055667351873c95632eb5", + "bb3a74b29b64a284c27f5e958f3839f5343f4795f0f4aeb6e5285027973b3d37", + "1dd18a14cb7462b922e8eaa9537835d292973a25a62c050da554e9d1a520d46d", + "77724d2dea965d74f8ae45961b27295c1504aa25af0cbc40e39da82bba1c77cf", + "e2de46c5f2d09041190e2a4abfce09f135f7707ab4eebb604a71a812783efd57", + "65cfed2e44c68705be47cfa64132f8da3cec7635d22b6139aa6b87882ef89aa7", + "f62b99e2bdd6cd6df8fd863598d1d5c6e330c14d0c4643d543203dbc78c27f91", + "84a575021eb1c364ad9f26ac30026c8dc7d06dbb2bc16bd360702916122d632c", + "f8c62415f32e7349b46c87b83a98ad3d1f46f8bb067cf9686b1f8599c2e84210", + "a4fabd8b075def5af3a9d7522e07217c4306dbe633e3d056ef0637afa7a55d3c", + "bf617c4e44a29b660aae0957ea05ea3be9748ca0b5be9841c7b0142cb0f37cc9", + "f00496741590892615b2d8acc9c1be1835dae7f6553efa1eb0aff2b16fa823c7", + "626fe478cac64c6366dc7546cb0e111d161f9c84e5939e3f85cded089d570c9b", + "5c7fe8d8b1c32f9a10638224c1cff92964dfc8da0f35daa4552f53a6480a77a8", + "8d77b0d2ab7018ee94c6f488fcf4114231ae9add1b92403dd741fa8ee14102c3", + "739267f59fda670d8bfb951fae7d96295462d13f4315b1d0742cf7907553fad9", + "69821255b1fc83edbfac6bb148f7041567b369ba40a94fe23f24f861b3e62e09", + "7f2e39326035cc38e548bc53286920e6f9fe45958b98dedb2eb3d28d1805ab16", + "6224c492d55b5f1f90f86bf8e228eafb494b1544b2b5f303ad2ecaaa4f4443fa", + "ac973097e8af7ad5647ca3bf85b074387c62f36b5b3b9be5e621b584879caada", + "d4d5e5751b3eb2eef85a51e814d56c7209277b32afe3265866f27964ec303e55", + "d0df46b06b1615a335e99bdb9fc2242c58389d765540a72a43ea3f811d9209bd", + "d9967e1c3c5ef62420d4038a3ec5b830b26b1e9fc9bf5fa1e87298c7476b31ef", + "d61e3cfb5aa3f4ed3e3d37616c9de1f642e614d05fc53c0b8afb65d966c0c920", + "7c00e7d7ba75d6a2f196a4d1962f9d488f02ee123bc1044712fc3a4cb1b9cc24", + "1a094940ed6e6ef5ba7716b04ce490dc8e4dbc2f8c3ffc17aed3159571881204", + "e572ab94b6874cefa8619d1a4f1a779a6b3aa6f6b80d611ec6c321412b109a00", + "3a9b0a9e84809f6ab85d8b0a765ae9912484975ab8326e9e3cd2d506c1a6b808", + "7dd8856549ec82d2028df4d8a1f7b385d4b36f2450fe9e9df8de9349e59b0c63", + "4f2704ca77604f279426a686d9ea2ffd78769e96e2010f9549b57471fd762d70", + "d489bbd3264b74dae3bbf636330d2c3a44486a13584f91e9f3d168841f1c28bd", + "b5837ad9002be03d0f11a8affd087fd53ac78c0a2f2e1e178cf977d1acf99b0d", + "da42fc6632f2eea0abcf4e66a4d37e6515e31fcfbf0b6e085b92ed1a9e1055b3", + "de0479b3a4f130574fe442bcdf6f5b93dc6be3d450cb526b65b5645472416989", + "73e7af51c77d74b6201ece141283429edb1d0abb2c2c92a5bdcc00738e956209", + "d85c4ea2615c33e3be50623d3b1ce1936cd15de993d6c723b788c76d4acf6028", + "4a05f230d1bee137ccefbacc148c24505dd5badbffb4b6145bcd6e5da8062475", + "cfbf8645a724311c08a45e68265a53c4ab6a4b61be891598e2b925b2e9da1f47", + "f030780eeddcdde57453db94747bb4268855373a43b9a24d4f5ce040d7f4399c", + "ac2363c85d461cb5d93b8ecc3a1820520b6738b72e914b393dea024c65f8d0a5", + "4600da68102cc23ab337de6f68d58be1eaf77b8379fa7865a441fc31c3799c0e", + "fe6a8933b1dc96fc9077f255c1517f4ebcfa7b84b928bfa4265d0b7eda712cf0", + "9c90757a8f5cd05d96a4b2614782ec0e6ae95d5380829fcc200648c377ab6c49", + "78069d05d0e23277b01610bcf52d8e1841befabc6e550cdc4e9707d4ab930b36", + "c2b93c16b67d0e4c472656d8807e03edeab455f030ecba40fd02df57549cb528", + "e803007ad841348794affa9205e0582ae5a94c582c319309438fd464ef3339a7", + "0a3fbd71d9b36f1c49eeb971663b113a113d0bb17b57e1319356932b39166f60", + "3021ced93474ca1202db2339e428a9191267b69f16801877acfa38e6337de252", + "c9b523de00637f26c8e22163f302867db58b2fa3944ebff285190dc775c90164", + "18cfc18d7b02b806f1a40dd0aabd3431b529b72cf72679021b8504afc371e06e", + "9cf36fa3b8b2422d0ef6536cb8c96976bd5e64d1efb28220bbbbc110254c8315", + "70754168b57c6574b419ceb81fbfd2d90a767121e465083eaaab73a0e1e3ab30", + "31bb0fff7dd56efa81c15eac52b044f8e15d90db59652707b2869454c36ea30a", + "4ef45b1d53c5f860fa1a711ed6e1cc94b7fc1dd502ebb70a340a79511b774167", + "cbbb709a8f2398d8f925ad91a524737cc6f693b9d3c7834d9f6db3e0eb1a7348", + "8b1136458ef67a90736c4f9c2832a9f5f5da1fa0eedd084d4bfab9215cb1eb65", + "7d54fe7cb314f6e3f72dd6c346c063290c422f0fd45447e92c2bc1f220ea15fa", + "bd84c34b5a9b121bbac5a72104a88d3ce034de2f17bf2ffd517a21b1f41bb3d9", + "1a9e7d31c33d5bda7dc059d7e2e049d8e726ef710bcb6d9dcb8cf12aa2e4aab6", + "c3fe720dbd6b96b39ca6073ce5a2639f0bb4f315d437da59a07718fcc7da95d3", + "f2fc608b3b99e18c01557a2bc58ef07b448ff7cb10f233bd0e6df5796f2f9d1a", + "fc8030443eeb26057e32d7e87d6f8def9bc37cf98d733dbf8e7e84ea54732692", + "423aa5dce32b5a55d551b36d190f80734bb36d1d0501edf6974e4018ec540791", + "e0aba167d73e6672086856dd0adbf07139156750c3a3bdf9784b1ab044d27f4e", + "cada168cdb21a13dedf0bd8cab20d829ac3ec899de2146c8a2f70854ec3d78d4", + "f8cb4b1b4e9fcaf2cb7f933e0167ce46c6aaefaadf3ff22c73fe572d7fa806ec", + "5ec38463ebf4b69e2631907f97b7dfce3805b6c905eee04e51254acf01bd9f15", + "b8d66c94dcad42448cd92c792d7fbfd0e5c8cc2c733ee7d9c7f5bfd9c21fc29b", + "b4396f098be58f9c24c02809448226c7eb52f67ecacbe3db7c6c47775f01888e", + "82a5fa92fcca31e30550fda7b9f4023765f25c0d7e687cfc36afb8190c02554b", + "1a5f68aed7a0d42703e583453d13f0232f9170d344989dd79f76609ee7f69025", + "6b8fac5e58c147026022ead2f9ab5d0e13151360c7e7e49566dd9873cf453369", + "965627e94212b2fb61961f61eae1845eb504a20092b59077dbb4a04d1e4a0d9b", + "a1ba6eaa16d746d7daf69bd91d52039f0133c0c1238a2d326b179a6448ff2b9b", + "a09cd576415a43ab5a4139e70eacb39d28b7dfb91e675db53f0a652733700a62", + "3f1abd11a36f856ab52c3f5a6442008dc12e299245631eab5be847677a2e883b", + "2c8ff507b86dd684a839f248009403a301c145437f6fc8e87face81cd9ffe7d6", + "24d695b29f84ce6ae1eab907899e0777d59ceaae7ea47803512e29cbb98557ff", + "c0fab9e53233d501fc1fca22ae311f10fb3331743b004f6ce4c643828d41383d", + "33350d144bc0fb45dd0789f6323645652835f4fc46b181d9fbb1e01023afe08d", + "c628d6cdf3425d968216b2deb0ea811a05c65a61f8b6f52a9b71b43b1214591c", + "b23f0750a636eda71f776b857f07f8e96c18a0bd119347fa0caae46a50c5e58e", + "b5df3890d2ee6e1f36db84288e23f415f76caf0383fc50d47ece3b873d893354", + "0cc3fef26a491c1b99d7a7c729013c4c4224c972bcb4a90cc55fe19e42801bd6", + "7fbd3d75b6b070c4bea8eba23329ac14a21d0d660279e26d1bc0a2c8d8588062", + "b06a8f29a7d3cbeace44f2bdc7819f77f34121ee5f87b66ee01ce2305284787a", + "8bda4d946539a110e86f82bc55f572a2f0895122ee32a15e44e8ea54230cdd36", + "9399b8fd18e16f17441abccefcb0e318f1c5def6c95e86c4a55afd91a2e4e4ca", + "f45ba237a05ca858f53d274a27f78a7d8825d6887f99f3023458d6d5dee15d25", + "950755123258b63e45ff8c126bb80cc0c7b0735637e68a8edf9bc611d2036d1e", + "9a9c603dc55840d95863ac8e0e37a0caeee4b09aa820aa2605770c797ab7774f", + "8884e989e890dd5de153fd5cb814b44a4412383a9c9b25a3ab8f25f21140082f", + "911591d32b6ed317f86a78fd5c772da95bcc4fc277e8a0a0ea086ebdefe376d6", + "04c0ff4d49a0523bb1a173555aa9734cbf4dbef15f541d0c961eab928efcb627", + "557b2a59a2c277b6846ef090ea0896e72adf4cdf85179b1f4342a4146789f694", + "9595597c42cc9828e37ab92ead886d249b8b710b638badba7bcf6f5ddbf4c6d8", + "98c969c479f4991c624df65f54ef5397df2e6149a829ed3b68db3ab613fc2a38", + "ac9131d4ab8fd38804635c79c6a99d08f6018834830bec2eb19d9d6f2f2f0ecb", + "0001d99b74d0f9e8be0a7ec5998a52e497f2da7036ff53b78534a532863c22b4", + "2ac70274f3d0b10bc91da912abbc5bc55d9b55118ce77b75630593e1c04925f7", + "dda72d5235c997feb0f66c0bd71e976c7f034ac0a6495f79dcde239729c8b64d", + "4455ca935e834f7ddb5e573c3f9e48057432988c763cf2209681678f7a0daa4c", + "84b7f81083b6b6d600ba7b95fc559246da45a36ccbd92c4b379c405aae0e44df", + "6a8d4fdb0c37b13b144e4d8087e1f670386f2896558c6b2927754cc1dea80ae2", + "f987b9afbe1296a36ed1ab6a2277a55e675f0c962269f5f8234e25ab6122ae22", + "4304c7b6e8740e9dc3b69d2f30eeb017f7bd0f3d11ad136d0aca67c1dbfda686", + "0c1a9d29c770f268d5f7f16d5fad81d4baaa28337c9634012772fea3439cf8a8", + "30862f4d1cc5b1dc44c7a83a5973faf3a30025ab143b19628fc7b72d6d471cf4", + "2954687c50bfbd14e6a3e25446b6a5fd9d511cc2af75e010a1050c569d531c82", + "9bf09a4fe773e5abe06b0ba5cc1756ce4650b4df828f850a975a5344813b6838", + "4483364c2894a4692b8e719b80ca5c1e712d162fc37516c59fbfff2baac53bc6", + "6ed752a8af35157751f3762bfe522238f27f29b545735d3febb10b4ac465092e", + "c9bbad6b7535a797f3ac610ac2f314bf261da06de21a1a6f5062218cb358c1dc", + "f5ea1250d4e0f2fcd5754daaa8db66d87cc6d83ab7ff6cea7c4740c5868bf2f6", + "9811ddf8b39784a46d415c5a32c037f5dba0d8051e2b5edacd99045ec98515c4", + "c7cb9ff611171ee02f2c39565621bb9e9ba88df4d14bfb4dfafc147b21d5a299", + "a6005a9092b5a4031262cf8b278402f1b60fe4a137cb2aa0c4873f12a5346599", + "bc34cd3126e6ba330f946dbd1b920090a91954c19ca5046125fe81e27a9a87dc", + "efdbc8e9cbdeedae76e52cfff83a4c6316b448018d766ea7a284d53976de991d", + "fb0713c93ed0353f6e6e583b6167ce8933128af3656034f6766349dcc91e0a83", + "d01ddcba6d4970fc9502ec24bc2b466d6b7ca85706dd5bcd89bd935bb080f224", + "3b1b549de5356d3958faac8f9649cbd2536130d0e92d862dfc9512109a20b57c", + "c6847bee31aa9499f4a84261d5dadd4b2cb3001f50d0493a917d455cf4ccde52", + "612e278f9ab5418d04bd1cdd4e1129ad0120b06fe49001f4aee0161489c0a2a4", + "0c431871dfb57fa67c840df0300da48ddae3ead62458a5d6bbaef6af31c26b37", + "f1493f81c24ee36277068cac04ff5c47343dde9e0341711566f42f12b54dece2", + "14f07beabd0eff9861521a83e1a6a7a8daece4f22957d71b6c1095db7ef52ed5", + "aed128a4ebbc17d8e0f6b48b33c6c93bdbdcb24b7c4f7f703c5b1226cc84acaa", + "9e50495c09f35e5e75973be7a78f16c65dce7384dec74a989af362d9c884ab27", + "cbcf364a26190305198122ffb2c61d35a40eb9ffa712c19885ddc281491a53d3", + "fa15a9eead41059983de074566725c9e02c9c393e306ccb5b0320c518c26e9a2", + "bca9d939cae391e88222a1eb4a656ed65707e76f45e3c5efff8c2be50e2225eb", + "82e5ac4c810f7980bbbf88b02fd38608b8f0c65a8c836a8ef69464734ccc9272", + "771de67802594266409f57f55f2a6ed16c5fd541a8ec0285b2850c8f727781bb", + "26a8ff7b1c7c2045b968a9c4a6823bcf7fa57eb8aafad5f755d2f65f4f60c685", + "f49c1a96c4f093a66a4291abe2bcf19d2b45934f74cfeb4f8c381a227b0e99c1", + "d07713424f4522b9ad6b205660d71e6c4c708df27ce1761e00d1f48ad9b6523a", + "9aedc7660f8763a7ec5c69ecb0d83f80840d8747f85064fa42918e59d24869ec", + "00745fa43f175459c71bdecde2c27586534a4f1d45d96b10dae8d035438a52cb", + "ec145236cadfa431e4c19f5e5364e004b773aaf7f7264401d66c1ceca9b81712", + "683461de202dc8ad164ae11d42f9b91dcecced63910454c37ef1bab5b0be3385", + "aac8ab8a2ba41f1a19b1c6b4c0b0418b009f1c1d33c1f533f35d8171854aa74e", + "dc416a19f8114c8b9514e348414ef98c8c0eedce4d83a94ac0e87dbebbb82ba3", + "6609f567b2a9018b3e67a1d76ea8c5156773d18d32ae96c64eeeef322640e867", + "22b8f7832287185942b41662db29fbc9432002366651fca9184fb2541b3120f7", + "a90f5bce9a26ea5a76eaca2d10332a497957fe2ad684e570c877b91ded3ed445", + "38e76baf82a907b7a9b8a5b9f7dd61c29f024b3f380d37068304d166f7f2220f", + "02e572bfaf69b230c7697b0361717956e3d3ffa9bc3a164bead3813226fe5900", + "475956b12e171d34626bdbf4b0ecc9fe753e443a5eea415a42bc547b13be8814", + "28cbb2681160076058b5ee47cdd4d8c1ccda82b117266ab74b4f4e62c1997c8e", + "e953afd88c3c9a6760d546efbe0f5b328193860e30388b9d8c0c9af1a56d714d", + "b0357b692cfd9cb14106706d297eb56f16e83f6c71ae8a678402f99901760440", + "691a4abc395571d978337de88c8b4d7f5b31af92cb53eb8e196ebd177d6347ca", + "0cc439efa227376026a0ebecc6bdf0f617af8d8bf4caa99e6b40eb4c654d171b", + "0ad93f9cd4b1237c5f3b12411fbc3b79de35c517def46dc5f56338c38451e91d", + "4baedb434ce5f8c5189fdbb66732d797e67142c8d3161de96b7e7bfc1a6f9995", + "236742fef8c8b3e06239c60f1968e25ce81c4d4f366c6c1f061a3f06093c251f", + "ef45428a22bb7faf80d18b4175f817741c4e0724ff32328d33426219237b8acf", + "58250eb2919b79e1550860969eb7fdd74038c3ffb586e0369678eb55aea21222", + "a9196aec0784d0f790280ac01f94cad8ddf778bce39d6ae2b66a1b099bb05fb5", + "e8b5656155b88fcdb8576886e690e8ae86adc7c60f094ed4af06bf511b3edcff", + "7b2cd726b5dc314318ef606ce6f11a4ed8db7cacfef2661959264309f3d1c798", + "a8d19723e399647093429401f648b9fe7d2d35c555c4edd15f0b5af12a2a3985", + "329e36f655192fdb1c66369763f450a29df07f31bdc660b116e3ddf70e75243e", + "095d5640154240f98b048026d431af1927eff57d0e06983aae3cab15531c059c", + "099a8edffa6bc6bd3ec986f56c2fcabe34d32bc65d8440347ecfc9ba8b6bd10e", + "25c2843f0f368a0307be1b1ea025538849e2ed340210f5a5338c906e65359d78", + "11a70b3d636becf5e7d1b5ee06e9faf46ea4308d663d2144ba3da498dc35a5a7", + "46ee38b9368926ca9689ad6bd2bde3633956030b14b4e9f8d90c7811b8609a7f", + "1f88ca86d9163f90a7df9b014ee4cf9dc52c1b9ca1bfd0956345e50f56f818e7", + "141516855950eabc2e5cba87e3f04baee5567671640d384d93027a044e71335f", + "aaa046aebd8c6b572c54621df46eb9c7def92969bf61784a49b4a22e2d60e128", + "d8702e684555ff6564e3ba856d8f465b276f0d0d691801442fa6d8b0d4b965b3", + "81c96f4144ed937b34e72df14378ea3c74978ececc78b23166624be183a76ae1", + "62f97e332432adec308a28657faa6ca75547a3f0cc4f6c4bf342b50da09865a0", + "463009bb3ccd98a136b2e97d2dda8978d11c2044fdb21da8d20e0b59f3073747", + "19c23de4eb2a36b0da90bd43ce732385b91a8de3426d036818e65d8bbfd05ba4", + "05213de728b7a6d1a8b58a1287896dc225380e99bb5e309fa0b39c7c999e4078", + "35a5a25917e0a3e982efe63fe2d62b08165f5b4fb34b77abb8d411ba3d8bacac", + "2e1723ec5cf5d06b773a4d94662089358e08c8f21d2db0a2cd226ec92242a5c8", + "eb1ff3cece1013976b4bd668f995738309b6cce044fed954ace6a0f492540c1e", + "7f3a214d51f34dad30faa41f742eedfd4223b45c8e45f1379c57324eb14f65e1", + "19b868de8761fc593307ddf81866375980ea9f758ebc0b989c04a04f080607ec", + "696b4e08153cd89049a9fae036c2c20322b33733fb1f9ffb8c056d56fb9d4def", + "1e2676702200e78ace211ee5f0c0e95f29d2de071d5a22025229ffb9fd7a970b", + "3a5ecc7115e114627a4208104d799a3ff82f9d267272d70526a5bcaa4c0ccec8", + "99f9a9e58f90ba969d97754683970e7dbe9b5c287c0100f17c8ca3856bb1b527", + "c3eadc4be4c6324a512471bdf088d97a1c1fbfdfe6571690002abcb34dda5435", + "bfa7d2679d2238de3e3501428ab6b2361e00aebbe898d925d51aa85cb1ccab10", + "1a5d84954d4c8343495f7c9f12d146779d02e257881632bc3e24fe0308a399df", + "5ad7b5ab3d139b9fd91d3d6d8d4a2185cf427fef8e8248a6686fa63205a03c29", + "914a5781921e1dd2e01650148ff91f028d5c085162ae24bde890a5e61789959f", + "6767282d5ca8bd1324ff0a43de1e12a6b4c90683023626ff7d6365703c8d37f2", + "5bcf37ae0279a3f98de86e7cec68c1c4547b36d279d0b3a468ddf86aa1d7f209", + "e43aa68b7008cee0c5dddc5422ded774b6e4d23f4b79d227785a3f30f282dfb8", + "e16f060a56e841b5cdbaee6672c1401032ee0882d335e5bb0e2ed134fa32926f", + "422aa5d5211073bead07233ff2475df739db95766ee67d3d83b3dbf189032624", + "e29d1f4868f7c2d52a2eabbfe6a592ed476de91b94ad666c6bc71e55e350cd42", + "e1a937e44db723d507936a53c0113503fe60ce35bff3be778706d3c97d2efe21", + "42a45255f2ee201e00b9d5f804d9165d8168dd5bdcfac7ee7ac72b28733a67a1", + "76705193b98e75aa659ffef950ab456e1b08c296339df45af040f9477b07807a", + "f17d827029a048741f34e283b6621de5e400f90155db56878d6af1b38dc5fa20", + "ef6c3825b1ccaa905dc17b638aa55bc3ca7dd2924600e65f2eeec32b68a6070b", + "cf5b9f24a776cfa6fc928ec9410278f9deaa4efd5615e2799201c2e3718b087c", + "1151a6b9e6a0b3666ba850448d54bc7e37f63096860c995850216eed1d74be27", + "42477505e08325c8790c58f90a99eb031696a39c2dc8a7e01b75a1aeb346b981", + "d29b1d022769112c82848e644cf0d64b06b6f8e05705eab1d2c1a7e5c9c7601f", + "42a744f1a10fc1e86fb204bf8609313e448b77faa910ad83c263b3fd518d053c", + "89f874fdfa77e1b882b3a65c573fd15551717c031554432cf60f4960a97a510b", + "5203e18861514ec7680c92075519c1a35e36d4cecde47b159283364515cbe7eb", + "3b2a3c2168fd48adcc5847612e8f7940b26e7f96f55145c8440a4af7e999465f", + "eb221e7b1a4d03da4b8ccc8374cfa81959edb1e544b658b527ce718ccbf07e05", + "9285c3a36a721fc1125867ba9cf3e4e6d2775171214f87455db73b1924c082d8", + "2ab0de04b1aa67ff68b8e5ae6e3b9c22a94c72eee7a7c7ae8459e48ba24d0b2c", + "f896caa16172f5c428dfb14a57813ef807eacc84bae3a7d5e1b15366a1713b57", + "04adcc1911d932e15b193766f189d493860b0fce747a92b84efb4c4f06ef5857", + "2813b48b7f29e6a421989ef461679d7fb95965bf6317be51fcb40a4e5c27ae8c", + "4cf6d613c9e5308d7ddea40c86aa8475098e361797fd9444a098e7c52953a4f6", + "cad3925ad05ec58ebf048342777e96951328b1ab3b6db6780888f8c269b4b342", + "10e638abde47663f970dc921fb75a68f52772e6e12b83f2d5266b0c0d6135fb4", + "af36e868da80366adcd08ec6b99bc05692f02682c9451f9380b6e3b3666aa343", + "97ea0df2f1987f02724feb60b2fe13171b871880595995feb873ddfbb331eeeb", + "154bcdac9015a95e7c6725b6862ba07743d98209637948bc83f8cb70b7f35e1d", + "b17f13903911c95ba5736691260ef895a8af73eb29ce06f52cb28d5bce92a68d", + "bfad52cf8fe93a30a85912dae2b5c2a8ad1d1a603349aceb662a700596c8d69a", + "6e2532b9863da478e3568a994b7c08558e22d29473f2783767b50ee7ffd33737", + "818f468353b38d7ea8fc57cedf18ff94eb29b9644a4db23a42792ee99d6551be", + "7ba5ba4afd2badb6262cdd11115d015f9c00ce37e97fe7178ffb3a758837e4c4", + "ddb82c2b04bc2ff04ba8ed8bffd05d91c1a6c1c847e8888d48ff3a0d84b16c76", + "4667928f1687ef0a8a3395906b7fb8b1d668ce0c002d03cb81acba248ed6683d", + "058c582de4a3f7ee7a028d6e63d34b9c0644c683b426647f60853918041a7829", + "0f881e96e58875b7d366adfc265067a2c1df9ccab287a3ed626ff318f2433d47", + "cfd555b1318e4bc75e1d96a754ed4bf81979d3f391ab6a803c5fbacc229f2f84", + "f74f4c67681cb337edd1f1cffafd7d1f21715a8f3623b1520dcf98bb97fae54c", + "24fc4d3480d2867f31c4e748fb9c3a6cc2636e3fb366701563ba2969689abfd8", + "9fad209f59a2866b23dfc462dfe66c7308a611e508ea4435e029b818279b7594", + "13a6ff3feb11c5b55bb9b01704fc6e46269aa6e0716b54729249d960b6353f4a", + "295815e7bd0f4315b680934ad2bd441e9e5b71d31fe2e3a3838ed01289cf122f", + "f9e35e1758544b30802d4c5fa49c2060a8d341dbb2aa529e853c887f7a3f400f", + "3449d9af7851d751981665cce1d6b2481eb92b10d0dc9c539978076d9d5384bf", + "3aa55a1e964ac443ee2394b1804e5753140a7d7c48a24c7dff72243d92143db8", + "2c748945372d662e47d2f776bb5a47461b3ee3e5c3ab5b9c7a6ef1e965889828", + "bb98459b10af6870a1f87831b24c837f2b23dd1f714bff3b1586553814270601", + "37778b9e2788a028a94e10464bbad6730510349f67c324efef923095c2a10350", + "631c3bb993023f9a808f8874eed607d495c8b00ccfc96649d539cf5a04e9b601", + "2b0eea6801df998b64621a801cfb0dae0284fe819ae9069e3cbdf14ade5b295d", + "f74dd2f5ed5a601e2030805376f8b10d2f84e2d80b4958475016096066e3cc48", + "4e22f45376de56677635ed937d53375801b868054636bd8be866533478ebc795", + "1465f2c76ba96e79f010c59edf44b44cb9eedc391435aa99827e3805ad2ac988", + "4a76e6690b9055b6b3d59def2eaa52bad2cb7942ec385a901cc784478fcd3543", + "040ec4a33335e2ee3d49c11bda84d62b75fef480aafeb9f2ab81625981eb1617", + "9432ad31446feb55b9cbc30a44fb1e1d704f673f6f701691e7ad99761a041bb2", + "2301c64e97ab5b907f616c00554c433c3a9686fe5c190f314710219319083a9a", + "92e4cf2ac3ecd2bab219b87e201b0da593fe203cab2ec73e0e8c725e9c8a463d", + "4d4fba58035fb593d6b69dfc4496272c7a3d059c89943bf3264075861d5fd4df", + "b766fc7999ef2d30d6f01d4f616b401d67d7a5919d70552ede8e5259832e6072", + "942971b9f22324bc04bcd24c86a909e185eb1352f41b719d623a2c24d37b42f4", + "8aadc02c2e2433213e747145da84c36d281a14bba4d98540e5263a4f750caae6", + "f520a2950bf17f8247005ceb11d663a3d5967f743350ea1ecc42241ed8c646a9", + "9527503ea73b71a27c20fe2f7b7ee2c00c62494317f8e762659e7cfb5e39a3a1", + "61e7dcaba1c57bab5d1bfb7aa52402d8bfe5fbc1491f97672b983e466262bd10", + "ac3200f507ca770537b68dacd84940435df76633da49e62eb696c143640ed32e", + "747b539a5fa9d82fe621195fb4f82870df191ef5a16511fd48b7ceefe67d0646", + "0da62bce962cc3f3a0e81c0dbc7c6709311c421503c2bd3c62bf2cf63ace8208", + "1c67ff53015ac63ed0b15a0e988bb23848dbf8b5779e325b1049658f8f1b2078", + "0b6b6c2515f74bba86e63046c0f58eace8c7dfa06b2a00ca6799419bb8a77ae3", + "54559b93defa1517bcf17dec76b9915a87dcd24eabe03717dafd88babdd698fc", + "295cb05fb6730d002f9ed66b8c7341cc46b1d65360a399b7573b85e47c05c042", + "bd8b8cd6668fa902cf05f0d011ca159b5af9ad00c707bd944810b48597236fd2", + "f4f22a90ec913904b9f811b68da05e9d5fc3eb87806b30db70b8cbb09b4869e6", + "e1cd8a46c62d9719fa1a5194621bb3591e483d5ce2a98056f5dc027cb02c50e3", + "14fb72575b5aac7e77e235075778415e788d88da605d4499ae4b8aac1e4671a9", + "54b2c6d3c1dc2c4355c74279dba84acea65fc2f5b6cab56145fae1a57ae39a5d", + "87a857f77e13de2efbe499c3811e5c7548b2a8016506603f6364218d9b40e0b7", + "c4dfcd1b75678eb4ff2d0ad837bb31844e9ed08dbae8db83fc27fbf552f8eeec", + "66180f974272eb7e48374a133d8b7ef55c091c0bc1747a6b3da246cce857969d", + "19af701c55d47ddeedfd2712576bade542b279f0a4e19a92f5f670bea8b2dd92", + "2ea569bfd83a3681cefa293faae5b7c2e7b374d5766298a5f75f93058186a528", + "5ac85767056c3f1d68ba861899c2826cb6c88d91c91cd6da802f534cee16a888", + "b4f5ff4669e865417e4a0bc5909d70f6c2b999a7560d76d09f24ca691e47b926", + "da4a7d311a10ef6f1f40448c43538e4276a95c00d274be7d42ca276569a72404", + "4079c78d4caee58e0afd6ace66b02b931d971a403f9806244f9c7b15a5224347", + "eda570961b5690c442d9f7938f83a921ab8c104169f394a3eeaf7190ab9bc3c6", + "214857d10b37b3bf50644c229a6945a15db33519ea272959179aacc024bbcf4c", + "37cf63f96e1f6b4ff302bb5c4e06be1c6182e1de209d572bd1427f7d1f1ecb91", + "e84735c23723af293e959008475f368075246b281fa065459b474f674b794e1a", + "fc34af8b582650ecdb5d195af0ecd474e6355bfbfd1794c0ee076bdc8d541de5", + "e1ebbdd70de19d618cfb797b287758bb271eb734a0f45bf72dffab9bea640d70", + "4d00c22e854b311c5135b0e975c15cbece18f05c8dbcf733712a3adcf32c5d49", + "ca02c7edf590170914a5b327799a0a704b1f4f4299497bcaf6013aa97b603818", + "53c2d30bbaab3ec159b5d2f6074122b14b7c265bdaccc9b7325a9e6e85eb3ac8", + "722c34c15ee4621acd18119eca978b268d086650281a86400b2b017d09104eae", + "96ba0ae36ed029011d9c5980ed79da1914bf86da16a5f0ac8ac56aaab5e14407", + "0d90be6e02e54c4277ff5d9af895670fc2902917559d586a18d8a6aedaa82f4f", + "18e61f2b4384158724a0287b649cbeb6b38f49e23f60aa7fa6ccf0e0c25328ec", + "29a721ad8112a4dfcd0e42e517216fafd6adf8f581974a1e01ade1c3e324a643", + "50754a3cbebcf3d3637a66c4ba1d6ef4e18a004d7035fcc82da3f9d7d43c1b49", + "04d3440320c6d57eb495ebb818f64691397e655552cef1f21564b56698f38247", + "3921dbb4716b9145c0042d2a0c5381d0191a92aba37b9ce87c8d542814e062a6", + "1cab15e87cf94ef0e98162aa0f1678fe8dd2c4d27560b4154b2e56de6a0abf88", + "71092bf0dc2ff6fe701d2f879007ef60fd730871e36bdb20321c80bebd7a446e", + "78178c4de95f498a11a0c5db35fa422508b4a983eabc7a0e6d73ecdccb6111aa", + "d76e2b86e66066abe0fb6406436114f55e20877e31db4de520936c26acb838d5", + "ee81884c842aea6391e2c4033f4199c6f634d0d156e658a6d1fff572bb11d47d", + "3e42e997f3ff0d0a734e349004ea6ce2b2535fe9fe937668c646f2bd58c46ccf", + "30f53617ecda9f520937fc09aad84cbafa166bd04d4121d41fb38a4233433e86", + "852aad8c9b65477c499b2b5c2d2e9d6e4c186b7c0ae127bf6014d718689fdaf2", + "4c525447b07210679828f1d607d49b2164c035658478a9c49cd8aa3dda441347", + "0ace4e9159463762d7cf4e908efa8183d68b0763c849bd7cb9e404c9173b0bc0", + "62a4e976cd786aff33f949ed78804f99c7cd54c962c37ad67b39455602451385", + "8d6d391f9d9c2a14408df2617c80049b9cbaa01563c7731a85ead65fba5c5b60", + "73d66383cadc8ea37511eca218a0f4baba86aa41022c598ccab6e997111c3ecb", + "51dbc1b65a4e05a4782d588e6782361cbfe0056f6d117fc01b95104b785ab143", + "9daada1e60332b79564cfc42c3ed73f3880ffb8d92950792a8ccc137ebc6eab1", + "183b9da1bff0ca3f047ce22a5fb79a9d7261eea54593a6774ebef206fceef4af", + "dddb778588702e82b07e0682bcd2804d949713cc9f500ff25c335bad81696d9a", + "fbfbb2efccdaed7f729458cea0fb1f3f51187a2b8cda1a286bab0cfed074d16a", + "7c67ab2ac057d7fe782e704ec80362f4c6d83a967e4ff4353e796aaaad70ec96", + "1d93fde5dfe1d3bd8c0270500ea97d73e064cca7d07e1fea7303b2ccd0312136", + "521c3f6635c2b5c3f5c49e19a2c385b5bc8a473b247fdda6f67cf3a8d6990ec1", + "ecca1a4e0e14f32b7ca102656043f08be7e4ce997b1cef9f8fcea90e84a49812", + "85120303938639b8a3c28af9360816d8266642d0b581411e65e68413b4090108", + "3ce71081d959afa09ecae833724a2d647578c2ef0a1a972de1f468050099cbe9", + "86f17a274697c0826d68ae07b8594fc514fdf3877a840271d87f59a5f79c6ce9", + "e4a1fa15a593e7ec213883263df05e99abaa5efd0fb9077f4caad2f841e3c8c0", + "b7acbcef82bfe7c5ac722cffd93d536866b6f5634b994f129aae354491db2237", + "875aa1eb922a40946d487fa337b5e98d47017bbb3569b21f3fae421fb4a29b1a", + "ed22466c6c1b23115de693765285029bb12c4021842a42fd014978650512296e", + "e65c17a7d1a4cf625ee7b9d36fd4538bce22c4a4d05d04f43c77ff7dd13471a4", + "2429e30b3aba437c7b4b7fb5c33fccae85cea5c200c834b92668e49f9f504078", + "6afba96b6bbd9845c290bf2e221c21792c7fef2405790d1d99f5d5889e0c0507", + "c46b9719c4e09079e5d4ba2604dbfa5cbfb0d4faafc33ebbe6968fd108a7a1a1", + "31c3cd99fe2d8ea4c854febbceb1850f5e24047d18d023a8e0edee5291b4068f", + "ec3b9029d990eb56231eee1d3cc35746e472c6c9db50ce780f1196e50b80f896", + "726c0cc79b0e16ad4d05fec82376202690ff1677df834a17d01e645bd94236f6", + "fdfecced8e4a5dc3d58730ee0102a0c466ace0dbaf553786ce605a7893beae1d", + "5e3271907ac2246f854ea02ae7c2db8a0b4dcb533abd9053ae6df7bc2ff47326", + "af55570de945d82ebc8caa49995de92d867e3ba28614340424c92673812e887e", + "8386db93ad0e05b60b00958acd14db2750f77b7a473b8ded15618c97c2ee81fe", + "fbf99e21a35f8f949eabfd40faede15cce1bb93306802895534932049c41f285", + "eefa6cefdbf9f3c817a9f0a6b192d9c241a5e5bbff7041a6bede6f46f954f5b4", + "cd9d43c13177eda82e91fbc200b9339ebbde557d509c47d3aec58b6220549892", + "845c47455cf13666bc688adf2598de0f53bb35977eeb0404a3689e9f021435c2", + "dc62dafa553cdb5e9920a20eb367f6b34bc240da2c8e52f3d53219ef8eb0877a", + "ac8d315acc302829207b2e676d7de96b4067ebdcdeb2c36fdc1f99cb75c77fe4", + "e5af0bcc4c4db93b5df46c379802cf629dce7312f56fdccbebb35b50f6fc0d6f", + "b3a60b177b4dfac086419e2476572fcd30b36370173e33f00aebff60d10e436b", + "01f881888343b36ae6d05c76eaf8403303ca65a25c91d6eb9369cb036a9b0833", + "8662b8efd466384f99dfc77264995fb7cc60636713724c7ddd33b7b4cb96eb45", + "a61ba48b0fb389ae2d29f3b68abe9e7c408bd4eb1fd51cc1ef3cee9f758a2caf", + "3c8de3a849240de85182ed904567934247718ec8063b8d2422d50ee43eac2b6a", + "b451b987197e3f54fa03951d2c82dd4e53c326efe9d2a031e8c610a6c70f3d3a", + "12ae6d7b4fa47f911e62d10a14e6eb9ef69c13f01e9d46c3e8f8e445649df127", + "14deafcde9ad92f6802b1c0eacf440e713e0e9f45cb8f982090e04f5bc5a6da1", + "284ffc69dea65baeb9b592628ba149c41300615a13a25be91cb05ded62d5aa3c", + "9464a89ca9c02c056b9402e6aa045743c52e1ff062dadf99d95ea9405badf3f7", + "b12ce0fc79e379c43c6ec2eba66645bde30fa02f1860a1b1a0adfef0ef5d82c6", + "c303cdd53180db509ee39552da17ef3febca7336e5e889562b8dddf6dbf3a46c", + "531c172cc022afb040d65133f0502453d7ee404efc41ff483a3eeb5c9d775047", + "27d381261205feb0e7c4917375a6a73a3d10b6710db66a95ff8dfa5a9d41d4bd", + "2e115fac43e6bf9be228ad266e8db28e942f99ca038f95a1a3340a8be03b9140", + "c0efc4bd7876038b26b9ee7aa1dae3fe8cc77c292becb1cf461f2ea405e18930", + "2fe1e043aeb7e38bb65b07d77d2fe04f49e026d5a6732af392185f4f136c91ef", + "389cb7c726c95fac15b4d60abf86d8f548d00fd3d9ca4c409df215a275a2d77f", + "f37bf1a6f1a445b6f28b32d24a4f2928dac6036c966d6fd883186050d0122bf8", + "98100c3449168dc781a69d59b58a0f9bd0ed4002d7ad180b9582ee6a26890420", + "7da9fd621b8ba27cb01fa201cb1908b208891a023c1c64fb99d69371505cb04e", + "173d04adb61fb1d3abd672d89c3bb7023a67b972144bfed62f7efde00b779a10", + "be69c793df0288ee50eb80ba0494997ba379b3606a70093231bad9db9c94f795", + "c64e0c432e0b590c15463829f80fe87d5dff52a2a72b8b376572fa9d6fba8fe5", + "200e7665adc86a94a29913a81d9a04c7062a655fd5c8bf6d9932f49abfebff98", + "cdfdd873e5690e9313b0ec438de5d8081ceba364e4e0a28312b539927c6db0da", + "445d0662f5e935ca1f4832696b4853d449bcf6dea62f0ab63d88a9b1c6e62829", + "a99f1e1443f28cbfbdc433be98a23f43dc8e3ace86f8afbbf953d590930ef464", + "2b7c9b3d5d6ce2fc154a9c18f819e4752c3ce883d53c45cf474d1fadc1da7161", + "927c14a6c870f44b233bc0d6464874dbd4532095947bb040dd91134348119d97", + "65f4c40ce3b00fda1de0b89ed2b20a4eb0bceddefee056515773a7cffaafb731", + "b1941f566e61152a96cf6333eeffc06a7f24f794fa4c2db2c841d157d1a2d678", + "f69091bdad9e0318e8b3dbea896740a5d4cc2e8c9a7e0f8de9c53d675e9daed7", + "080eafd11083f204db3d4fac7d1e417848d27bac3363f44fa86aad6bcd560701", + "81a4e23fc946323d47eb0464547027ae663c857d139d9fcfb1320e9fb8e2a0a3", + "e100ef0c8c604ce38b5928f05079905b36b22295ea1adcd4b1afa5020de5a92b", + "63a14c4bc05559e057ca63684353a0292bee863a938b1a14b243fce5cda040cc", + "4c38973e813b67cf701e7cf589fe5361e1502094b24203908f1842ba43abfb6b", + "f1b9dc2983693e147d3cfd01d245ab83910a43952f4d557cfa736486331f29d9", + "2ba54b05e20d1fe46ecdb7be5690f2c22c4d1cacf73eaa21ad013c1979fc2e6d", + "c5fc9a9e101cee2e6befab1db55131f064164612611d078798389e4ccb85083a", + "7874b387228153ec2da4c34f1068a9a37c14a41b2e4c012e2721d2c7357347fd", + "45e2dfae8475f78cc8b41e61d7e26c629071f730a1d0386f53b99a0d07988e9e", + "2c66ecec3a8a82bc91639dbf758bb1d7626c068d593961c3213f6e59893aa4ab", + "567a32c35f25764d3ae3007608d8c7294e7beb6e3a2a1a524fe79165d0695477", + "2532974572efa8615c0943e93a45ab5498c0ad600fdd568ee51c2f7d94b8290f", + "385a79e83f5ca99c3e5efe446aff3c81b582c82851120d007b18fb96f8aa5c8e", + "53ad022c5a130bab0d4fe85bbf4f6f8fffb0b0d7cb4ded65dc6ef6b9a2dc2d2d", + "755816eb525f4f235d221208534cd713468e3268433613b7b4d719e79dd7d812", + "1b6f738cb65918b3d624703d1871482ffdaa4c8729b190218380ecd1a2dee3e3", + "15d5895219e814b0b63df8fdc67212df2ba694288e2da6c9614594808f0e11ce", + "7be0466d0d4467a8ca3e87c63ba42e2bf638d30df07ff8b31f1cb83558c05be7", + "30692cb41fdf5221e0e1096fc9e6d47621dfabf577e2b7f70910544bb7e13071", + "658b78baa647b81a056a4e0834ddb1545fd4e5a874fdcf843f57e6f0814f5044", + "1c5b12f7682b1e442df140259c0f5648e720ef93be0324bf81ef15a72b7bd214", + "836014fba05575f80d7e2d151aed6386869a43efe5f4c02c0e6ae575b285f6d9", + "9ada4dfa24ed5422a79e9f1c44fbee29601bcb594b1b5bfa6a8dab7b3d7fb698", + "b57dea54b35c45a6f86b308654726ca91f4b5dcd778861719d0a090768f32d9b", + "b34e09424d8165a6abaa72bb75641f8233511680943c929aee8f177cce1b3ccb", + "0e11c77b5ae210ed3c5466b1b96d7a9ad0ed12f939dd6e0305affafe0fdda629", + "d0f42847ffb2e8051cc5abe56a632198e1becfbe00db82bfd1bcb19e9cbc1dd9", + "750da992ac17643cfdad3cadc7429884b2dde2b6ff4a23a94c555a1aa0253c71", + "4d6f4df4bd44f1043830aa1980848123f9c40a4ffb34469f6318a6fd48224fd8", + "fc1e0025095910650ec5f3f3004eb31b479e7a7d38f98b82da2226e2e472e6d9", + "d49495cc73eba2929390437646d74e3c6f1812055e4d3e64c1b446a060df913b", + "e1057f4fef92f56e772b7d945ca23a604ad4f0a7e808815dc1f0127471ae3215", + "92d7e1bf8f4a1100eff80ccfc6193c659b509e3e1f6285ca77b5f68fde94059e", + "d6f09c5b731e4ff18c3e7ea64886311bcb3c408f6cc88aea210ad53c78d8bd02", + "55e6cd6b15f76c5a2738ed33b382f927ef1791739e15d2b993660b2bdf3e083b", + "e736c652fd7f5259f8480c4f088e06bd8fdfdf4d981e6f06344da8361378cb5c", + "8ba786575b4eeef8621e169571b2e86d0a25419054e7b094cd1c93c1eaa40171", + "49a7dc297d0031a7e9e57e8c2f5ecc0595a2cf0d2a111f94b46203978b3630db", + "a3a03c04fcc39b06addc42ffd6cfde6fa42e93a070f537a45c4ded16f29986c4", + "4c8c1cee3bf02d9e3bc4e99480374c1d216d5d340f17a30c1f5d6e23920a22c1", + "d31902df7da1b478f340859861d93821d61c49dbfebda438934edb3175afb998", + "0ae412fc4d28afa5ec6a0819fd410b54cbb054a7d08eec747f13414cad7b3703", + "93627a9140c973f02085dc161e0fb1b076d200a6b6fba66f3e3ce4f00db165a1", + "f55514e70859322b642bd28755a3f71ca5dd8fb199f81e674a66b6ffa263eb5d", + "22ec89752bf94a15697b37b6afe55b01f72e27336b2280f782dbb6c211e9e302", + "d6447a9fecc671f77735a6cd0e04ffcb0df56b99765be029c6fdd6e701eb57dc", + "4a109d4835a7358df6770d4325771748754109011ed364126a5a4c17e80714ae", + "babdcb8992d2437c9869f9f5a17f378940a9f09dc60a17be5bbd21155abf2c15", + "bc714ef5829b4d639d274850e7b039f8bd0cce3237f62852f959616c2b27ceb2", + "4acef230b6ab5dd77a6d813a3f920c76a295f197cbd3e0d169940cffa5e4a956", + "0322dfd9ea77c1e8d519bd548bfadf5df87809d0894c1e4373b6607250c6a0ef", + "c53f2e91135d743b025f09c09644a9ed692ac2e7c188e7291086f1c3aa9db2bb", + "20870a96ad0320cf9b877fa7ff15814fb63a3606d8d04f5e2db2fc642b88aebf", + "2a4abc16f6764f89185442e11a8ce025307fcd4eee1efe7041c1273bae04f04d", + "c222953d51416f4500bfc85d299838f783f205f2fdfa3e793cf16a2d298aecc1", + "2fbb142ee5d2b61de7c3d446ede1a9945272adf4dbb866100fde41cffca86c7e", + "64273debac8d266640f5e08c54f4bb3237f847a39e4182d0bef40f6ca6c02644", + "4693d78dc105cf551cdee16b0649dce48e3af4ed11deee027372e3589f448595", + "88db4c5056c66df2c653a111e0f28a65b6fef0373727a4b083ad8e2eeef13dc2", + "ed8bd6db3e06f6772ad970d6da45f342982bdb45b09e03975d1a321ea50ed48f", + "dedcd14539675fc737540a83326656d511991ca2fd118d0d28d02b4b6b6da218", + "66a37cb492d7d3e34696844b28c1703ad10023c73820143afea8ee34d4a26646", + "fe9d63b76ba2285d6894cb24151522c4f98a402eafc38ed091f701ceb279776b", + "8e24ac9c3b9331162079b7bc00f8d2c9ffbe0380d50eb36625cdcd47d1dc4e58", + "b52e498ff4a75025d7f97ee50ded248260e88eef4b175f26a615ab13309fef97", + "e9d3d01be3d95d29d7d29194a6df85f77c3782ab72bf9409ef79134ba095936a", + "cf8904c8df1a9f7cc8b765121e3faaf4d5c7e824971dff779728261f09f153e2", + "0aff1f7907d5438a1af7724680a1de72cac251902a9427f3148957bfe95ea1fb", + "9327385287fcef27f9d2c9b1430e1af4f1b13e2180587d4b6a92a356f21f218f", + "615d6977aa75a58d2faef4464abbb7bb1b7526bcf3b47cf880a9e2dffea87b28", + "fd4ee634db05f9da1992592051c1ee4e8d77d13375e09a49a4be80417ef927be", + "04a5826cda639b37979ec9b489cd28da1c22af5c515c8b621adab116bb04f9ce", + "36e38674d5fafc9dcea28be27ec947e336b2fa21ec7ffc90e6993434d945e0f1", + "3bda2162057d0205df6f23c9b2bb89f5385bef8f46e412d97063659be7304f8c", + "54b6351afb1718b88343b86efb80e0f9949f3aef0ca63066e7a2fd4f5e62a5ff", + "d88ea1d334378a8de71d9c86f54a070eec96e070e508526eac8741a355a2bde6", + "d3e693ab231f6a8f01a9251a561f6fbca93c6277871a488a5ebf5ddaf0cc666a", + "4c7a438c50c7f0b6b1c0bcb5896a65b116d9116c16a98f3b4b566e53398d1d25", + "de405edbf9fab41daa7f18945a66d3d80617d43158414bbbc2323fed8c18b9ef", + "253542a5539d17551b9b8e32c683cdaee807faaaefb23aa15462e44bc89eaca0", + "65f33548e95eb5c067102a44e1e9a7e0dde7b7b23053ad7f0a13329701c678aa", + "298e9b9b0a9b23dd71712988a97230061b7ba3bc4a326c348ea59a9e99fa523d", + "29356d5c5250522232619c95d659c6242d8bb0cf4e4a0ae63198b50071e618cf", + "3337578afb7db139bc5ae9eb6da6c532d429ebc3fba197de788440ea909a4cc5", + "758cff66ea378492d58e9c9b572802008016fec5be6062c9370eefb09c6dc2c7", + "ad85b4fac095dfe64b46b5758bf39b1c716e023061b3fb67756afb34eb60d19d", + "c96370f42781e63d648121c093e88e755f456dfb90781891bc51b31c936532f1", + "b288794d0ad0e3b04e638adb5dd10fc713afbff6d5f7ec0445cf64ab3a8188b0", + "ccf2dc6cb2091c74f4b2badfe5263d0d658c951ae393f2b5b16be9877c9b5d80", + "08810e81149a503e58bfa1bb4ea104ce48ad7d3cc16d0e283a4ee1b40150307b", + "d176414202119a08be0198ae8345491804c27bb99056ab0a513b0e9c4e7bbb68", + "58d73416eeda96720cd3783fac03b8817993183f44bb0e29c92412a9053d98e2", + "d0194eb75473b6b3a7e4ec634dbddfe4c6520fa6da83ffe84d8e340b5d52f5ec", + "46d92d02aabac8eb684f32545ccb0e24cb0e9afd3e6606e465b55e612188fec7", + "10e18a205c0df296b8518266b117c983ffa5cc25cae121f740361bdf64ccb73e", + "37b5624b8d3eacc09c4d1270fcb3d7a0937529f158c658fdaf5b48bfc9097c79", + "d28cb2f21ea4d04629d050c16dbd119545d0e45bed2618242b5ec2bc7a485adc", + "4c1e1f1c2e85366a9132a14f9247e2ca6cc43d4f9e23f32402af94ede290b597", + "6879c96b585c2b1a058644430a7bdf6b5192990601bd8dbe7dd099281d76563d", + "48de7e80aad521af46bdfde4af014a040bc79f082da89afe814e518c9fff6c20", + "9622ac1f9a92c22110455de7451f9d3ab5f47c5e1f2522ca4e8b2a1945e3cb92", + "81bf8b177a711f422aa95d646a492a17042a4f5740e183737438bdb013008428", + "585d4987cf6da17914885138928215ce768b7e377f175e377d6a3961bbdd0327", + "87924c45cff29dbf5738b6fa42bb2ae8a624f64990524de14d6bae294d0ecba3", + "15316b944c17489ddc0bb5002dbfa2534f7177f7c80ffa439347388d5bf75dc6", + "a740dde7eb1cc1b7b8c1a5b9470b344a01f4f59b0e1ce817734785770f6eac24", + "39af3c24a41ad9a34137ee355fd80295d34ddd7077be4bfdf46b5ac9cb14d042", + "4a4a59484904ae6d2ef610d9356570f36def8f93508c2950b1ed2da12c274968", + "7dac7a8f9fcc34f8318b1486e482776a1319f43a41f812c298c2354c1d8b11cd", + "eb284154c7769dc565ea552f2bb1bb5bd4276da731ac4262b4eae1448bb79ce7", + "7d5b1f19001234bf3745c57ef8c7a27837a2b344ddbed7f007a006dea99b336f", + "06159cd56b14b214c9fd60b7caf693eb535a8b36fef52b14d81fe2b538cc39fa", + "7614f81b076eae1d2dd32e1956ef9b0bce37a58c6a045a7e943afe2e17caf79b", + "82e16c2b37b87bec209958f5b351cabed752a74b6560ddf810b8ab21bd5d5a5f", + "accb18d9450f23b306a906796cc98589872d846a141dfb13b3cf0b3de88dfd3d", + "fd2da2bfb2b8f9dc1bb45d2442533229079a8a58d91723d8d60d2ac5be9da38e", + "21a02450c93f4d4917d45f7bfa814cb1c7c4fe1b34f38adc7a615cd28af10580", + "f931e62f8ab8f9d987d955a2e0c47ec0d4d36dd9f16b933c20c07d9ed0b1101f", + "a84cd76118d9bfcccce6dd2d07fa7e29050f112b62022672cce025e84e447aa2", + "39291da1e570472be83637a06f2525aa49af9a01abee9a796b20930e14fe2c9f", + "5017375d221dcb5ec46a46c45b100b42801e999d3a8c7deb641403c3468e1000", + "c892eff481ee68289112630a050d1fd6b58cb29e18f34c547b7fd1bf73070892", + "c0da24e7246497da2437d3ced235727c7a567f57fa923d328ab6b750a51bc7fe", + "a6fa858e8a67598a5d079c6dce741a023193e61fc72c21092a005f6be0fa4e19", + "d4eea0369c4772c575172eb5f9eace7b4151f2d537c474c75b2bd461480dc20e", + "1c6b1f2c142426d37bc9153ae1c41200f66d8107fff748e9c7524e6450c79f2c", + "47f7d44c43958509536a1f931109bb52ebb00ae06c28b49ddccd1158ffd67e27", + "d22b77a2373fa5185a6c0e2cbec23ab550f5d976dae24dc4a9fd2663996354ad", + "cb4a46a838281342f2d863dba4a19d79ee235659f3cb1923d10f7bb305bac931", + "5fd0fea05496ace61b822e6949326f79f7792053dc450914aed7a49e030a279b", + "57f4190de9110b84d73a5809b3d5ce9435b7676b24c05f66728d83c2144a4b94", + "26795425d888ba302a77c1cc252ee11eb95e42aa6193b2f8b59cd51fe10ec83c", + "a4415165b22887a9e1e0cdc6cfb8b11bd5965ded69e152a9afd038462054725a", + "83eed4368cc5cccd501668803062c25746faecd6a64cf713779659aed3b17c1f", + "660ac87882dd87c66ff2e1e8856a910559d132cd1d641cff6b7bd1a988382d17", + "073737298a3c9c3e980320235518d45133684970d7b1bef07f30658cdfe5bcaa", + "4e2c2a2edd818e624e79c226264757c3d1626777c0f8632336c51fd00191a72f", + "674179eba9c868a8a9570fb9c89f9263d5566d5e2c128ec76e5f228713df1d9c", + "09773953ea11e6b0743e168e33121d48068d024478ea82950a1657b7866aa11f", + "c20ea4e80ba78fec1c266886086cb92b1d79ce867ed200be372d1e2be29f618f", + "8ee3f0f3aa64d0622dbbcd79a0666c4cd1b70d5b0b885c99c76e768d6d8b2351", + "10102281b33e8b0144cca6c8cac164ce7bcf3b6fe8e80d7af033bacaabac14d4", + "669b1876f548a9bae743a47d3b6db69093fb81fb445e30b96a8a08de584afdb8", + "427e02462a059230af3e8d66a04deefa7a4f0bf196c2ac71195bf2dca0e70354", + "8f0328b8c94fe3db6bd46c3f0ed46cd5baf5fa83474eb2480483221e0a7758c9", + "9cfa92163986f4502a922432866cf0872041397d1507efe3c09f17212c6d8ed1", + "69710191cd712edcdce481a043d1829cbe5c6c05d5cebf5c182644403055469f", + "b1683c1075f00bbb61e5d2ae53be86c40276ef294cff201ea966e285f22f5490", + "2c41f0d97efdec788e384b3ced7e9dd46712a3bf43e076443290550d255f6457", + "384e61f5fb29a0c0130a4b4ab0389facc5441ae22c0c84ce265da69a670203c9", + "d388ee05db8dca588d750e5f1d6adbc7809f072cae548107878b646837f320da", + "1ba30823c05426ec600e310cb095527551d105e5665827ec2f6840b39502f4d6", + "83b9f0c03a7fd15cc481fbf900c55a076d654eef9681e970c4c11f7862753268", + "c1aaddea54c87b8ab7cbdb747c83d3aeb4774517b3f228c8944e2e723185c4bd", + "6949bb9c29c98d1af099bdbc5b95af0c2f5d587c9098c50063690b6cb66d5560", + "787f0d5ce660aef5b3c2264a8863dd3e79bf1810a1d3799912d414aefbb1eeb3", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + ], + "reverse_peak_checks": [ + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ], + [ + 20644, + 558, + "a0574317501f92f440f474d87321766e39d9c436b3560257138c0577afd625dc" + ] + ], + "ideal_peak": [ + "850", + 20479, + 558 + ], + "erasures": [ + [ + 12813, + 798, + "103" + ], + [ + 12972, + 795, + "69/2" + ], + [ + 13098, + 797, + "35" + ], + [ + 13224, + 796, + "32" + ], + [ + 13462, + 770, + "61/2" + ], + [ + 13471, + 771, + "123/4" + ], + [ + 13482, + 772, + "127/4" + ], + [ + 13499, + 792, + "2" + ], + [ + 13505, + 773, + "30" + ], + [ + 13525, + 786, + "117/4" + ], + [ + 13526, + 774, + "117/4" + ], + [ + 13554, + 784, + "121/4" + ], + [ + 13555, + 775, + "121/4" + ], + [ + 13584, + 788, + "111/4" + ], + [ + 13586, + 776, + "111/4" + ], + [ + 13613, + 790, + "27" + ], + [ + 13614, + 777, + "27" + ], + [ + 13634, + 778, + "1/2" + ], + [ + 13656, + 778, + "62" + ], + [ + 15568, + 791, + "61" + ], + [ + 16024, + 793, + "2" + ], + [ + 16822, + 794, + "2" + ], + [ + 16888, + 789, + "108" + ], + [ + 16915, + 783, + "121" + ], + [ + 16918, + 780, + "121" + ], + [ + 16931, + 787, + "111" + ], + [ + 16962, + 785, + "117" + ], + [ + 16963, + 781, + "117" + ], + [ + 16975, + 779, + "108" + ], + [ + 16997, + 782, + "111" + ], + [ + 22801, + 778, + "0" + ] + ], + "native_seed_bits_per_tensor_axis": 5952, + "scalar_seed_bits": 18592, + "division_residue_bits_per_complex_coordinate": 578, + "tail": { + "normalized_width_one_rms_guard": 8, + "normalized_width_one_tail_guard": 11, + "tail_exponent": "8388608/208355", + "positive_taylor_degree": 64, + "positive_taylor_lower": "221274610405687194622256640907051079082566162458698261726443090221630998529116466252279087580029341017081393282568264813021918304960429539038463683276930730360193367063834303566587994453253833676952418486364183368686077683754063801474896434484818862632056410090322262083146928276258563590527135775320252436892547430087393057341578921280052402328690733525734461363209312707181831010694404434837951346962585763675033773945638507/724158138451097979920055054599479601082273996631031164812132390029753907910241022519827602650685608011264962924524986171021685117092308625723143500932891459896448469894211858639264250954998598793007570506496563262777944041461338879876664060850733399848389757609049629291791099531173513039348183195798517591310432629746214235429077853732126892111875704814401254668927536417566415138935553841292858123779296875", + "failure_bound": "2^-40", + "union_changed_fields": 22803, + "width_one_binary_grid_rms_bits": 12, + "width_one_binary_grid_tail_bits": 16, + "width_one_binary_grid_tail_exponent": "16777216/208355" + } + }, + "finite": { + "pair_inputs": 2401, + "wide_pair_roundtrips": 48, + "scalar_contexts": 2015, + "division_roundtrips": 5140, + "mixed_seed_trajectories": 32, + "semantic_controls": 7 + }, + "caller": { + "initial_sha256": "498af4a6ffbdc0a96195b07ac872313e42882cc9596f28401f77fbb9d8ac65c1", + "output_sha256": "a65347fa80f14a934b7fd10cc5c51c3a82c55be1bae5cb1a9138b041f53b641c", + "retained_field_values": 54, + "peak_live_and_retained_fields": 824, + "native_seed_bits": 5952, + "scalar_seed_bits": 18592, + "division_residue_bits": 295936, + "max_absolute_payload": 2160, + "all_events_forward_and_reverse": 22803 + }, + "endpoint": { + "decoded_public_fields": 770, + "max_squared_error": [ + "5651615/8", + 568 + ], + "squared_errors": [ + "1534", + "1425", + "20069/8", + "121077/8", + "2481/2", + "18009/4", + "5857/4", + "1355", + "19555/8", + "4485/2", + "5879/4", + "18957/8", + "13151/8", + "10853/8", + "726", + "11697/8", + "1482", + "17995/8", + "2673", + "14107/8", + "11715/8", + "14715/4", + "7467/4", + "1746", + "17107/4", + "21959/8", + "10083/4", + "11947/8", + "32055/8", + "19959/8", + "4213/2", + "6319/4", + "26765/8", + "4769/4", + "50335/16", + "20321/8", + "1286", + "11285/4", + "9987/4", + "28313/8", + "1693", + "9241/4", + "5781/4", + "4431/2", + "5869/4", + "10883/4", + "11123/8", + "6925/2", + "33713/8", + "9523/8", + "20059/8", + "10657/8", + "16723/8", + "10799/8", + "3844", + "12331/8", + "16759/4", + "5461/4", + "36523/8", + "19409/8", + "1663", + "19483/8", + "3033/2", + "18755/8", + "6773/4", + "4267/2", + "22457/8", + "7723/2", + "9447/8", + "16697/4", + "11143/8", + "2628", + "12811/8", + "19837/8", + "5971/4", + "28903/8", + "237", + "21269/8", + "19119/8", + "6115/4", + "1474", + "4633/2", + "10703/4", + "11653/8", + "4661/2", + "1360", + "2705", + "9409/4", + "10793/8", + "6173/4", + "21737/8", + "5729/4", + "21177/8", + "228405/8", + "12585/8", + "8615/4", + "2043", + "14843/8", + "3025/2", + "9255/4", + "27555/8", + "11309/8", + "13083/4", + "9875/4", + "20807/8", + "10961/8", + "8571/4", + "4531/2", + "1675", + "8951/4", + "5303/2", + "9675/8", + "7849065/16", + "381457", + "660153/4", + "4189/4", + "2518385/16", + "224647/2", + "1045773/4", + "1720385/8", + "1549181/8", + "312877/2", + "367127/2", + "1273629/8", + "694709/4", + "3542353/8", + "4391319/16", + "2835521/16", + "807589/4", + "1364297/8", + "486421/4", + "145907/2", + "135361", + "730685/8", + "1079817/8", + "85876", + "364235/2", + "921507/8", + "2123793/8", + "976889/4", + "589229/2", + "245629/2", + "576927/4", + "1434697/8", + "1004675/8", + "1155199/16", + "296035/4", + "1462379/8", + "905909/8", + "1237607/8", + "1536693/8", + "1180581/16", + "811965/8", + "553545", + "4147529/8", + "797509/4", + "1846153/8", + "2976699/16", + "241183", + "1738145/8", + "2385821/16", + "1468277/16", + "461093/4", + "1992031/8", + "4627659/8", + "9607115/16", + "2000181/16", + "634755/4", + "1531207/8", + "4768995/16", + "1333793/8", + "821737/4", + "126658", + "600213/8", + "1835301/8", + "124166", + "1041793/4", + "430781/2", + "699319/2", + "4826753/8", + "2835951/16", + "1274229/8", + "318059/2", + "1773039/8", + "187134", + "986185/8", + "4180155/16", + "773937/4", + "7073957/16", + "674925/4", + "572091/2", + "153628", + "1482515/8", + "1097629/2", + "3553971/16", + "2547297/16", + "3459353/8", + "1181695/8", + "837239/4", + "3161351/8", + "2500145/16", + "613137/4", + "2147029/8", + "556331/4", + "3825089/16", + "176445", + "1475253/16", + "1509181/8", + "1615383/8", + "200528", + "220464", + "444987/2", + "1364663/8", + "690651/8", + "2005675/16", + "577177/4", + "2900703/8", + "441303/2", + "212751", + "1041237/8", + "2012543/16", + "226143/4", + "369631/2", + "793659/4", + "94391/16", + "7739/2", + "90581/8", + "85613/8", + "26095/2", + "124351/8", + "143903/8", + "173847/8", + "48017/8", + "33961/4", + "64841/8", + "79827/16", + "199783/16", + "97845/8", + "90509/16", + "35139/8", + "9033/2", + "56295/16", + "161911/8", + "197253/16", + "57461/8", + "13509", + "14717/2", + "85089/4", + "174705/16", + "16268", + "51763/4", + "8121/2", + "291963/16", + "26257/4", + "102069/8", + "156459/8", + "45485/8", + "35757/4", + "278951/16", + "16430", + "193121/16", + "58181/8", + "132469/16", + "265341/8", + "59429/4", + "72571/8", + "124503/16", + "13673/4", + "146339/8", + "6478", + "7445", + "130235/16", + "54293/8", + "4215", + "34199/4", + "3029/2", + "9105", + "3642", + "156727/16", + "51157/8", + "9237/2", + "34675/8", + "1285", + "9325/4", + "54715/8", + "43621/8", + "117177/16", + "34953/8", + "45549/8", + "5664", + "106429/16", + "1889/2", + "49561/8", + "7429/2", + "53437/8", + "105817/16", + "5412", + "32557/8", + "1046", + "3971/2", + "37057/8", + "83427/8", + "108273/16", + "4969", + "28783/4", + "8151/2", + "304051/8", + "2244", + "30735/2", + "7086", + "315245/16", + "294249/8", + "37693/8", + "15069/4", + "1269", + "20843/8", + "254663/16", + "19977/4", + "16227", + "76813/16", + "105259/16", + "6367", + "102159/16", + "1805", + "78925/8", + "14515/4", + "31273/4", + "30051/16", + "36963/8", + "28063/8", + "1807/2", + "20793/8", + "47513/8", + "95197/16", + "63915/8", + "17123/4", + "102051/8", + "10829/2", + "155785/16", + "9477/4", + "34499/4", + "15440", + "187189/16", + "30775", + "154453/16", + "274", + "1879/2", + "12157/4", + "184567/8", + "42139/8", + "141737/8", + "185269/8", + "41967/8", + "4243", + "96843/16", + "1628", + "6915", + "3421", + "146449/16", + "202887/16", + "4193", + "59581/16", + "1038", + "48969/16", + "90259/16", + "54163/8", + "30281/4", + "18035/4", + "35209/4", + "14075/2", + "212169/16", + "3703/2", + "34397/2", + "6925/2", + "83559/8", + "42585/4", + "15283/4", + "47263/16", + "1997/2", + "51941/16", + "145465/16", + "34651/8", + "186909/16", + "41803/8", + "26485/4", + "9655/2", + "13259/2", + "2221", + "45593/8", + "11255/2", + "44629/4", + "25227/4", + "34725/8", + "25601/4", + "4779/2", + "19229/8", + "36739/8", + "45335/8", + "97979/16", + "17525/4", + "40443/2", + "96379/16", + "13413", + "10044", + "29739/8", + "1751/2", + "21079/2", + "87099/8", + "175297/16", + "11774", + "68385/8", + "31325/8", + "40515/4", + "34035/4", + "78101/8", + "179271/16", + "50721/8", + "10115/4", + "30081/4", + "112571/16", + "40449/8", + "72383/16", + "19625/4", + "21975/4", + "20705/4", + "7137", + "85449/8", + "4734", + "37377/8", + "39511/8", + "24085/4", + "21803/4", + "2639", + "31033/8", + "620627/16", + "285413/8", + "42531/8", + "13405/2", + "27153", + "238857/8", + "42893/4", + "9700", + "134371/8", + "52585/4", + "110719/8", + "41391/4", + "179933/16", + "20841/2", + "210825/8", + "276789/16", + "409577/16", + "338517/16", + "6597/4", + "14239/8", + "3469/2", + "3733/4", + "97273/2", + "87571/2", + "41389/4", + "12883", + "31663/8", + "32407/8", + "3888", + "9491/2", + "200159/16", + "76365/8", + "41249/4", + "98361/8", + "7655/2", + "144925/16", + "74073/16", + "45067/4", + "331309/16", + "26333/8", + "10523/4", + "2549", + "20009/8", + "20391/8", + "38051/8", + "18259/4", + "61329/8", + "123835/16", + "33855/8", + "35221/8", + "385999/16", + "36887/16", + "42427/16", + "20705/8", + "5385/2", + "41423/16", + "40369/4", + "41159/4", + "43253/8", + "5105", + "10017/2", + "36659/8", + "27377", + "18268", + "145289/4", + "278795/8", + "19523/8", + "29763/16", + "136947/4", + "36325/8", + "215703/16", + "104871/8", + "178841/16", + "63851/16", + "17421/8", + "2294", + "16339/8", + "111437/16", + "14437/8", + "31425/16", + "56091/8", + "56249/8", + "56591/8", + "6810", + "5485/2", + "7543/2", + "35191/8", + "16801/4", + "42195/16", + "19467/8", + "39385/16", + "205565/16", + "45679/16", + "9207/4", + "19325/8", + "19463/8", + "7743/2", + "17655/8", + "32381/4", + "10571/4", + "9133/4", + "2707", + "10915/4", + "20387/8", + "46655/16", + "19217/8", + "6267/2", + "39463/16", + "104665/16", + "31985/16", + "34015/8", + "70907/16", + "755273/4", + "398327/2", + "2682517/16", + "1516105/8", + "38111/16", + "18671/8", + "4799/2", + "9113/4", + "8471/4", + "14679/8", + "21601/8", + "3113/4", + "10511941/16", + "1909", + "410089/16", + "353835/16", + "20339/8", + "5771/2", + "27817/8", + "12353/4", + "7357/4", + "3549/2", + "5651615/8", + "706653/4", + "5211781/8", + "7303/4", + "227185/8", + "29611/16", + "31043/16", + "320169/2", + "2592439/16", + "13765/8", + "28639/16", + "16357/8", + "15745/8", + "129117/16", + "133925/16", + "29661/16", + "1542", + "1651", + "284645/16", + "1652", + "6227/4", + "3289/2", + "13445/8", + "38515/8", + "109747/16", + "165101/16", + "1293", + "6543", + "2793/2", + "3485/2", + "2294", + "126547/16", + "39099/8", + "13019/2", + "1394", + "51073/8", + "1923", + "3393/2", + "1602", + "124525/16", + "20967/4", + "48623/8", + "1521", + "18063/2", + "3105/2", + "1393", + "2629/2", + "30409", + "238061/16", + "363139/16", + "8693/2", + "67223/8", + "3237/2", + "2915", + "1601", + "2631/4", + "210019/4", + "141125/4", + "3283", + "275079/8", + "2795/2", + "10587/2", + "2107", + "65893/2", + "14914", + "421851/16", + "9703/2", + "43585/4", + "1739", + "2985/2", + "3527/2", + "244061/8", + "107119/8", + "167627/8", + "12037/2", + "49737/8", + "3219/2", + "3127/2", + "1249", + "19997/4", + "260843/16", + "140073/8", + "3271/2", + "7098", + "4831/2", + "1267", + "2859/2", + "69139/8", + "74993/16", + "56887/8", + "2959/2", + "110189/16", + "1677", + "3231/2", + "1844", + "23345", + "57451/8", + "46557/4", + "1375", + "17831/2", + "1691", + "2873/2", + "1580", + "70007/8", + "92127/16", + "142063/16", + "3581", + "67509/8", + "1497", + "1524", + "3115/2", + "40337/8", + "108725/16", + "110375/8", + "3015/2", + "11175/2", + "3153/2", + "3293/2", + "3865/2", + "129301/16", + "19913/4", + "82733/8", + "1424", + "7063", + "3669/2", + "2096", + "1230", + "149611/16", + "612", + "188123/16", + "7317/2", + "149573/16", + "2919/2", + "1689", + "2901", + "35141/16", + "36537/16", + "3701/2", + "18285/8", + "21859/8", + "331", + "10388", + "609", + "11201/4", + "1875/2", + "216", + "1873/2", + "1671", + "7505/4", + "2121/2", + "669", + "1095", + "1128", + "500", + "749/2", + "1056", + "1235", + "1995/2", + "4723/2", + "802", + "1225", + "1172", + "2155/2", + "3267/2", + "187669/16", + "7200", + "42051/4", + "15047/4", + "7553/2", + "136553/8", + "128927/8", + "133913/8", + "11241/2", + "10421/4", + "4739/2", + "3677/4", + "604", + "504", + "656", + "143", + "148", + "144", + "148", + "675", + "382", + "3639/4", + "3487/4", + "589", + "147", + "145", + "433", + "117", + "647", + "3439/4", + "6567/2", + "1817", + "16379/2", + "851/2", + "147", + "8201/2", + "77069/2", + "298" + ], + "independent_tensor_coordinates": 262144, + "source_assertions_enabled": true + }, + "tensor": { + "coordinates": 262144, + "active_stages": 16, + "output_sha256": "1dea5d76312e7c6096f4b377027e18b2172addab31e27e26dc46c1f781ccbf47", + "exact_output_sha256": "6f8fc265257b97c1aff1299f4dff58106269aae8fefdf4aff099bd193b146674" + }, + "source_corruption_controls": 3, + "selected_frontier_changed": false +} diff --git a/research/selected-absolute-stochastic-caller/SOURCES.json b/research/selected-absolute-stochastic-caller/SOURCES.json new file mode 100644 index 0000000000..dc4e6683f6 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/p104-helper470-twin-rung-removal/WORD.json.gz", + "usage": "input", + "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760", + "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ] +} diff --git a/research/selected-absolute-stochastic-caller/TASK.json b/research/selected-absolute-stochastic-caller/TASK.json new file mode 100644 index 0000000000..b15b645651 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Construct the complete selected-word same-grid stochastic numerical caller with an absolute-error theorem, all native edge bindings and an explicit retained-state inverse bill.", + "scope_change_reason": "The relative completed-error premise of PR6526 is not supplied by PR6532 at small lattice inputs. Use its absolute local allowance and pay retained inverse state instead.", + "bottleneck_link": "The precision_tape and native_all_columns interfaces need a caller whose local numerical contract is actually supplied. This joins that numerical contract but leaves physical and fast-recursive admission open.", + "budget_minutes": 90, + "stop_rule": "Stop at the complete numerical caller, independent source/endpoint checks and exact absolute budgets. Do not count the direct reference as a physical or accelerated implementation.", + "outcome": "completed", + "evidence": "PROOF.md and RESULT.json; VERIFY.json registers normal and optimized exact replays.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. No subagents.", + "open_questions": [ + { + "question": "Can an accelerated reversible native child implement this same-grid absolute-error contract with a paid retained-state schedule?", + "why_it_matters": "The direct numerical execution does not supply the selected fast child, physical tape or outer invoice.", + "first_step": "Bind one exact fast child to the completed numerical ABI and include every seed, residue, COPY/CLEAR value and cleanup cost.", + "blocked_by": "No such fast physical implementation is supplied here; the all-size numerical proof alone does not price one." + } + ] +} diff --git a/research/selected-absolute-stochastic-caller/VERIFY.json b/research/selected-absolute-stochastic-caller/VERIFY.json new file mode 100644 index 0000000000..2dce94c653 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/VERIFY.json @@ -0,0 +1,40 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [ + "numpy==2.3.4" + ], + "inputs": [ + "research/p104-helper470-twin-rung-removal/WORD.json.gz", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Regenerate and check every native edge, every final signed coefficient, the complete numerical caller and inverse, independent decoded endpoints, full tensor, exact moments and semantic/source rejection controls. Source assertions stay enabled in normal subprocesses." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Regenerate and check every native edge, every final signed coefficient, the complete numerical caller and inverse, independent decoded endpoints, full tensor, exact moments and semantic/source rejection controls. Source assertions stay enabled in normal subprocesses." + } + ] +} diff --git a/research/selected-absolute-stochastic-caller/endpoint.py b/research/selected-absolute-stochastic-caller/endpoint.py new file mode 100644 index 0000000000..a41b76fd1f --- /dev/null +++ b/research/selected-absolute-stochastic-caller/endpoint.py @@ -0,0 +1,70 @@ +"""Decode the numerical endpoint with the independent source coordinate code.""" + +import gzip +import hashlib +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +import numpy as np + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + + +def need(ok,label): + if not ok: + raise ValueError(label) + + +def main(): + need(__debug__, 'source assertions enabled') + for item in json.loads((HERE/'SOURCES.json').read_text())['files']: + if item['usage']=='input': + need(hashlib.sha256((ROOT/item['path']).read_bytes()).hexdigest()==item['sha256'], 'source bytes') + sys.path.insert(0,str(ROOT/'research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow')) + import bw_gauss + folder=Path(sys.argv[1]);data=json.loads((folder/'fixture.json').read_text()) + word=json.loads(gzip.decompress((ROOT/'research/p104-helper470-twin-rung-removal/WORD.json.gz').read_bytes())) + def decode(values,frame): + need(len(values)==512 and max(abs(v) for z in values for v in z) < 1 << 30, 'oracle integer input bound') + x=np.array(values,dtype=np.int64) + a,b,d=bw_gauss.frame((x[:,0,None],x[:,1,None],0),word['frames'][frame],9,-1) + need(d<=9, 'source frame denominator') + return [(Q(int(r),1 << d),Q(int(i),1 << d)) for r,i in zip(a[:,0],b[:,0])] + initial=[decode(data['initial'][str(r)],frame) for r,frame in enumerate(word['initial'])] + errors=[] + for r,frame in enumerate(word['final']): + actual=decode(data['output'][str(r)],frame) + other=initial[r-112] if r-112 in word['live'] else [(Q(0),Q(0))]*512 + err=sum((x-a-c)**2+(y-b-d)**2 for (x,y),(a,b),(c,d) in zip(actual,initial[r],other)) + errors.append(err) + tensor=json.loads((folder/'tensor-fixture.json').read_text()) + values=np.array(tensor['initial'],dtype=np.int64) + re,im=values[:,0].reshape(512,512),values[:,1].reshape(512,512) + old,new=tensor['edge'] + for axis in range(2): + if axis==0: + re,im=re.T,im.T + need(np.max(np.abs(re)) < 1 << 25 and np.max(np.abs(im)) < 1 << 25, + 'tensor oracle integer input bound') + re,im,exponent=bw_gauss.frame(bw_gauss.frame((re,im,0),word['frames'][old],9,-1), + word['frames'][new],9) + need(exponent<=18 and np.all(re % (1 << exponent)==0) and + np.all(im % (1 << exponent)==0), 'exact tensor grid') + re,im=re//(1 << exponent),im//(1 << exponent) + if axis==0: + re,im=re.T,im.T + actual=np.array(tensor['output'],dtype=np.int64) + need(np.array_equal(re.reshape(-1),actual[:,0]) and np.array_equal(im.reshape(-1),actual[:,1]), + 'independent full tensor operator') + (folder/'endpoint.json').write_text(json.dumps({'decoded_public_fields':len(errors), + 'max_squared_error':[str(max(errors)),errors.index(max(errors))], + 'squared_errors':[str(v) for v in errors], + 'independent_tensor_coordinates':len(actual), + 'source_assertions_enabled':__debug__},indent=2)+'\n') + + +if __name__=='__main__': + main() diff --git a/research/selected-absolute-stochastic-caller/ledger.py b/research/selected-absolute-stochastic-caller/ledger.py new file mode 100644 index 0000000000..728b290117 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/ledger.py @@ -0,0 +1,190 @@ +"""Compute exact signed defect transfers and check them in reverse order. + +The forward/reverse method credits the selected-word analysis in PR6526. +""" + +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from math import isqrt + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def add(row, other, q): + for j, v in other.items(): + z = row.get(j, Q(0))+q*v + if z: + row[j] = z + else: + row.pop(j,None) + + +def digest(row): + return sha256(''.join(f'{j}:{v};' for j,v in sorted(row.items())).encode()).hexdigest() + + +def noise_weight(e, rank): + if e[0] == 'MOVE': + return rank, 0 + if e[0] in {'ADD','SCALE'} and Q(e[-2]).denominator > 1: + return 0, 1 + return 0, 0 + + +def score(row, weights): + out = [Q(0)]*4 + for j,c in row.items(): + m,s = weights[j] + out = [a+b for a,b in zip(out,(c*c*m,c*c*s,abs(c)*m,abs(c)*s))] + return out + + +def reverse(word, weights, cut, role): + row, errors = {role:Q(1)}, {} + for j in reversed(range(cut)): + e = word['program'][j] + op,r = e[:2] + c = row.get(r,Q(0)) + if c and any(weights[j]): + errors[j] = c + if op in {'INIT','CLEAR'}: + row.pop(r,None) + elif op == 'SCALE' and c: + row[r] = c*Q(e[-2]) + elif op in {'ADD','COPY'}: + if c: + add(row,{e[2]:c},Q(e[-2])) + if op == 'COPY': + row.pop(r,None) + return row, errors + + +def analyze(word, ranks): + public = word['public'] + count = public+word['owned_fields'] + rows = [{} for _ in range(count)] + ideal = [{r:Q(1)} if r=public and r not in live and frames[r] is None, 'INIT') + live.add(r) + frames[r] = e[2] + else: + need(r in live and frames[r]==e[2], 'CLEAR') + erasures.append([j,r,sum(map(abs,ideal[r].values()),Q(0))]) + live.remove(r) + frames[r] = None + rows[r],ideal[r],scores[r] = {},{},[Q(0)]*4 + else: + need(op in {'ADD','COPY','SCALE'}, 'opcode') + q=Q(e[-2]) + need(q and q.denominator & (q.denominator-1)==0 and frames[r]==e[-1], 'scalar ABI') + bits=q.denominator.bit_length()-1 + scalar_seed_bits += bits + if op == 'SCALE': + need(abs(q.numerator)==1 or q.denominator==1, 'division numerator') + scale_residue_units += bits + rows[r] = {k:q*v for k,v in rows[r].items()} + ideal[r] = {k:q*v for k,v in ideal[r].items()} + scores[r] = [v*(q*q if k<2 else abs(q)) for k,v in enumerate(scores[r])] + else: + s=e[2] + need(s!=r and frames[s]==frames[r], 'scalar operands') + if op=='COPY': + need(r in live and not ideal[r] and q==1, 'selected COPY') + rows[r],ideal[r],scores[r] = rows[s].copy(),ideal[s].copy(),scores[s].copy() + else: + add(ideal[r],ideal[s],q) + for k,v in rows[s].items(): + old=rows[r].get(k,Q(0));new=old+q*v + m,sweight=weights[k] + delta=(new*new-old*old,abs(new)-abs(old)) + scores[r]=[a+b for a,b in zip(scores[r],(delta[0]*m,delta[0]*sweight,delta[1]*m,delta[1]*sweight))] + if new: + rows[r][k]=new + else: + rows[r].pop(k,None) + if any(weights[j]): + rows[r][j]=Q(1) + m,s=weights[j] + scores[r]=[a+b for a,b in zip(scores[r],(m,s,m,s))] + norm=sum(map(abs,ideal[r].values()),Q(0)) + if norm>ideal_peak[0]: + ideal_peak=[norm,j+1,r] + m,s,am,ass=scores[r] + for k,v in enumerate((m,s,am,ass,m+s,m+4*s,am+2*ass)): + if v>peaks[k][0]: + peaks[k]=[v,j+1,r] + need(not live and frames[:public]==word['final'], 'all final frames') + for r in range(count): + target={r:Q(1)} if r 45606*(1 << 40): + need(Q(1 << 32,512*q) >= x, 'binary grid tail follows from exact exponential bound') + return {'normalized_width_one_rms_guard':rms,'normalized_width_one_tail_guard':g, + 'tail_exponent':x,'positive_taylor_degree':64,'positive_taylor_lower':lower, + 'failure_bound':'2^-40','union_changed_fields':22803, + 'width_one_binary_grid_rms_bits':next(t for t in range(32) if 256*peaks[4][0] < (1 << (2*t))), + 'width_one_binary_grid_tail_bits':16, + 'width_one_binary_grid_tail_exponent':Q(1 << 32,512*q)} + raise ValueError('tail certificate range') diff --git a/research/selected-absolute-stochastic-caller/produce.py b/research/selected-absolute-stochastic-caller/produce.py new file mode 100644 index 0000000000..5ed6163e90 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/produce.py @@ -0,0 +1,102 @@ +"""Check every distinct selected native edge with two exact representations.""" + +import gzip +import hashlib +import json +import sys +from collections import Counter +from pathlib import Path + +import numpy as np + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(HERE)) +from sampler import need, route + + +def matrix_monomial(z, rec): + real, imag = z + dest, phases = route(rec) + rr, ii = np.empty_like(real), np.empty_like(imag) + for src, (dst, p) in enumerate(zip(dest, phases)): + a, b = real[src], imag[src] + if p == 0: + rr[dst], ii[dst] = a, b + elif p == 1: + rr[dst], ii[dst] = -b, a + elif p == 2: + rr[dst], ii[dst] = -a, -b + else: + rr[dst], ii[dst] = b, -a + return rr, ii + + +def recipe_matrix(rec): + re, im = matrix_monomial((np.eye(512, dtype=np.int64), np.zeros((512,512), dtype=np.int64)), rec['right']) + for axis in range(rec['rank']): + lo = np.array([j for j in range(512) if not j >> axis & 1]) + hi = lo ^ (1 << axis) + sr, si, dr, di = re[lo]+re[hi], im[lo]+im[hi], re[lo]-re[hi], im[lo]-im[hi] + re[lo], im[lo], re[hi], im[hi] = sr-di, si+dr, sr+di, si-dr + return matrix_monomial((re, im), rec['left']) + + +def main(): + need(__debug__, 'source assertions remain enabled') + for item in json.loads((HERE/'SOURCES.json').read_text())['files']: + if item['usage'] == 'input': + need(hashlib.sha256((ROOT/item['path']).read_bytes()).hexdigest() == item['sha256'], 'source bytes') + src = ROOT/'research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow' + sys.path[:0] = [str(src), str(src/'vendor/clifford')] + import bw_gauss + from clifford_exact import canonical_frame, lower_child + word = json.loads(gzip.decompress((ROOT/'research/p104-helper470-twin-rung-removal/WORD.json.gz').read_bytes())) + charts, recipes, ranks, counts = {}, {}, [], Counter() + controls = 0 + for e in word['program']: + if e[0] != 'MOVE': + ranks.append(0) + continue + old, new = e[2:4] + key = f'{old},{new}' + if key not in recipes: + for t in (old,new): + if t not in charts: + charts[t] = canonical_frame(9, word['frames'][t]) + rec, compiled = lower_child(charts[old].adjoint().then(charts[new])) + need(1 <= rec['rank'] <= 8, 'selected native rank') + actual_re, actual_im = recipe_matrix(rec) + re, im, exponent = bw_gauss.frame( + bw_gauss.frame(bw_gauss.eye(9), word['frames'][old], 9, -1), + word['frames'][new], 9) + need(exponent <= 18 and np.max(np.abs(re)) <= 1 << 18 and + np.max(np.abs(im)) <= 1 << 18 and np.max(np.abs(actual_re)) <= 1 << 8 and + np.max(np.abs(actual_im)) <= 1 << 8, 'integer matrix range') + need(np.array_equal(actual_re << exponent, re << rec['rank']) and + np.array_equal(actual_im << exponent, im << rec['rank']), 'all columns of every native edge') + if not recipes: + need(not (np.array_equal(-actual_im << exponent, re << rec['rank']) and + np.array_equal(actual_re << exponent, im << rec['rank'])), 'global phase mutation is rejected') + need(not (np.array_equal(actual_re << exponent, re << rec['rank']) and + np.array_equal(-actual_im << exponent, im << rec['rank'])), 'conjugate mutation is rejected') + controls = 2 + recipes[key] = rec + rank = recipes[key]['rank'] + ranks.append(rank) + counts[rank] += 1 + out = Path(sys.argv[1]) + data = {'recipes':recipes,'ranks':ranks} + encoded = (json.dumps(data,sort_keys=True,separators=(',',':'))+'\n').encode() + (out/'native.json').write_bytes(encoded) + (out/'source-summary.json').write_text(json.dumps({ + 'events':len(word['program']),'distinct_edges':len(recipes),'frames':len(charts), + 'full_operator_columns':len(recipes)*512,'move_events':sum(counts.values()), + 'rank_counts':{str(k):v for k,v in sorted(counts.items())}, + 'native_stage_count_per_tensor_axis':sum(k*v for k,v in counts.items()), + 'all_recipe_sha256':hashlib.sha256(encoded).hexdigest(), + 'source_assertions_enabled':__debug__,'operator_mutation_controls':controls},indent=2)+'\n') + + +if __name__ == '__main__': + main() diff --git a/research/selected-absolute-stochastic-caller/sampler.py b/research/selected-absolute-stochastic-caller/sampler.py new file mode 100644 index 0000000000..2f7ba4b7d0 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/sampler.py @@ -0,0 +1,226 @@ +"""Run the integer caller and retain every value required by its inverse. + +The pair map and route formula extend Ali Romman's PR6532 implementation. +""" + +from fractions import Fraction as Q +from hashlib import sha256 + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def phase(z, p): + a, b = z + p %= 4 + if p == 0: + return a, b + if p == 1: + return -b, a + if p == 2: + return -a, -b + return b, -a + + +def pair(x, y, seed, inverse=False): + need(type(seed) is int and seed in (-1, 1), "pair seed") + a, b = x + c, d = y + sr, si, dr, di = a+c, b+d, a-c, b-d + cr = ci = 0 + if (sr+si) % 2: + if sr % 2: + cr = seed if sr > 0 else -seed + else: + ci = seed if si > 0 else -seed + dr, di = dr-cr, di-ci + dr, di = (di, -dr) if inverse else (-di, dr) + dr, di = dr+cr, di+ci + nums = sr+dr, si+di, sr-dr, si-di + need(all(v % 2 == 0 for v in nums), "integer pair output") + a, b, c, d = (v//2 for v in nums) + return (a, b), (c, d) + + +def route(rec): + dest, phases = [], [] + n = len(rec["matrix_rows"]) + for x in range(1 << n): + dest.append(sum(((row & x).bit_count() % 2) << j + for j, row in enumerate(rec["matrix_rows"])) ^ rec["offset"]) + p = rec["phase"] + for j in range(n): + if x >> j & 1: + p += rec["linear_Z4"][j] + p += 2 * (((rec["quadratic_rows"][j] >> (j+1)) & (x >> (j+1))).bit_count() % 2) + phases.append(p % 4) + need(sorted(dest) == list(range(1 << n)), "monomial permutation") + return dest, phases + + +def monomial(values, routing, f, inverse=False): + dest, phases = routing + out = [None] * len(values) + for src in range(len(values)): + dst, p = 0, 0 + for axis in range(f): + digit = (src >> (9*axis)) & 511 + dst |= dest[digit] << (9*axis) + p += phases[digit] + if inverse: + out[src] = phase(values[dst], -p) + else: + out[dst] = phase(values[src], p) + return out + + +def native(values, routes, rank, seeds, f=1, inverse=False): + need(type(f) is int and f >= 1 and len(values) == 512**f, "native shape") + axes = [9*j+k for j in range(f) for k in range(rank)] + need(len(seeds) == len(axes), "native seed count") + left, right = routes + out = monomial(values, left if inverse else right, f, inverse) + order = reversed(range(len(axes))) if inverse else range(len(axes)) + for j in order: + stride = 1 << axes[j] + for start in range(0, len(out), 2*stride): + for low in range(stride): + a, b = start+low, start+low+stride + out[a], out[b] = pair(out[a], out[b], seeds[j], inverse) + return monomial(out, right if inverse else left, f, inverse) + + +def quantized(values, q, seed): + d = q.denominator + need(type(seed) is int and 0 <= seed < d, "scalar seed") + return [((q.numerator*a+seed)//d, (q.numerator*b+seed)//d) for a, b in values] + + +def pack_remainders(values, q, seed): + d = q.denominator + bits = d.bit_length()-1 + need(abs(q.numerator) == 1 and bits > 0, "division residue contract") + out = bytearray((2*len(values)*bits+7)//8) + pos = 0 + for z in values: + for v in z: + residue = (q.numerator*v+seed) % d + for k in range(bits): + out[pos//8] |= ((residue >> k) & 1) << (pos % 8) + pos += 1 + return bytes(out) + + +def restore_division(values, q, seed, packed): + d = q.denominator + bits = d.bit_length()-1 + need(abs(q.numerator) == 1 and bits > 0, "division residue contract") + size = 2*len(values)*bits + need(len(packed) == (size+7)//8, "residue byte length") + need(not size % 8 or packed[-1] >> (size % 8) == 0, "residue padding") + out, pos = [], 0 + for z in values: + value = [] + for v in z: + rem = 0 + for k in range(bits): + rem |= ((packed[pos//8] >> (pos % 8)) & 1) << k + pos += 1 + value.append(q.numerator * (d*v+rem-seed)) + out.append(tuple(value)) + return out + + +def digest(fields): + h = sha256() + for r, values in sorted(fields.items()): + h.update(f"{r}:".encode()) + for a, b in values: + h.update(f"{a},{b};".encode()) + return h.hexdigest() + + +def execute(word, recipes, initial, seed_value, f=1): + """Use supplied seeds; a deterministic test stream is not a randomness proof.""" + fields = {r: list(v) for r, v in initial.items()} + tape, routes = [], {} + peak_fields = len(fields) + retained_fields = scalar_seed_bits = native_seed_bits = residue_bits = 0 + max_abs = max(abs(t) for v in fields.values() for z in v for t in z) + for j, e in enumerate(word["program"]): + op, r = e[:2] + if op == "INIT": + need(r not in fields, "allocate unused field") + fields[r] = [(0, 0)] * (512**f) + record = None + elif op == "CLEAR": + record = fields.pop(r) + retained_fields += 1 + elif op == "COPY": + need(Q(e[3]) == 1, "selected exact COPY coefficient") + record = fields[r] + fields[r] = list(fields[e[2]]) + retained_fields += 1 + elif op == "MOVE": + key = f"{e[2]},{e[3]}" + rec = recipes[key] + if key not in routes: + routes[key] = (route(rec['left']), route(rec['right'])) + raw = [seed_value(j, k, 2) for k in range(rec['rank']*f)] + need(all(type(v) is int and v in (0,1) for v in raw), 'fresh bit range') + record = [1 if v else -1 for v in raw] + native_seed_bits += len(record) + fields[r] = native(fields[r], routes[key], rec['rank'], record, f) + else: + need(op in {'ADD', 'SCALE'}, "known scalar instruction") + q = Q(e[-2]) + seed = seed_value(j, 0, q.denominator) if q.denominator > 1 else 0 + scalar_seed_bits += q.denominator.bit_length()-1 + record = (seed, None) + if op == 'ADD': + inc = quantized(fields[e[2]], q, seed) + fields[r] = [(a+c, b+d) for (a,b),(c,d) in zip(fields[r],inc)] + else: + if q.denominator > 1: + packed = pack_remainders(fields[r], q, seed) + residue_bits += 2*len(fields[r])*(q.denominator.bit_length()-1) + record = (seed, packed) + fields[r] = quantized(fields[r], q, seed) + tape.append(record) + peak_fields = max(peak_fields, len(fields)+retained_fields) + if r in fields: + max_abs = max(max_abs, max(abs(t) for z in fields[r] for t in z)) + output = {r: list(v) for r, v in fields.items()} + for j in reversed(range(len(tape))): + e, record = word['program'][j], tape[j] + tape[j] = None + op, r = e[:2] + if op == 'INIT': + need(all(z == (0,0) for z in fields.pop(r)), "reverse allocation is zero") + elif op == 'CLEAR': + need(r not in fields, "restore cleared field") + fields[r] = record + elif op == 'COPY': + need(fields[r] == fields[e[2]], "reverse COPY value") + fields[r] = record + elif op == 'MOVE': + key = f"{e[2]},{e[3]}" + fields[r] = native(fields[r], routes[key], recipes[key]['rank'], record, f, True) + else: + q, (seed, packed) = Q(e[-2]), record + if op == 'ADD': + inc = quantized(fields[e[2]], q, seed) + fields[r] = [(a-c, b-d) for (a,b),(c,d) in zip(fields[r],inc)] + elif q.denominator > 1: + fields[r] = restore_division(fields[r], q, seed, packed) + else: + need(all(t % q.numerator == 0 for z in fields[r] for t in z), "reverse integer scale") + fields[r] = [(a//q.numerator,b//q.numerator) for a,b in fields[r]] + need(fields == initial, "literal complete inverse") + return output, {'initial_sha256':digest(initial),'output_sha256':digest(output), + 'retained_field_values':retained_fields,'peak_live_and_retained_fields':peak_fields, + 'native_seed_bits':native_seed_bits,'scalar_seed_bits':scalar_seed_bits, + 'division_residue_bits':residue_bits,'max_absolute_payload':max_abs, + 'all_events_forward_and_reverse':len(tape)} diff --git a/research/selected-absolute-stochastic-caller/verify.py b/research/selected-absolute-stochastic-caller/verify.py new file mode 100644 index 0000000000..aea6fd3df8 --- /dev/null +++ b/research/selected-absolute-stochastic-caller/verify.py @@ -0,0 +1,177 @@ +"""Verify the source join, all signed transfers, moments and retained inverse.""" + +import gzip +import hashlib +import itertools +import json +import subprocess +import sys +import tempfile +from fractions import Fraction as Q +from pathlib import Path + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +sys.path.insert(0,str(HERE)) +from sampler import execute, native, need, pack_remainders, pair, quantized, restore_division, route +from ledger import analyze, reverse, tail_certificate + + +def check_source(data, expected): + need(hashlib.sha256(data).hexdigest()==expected,'source hash mismatch') + + +def cpair(x,y): + a,b=x;c,d=y + return ((a-b+c+d)/2,(a+b+d-c)/2),((a+b+c-d)/2,(b-a+c+d)/2) + + +def finite(word): + pairs=0 + for a,b,c,d in itertools.product(range(-3,4),repeat=4): + x,y=(a,b),(c,d) + actual=[pair(x,y,s) for s in (-1,1)] + for s,out in zip((-1,1),actual): + need(pair(*out,s,True)==(x,y),'pair exact inverse') + target=cpair(tuple(map(Q,x)),tuple(map(Q,y))) + need(all(Q(actual[0][j][k]+actual[1][j][k],2)==target[j][k] + for j in range(2) for k in range(2)),'pair exact mean') + mse=sum((Q(out[j][k])-target[j][k])**2 for out in actual for j in range(2) for k in range(2))/2 + need(mse==((a+b+c+d)%2),'pair conditional second moment') + pairs+=1 + wide=0 + for bit in (0,1,17,64,257,1024): + for signs in itertools.product((-1,1),repeat=2): + x=(signs[0]*(1 << bit)+1,-(1 << bit));y=(signs[1]*(1 << bit),3) + for s in (-1,1): + need(pair(*pair(x,y,s),s,True)==(x,y),'unbounded integer pair') + wide+=1 + scalars=0 + coefficients=sorted({Q(e[-2]) for e in word['program'] if e[0] in {'ADD','SCALE'}}) + for q in coefficients: + for v in range(-32,33): + outputs=[quantized([(v,-v)],q,u)[0] for u in range(q.denominator)] + need(sum(x for x,y in outputs)==q.numerator*v,'scalar exact mean real') + need(sum(y for x,y in outputs)==-q.numerator*v,'scalar exact mean imaginary') + need(sum((Q(x)-q*v)**2+(Q(y)+q*v)**2 for x,y in outputs)/q.denominator<=Q(1,2),'scalar variance') + scalars+=1 + divisions=0 + for q in sorted({Q(e[2]) for e in word['program'] if e[0]=='SCALE' and Q(e[2]).denominator>1}): + for v in range(-128,129): + for u in range(q.denominator): + original=[(v,1-v)] + packed=pack_remainders(original,q,u) + need(restore_division(quantized(original,q,u),q,u,packed)==original,'division exact residue inverse') + divisions+=1 + # Exhaust every fresh seed of a mixed two-pair/scalar trajectory. + x,y=(Q(1),Q(1)),(Q(2),Q(-1)) + a,b=cpair(x,y);a=tuple(v-Q(3,4)*w for v,w in zip(a,b));b=tuple(v/2 for v in b) + expected=cpair(a,b) + totals=[[Q(0),Q(0)],[Q(0),Q(0)]] + cases=0 + for s,u,v,t in itertools.product((-1,1),range(4),range(2),(-1,1)): + a,b=pair((1,1),(2,-1),s) + inc=quantized([b],Q(-3,4),u)[0];a=tuple(x+y for x,y in zip(a,inc)) + rem=pack_remainders([b],Q(1,2),v);b=quantized([b],Q(1,2),v)[0] + out=pair(a,b,t) + for j in range(2): + for k in range(2):totals[j][k]+=out[j][k] + a,b=pair(*out,t,True);b=restore_division([b],Q(1,2),v,rem)[0] + inc=quantized([b],Q(-3,4),u)[0];a=tuple(x-y for x,y in zip(a,inc)) + need(pair(a,b,s,True)==((1,1),(2,-1)),'mixed inverse') + cases+=1 + need(all(totals[j][k]/cases==expected[j][k] for j in range(2) for k in range(2)),'mixed exact mean') + controls=0 + try: + pair((0,0),(1,0),True) + except ValueError: + controls+=1 + else: + raise ValueError('boolean pair seed accepted') + original=[(1,0)] + q=Q(1,2) + need(quantized(original,q,0)==quantized([(0,0)],q,0),'lost division residue collision') + controls+=1 + need(pair(*pair((0,0),(1,0),1),-1,True)!=((0,0),(1,0)),'wrong inverse seed witness') + controls+=1 + reused=Q(0);fresh=Q(0) + for u in range(2): + x=quantized([(1,0)],q,u)[0][0] + reused+=Q(quantized([(x,0)],q,u)[0][0])-Q(x,2) + for v in range(2):fresh+=Q(quantized([(x,0)],q,v)[0][0])-Q(x,2) + need(reused/2==Q(1,4) and fresh==0,'adaptive reused-seed bias') + controls+=1 + toy={'program':[['MOVE',0,0,1,False],['COPY',1,0,'1',1],['ADD',0,1,'-1',1],['CLEAR',1,1]]} + weights=[(1,0),(0,0),(0,0),(0,0)] + _,row=reverse(toy,weights,3,0) + need(not row,'signed COPY cancellation') + _,row=reverse(toy,weights,4,1) + need(not row,'CLEAR kills later error') + _,row=reverse(toy,weights,2,1) + need(row=={0:Q(1)},'CLEAR does not erase earlier prefix excursion') + controls+=3 + return {'pair_inputs':pairs,'wide_pair_roundtrips':wide,'scalar_contexts':scalars, + 'division_roundtrips':divisions,'mixed_seed_trajectories':cases,'semantic_controls':controls} + + +def run(generate=False): + corrupt=0 + for item in json.loads((HERE/'SOURCES.json').read_text())['files']: + if item['usage']=='input': + data=(ROOT/item['path']).read_bytes();check_source(data,item['sha256']) + try: + check_source(data+b'!',item['sha256']) + except ValueError: + corrupt+=1 + else: + raise ValueError('corrupt source accepted') + word=json.loads(gzip.decompress((ROOT/'research/p104-helper470-twin-rung-removal/WORD.json.gz').read_bytes())) + with tempfile.TemporaryDirectory() as tmp: + folder=Path(tmp) + subprocess.run([sys.executable,'-I','-Werror','-B',str(HERE/'produce.py'),tmp],check=True,timeout=900) + sources=json.loads((folder/'source-summary.json').read_text());bound=json.loads((folder/'native.json').read_text()) + ledger,weights=analyze(word,bound['ranks']);ledger['tail']=tail_certificate(ledger['prefix_peaks']) + checks=finite(word) + initial={r:[(((r*17+j*29)%23)-11,((r*31+j*7)%19)-9) for j in range(512)] for r in range(word['public'])} + def seeds(j,k,d): + return int.from_bytes(hashlib.sha256(f'selected-absolute-fixture:{j}:{k}'.encode()).digest()[:8],'little')%d + output,caller=execute(word,bound['recipes'],initial,seeds) + need(caller['native_seed_bits']==ledger['native_seed_bits_per_tensor_axis'] and + caller['scalar_seed_bits']==ledger['scalar_seed_bits'] and + caller['division_residue_bits']==512*ledger['division_residue_bits_per_complex_coordinate'],'exact caller budget') + (folder/'fixture.json').write_text(json.dumps({'initial':initial,'output':output},separators=(',',':'))) + key,rec=next((key,r) for key,r in bound['recipes'].items() if r['rank']==8) + values=[((j%11)-5,(j%7)-3) for j in range(512**2)] + bits=[1 if k%3 else -1 for k in range(16)] + routes=route(rec['left']),route(rec['right']) + transformed=native(values,routes,8,bits,2) + need(native(transformed,routes,8,bits,2,True)==values,'rank-eight full tensor inverse') + tensor={'coordinates':len(values),'active_stages':16, + 'output_sha256':hashlib.sha256(repr(transformed).encode()).hexdigest()} + exact_input=[(a << 16,b << 16) for a,b in values] + exact_output=native(exact_input,routes,8,bits,2) + need(native(exact_input,routes,8,[-v for v in bits],2)==exact_output,'exact tensor seed independence') + tensor['exact_output_sha256']=hashlib.sha256(repr(exact_output).encode()).hexdigest() + (folder/'tensor-fixture.json').write_text(json.dumps({'edge':list(map(int,key.split(','))), + 'initial':exact_input,'output':exact_output},separators=(',',':'))) + subprocess.run([sys.executable,'-I','-Werror','-B',str(HERE/'endpoint.py'),tmp],check=True,timeout=180) + endpoint=json.loads((folder/'endpoint.json').read_text()) + for r,err in enumerate(endpoint['squared_errors']): + am,ass=ledger['final_scores'][r][2:] + need(Q(err)<=256*(am+2*ass)**2,'decoded numerical endpoint bound') + result={'schema_version':1,'status':'PASS_SELECTED_ABSOLUTE_STOCHASTIC_CALLER', + 'base_commit':'7c49fe32c55de02c2c873655c804b16e4c3fef0a','source':sources, + 'ledger':ledger,'finite':checks,'caller':caller,'endpoint':endpoint,'tensor':tensor, + 'source_corruption_controls':corrupt,'selected_frontier_changed':False} + result=json.loads(json.dumps(result,default=str)) + if generate: + (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n') + else: + need(result==json.loads((HERE/'RESULT.json').read_text()),'committed exact receipt') + print('PASS_SELECTED_ABSOLUTE_STOCHASTIC_CALLER') + print(json.dumps({k:result[k] for k in ('source','finite','caller','tensor','source_corruption_controls')},sort_keys=True)) + + +if __name__=='__main__': + need(sys.argv[1:] in ([],['--generate']), 'verify arguments') + run(bool(sys.argv[1:]))